gdb/sol-thread.c

   1 /* Solaris threads debugging interface.
   2
   3    Copyright (C) 1996-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* This module implements a sort of half target that sits between the
  21    machine-independent parts of GDB and the /proc interface (procfs.c)
  22    to provide access to the Solaris user-mode thread implementation.
  23
  24    Solaris threads are true user-mode threads, which are invoked via
  25    the thr_* and pthread_* (native and POSIX respectivly) interfaces.
  26    These are mostly implemented in user-space, with all thread context
  27    kept in various structures that live in the user's heap.  These
  28    should not be confused with lightweight processes (LWPs), which are
  29    implemented by the kernel, and scheduled without explicit
  30    intervention by the process.
  31
  32    Just to confuse things a little, Solaris threads (both native and
  33    POSIX) are actually implemented using LWPs.  In general, there are
  34    going to be more threads than LWPs.  There is no fixed
  35    correspondence between a thread and an LWP.  When a thread wants to
  36    run, it gets scheduled onto the first available LWP and can
  37    therefore migrate from one LWP to another as time goes on.  A
  38    sleeping thread may not be associated with an LWP at all!
  39
  40    To make it possible to mess with threads, Sun provides a library
  41    called libthread_db.so.1 (not to be confused with
  42    libthread_db.so.0, which doesn't have a published interface).  This
  43    interface has an upper part, which it provides, and a lower part
  44    which we provide.  The upper part consists of the td_* routines,
  45    which allow us to find all the threads, query their state, etc...
  46    The lower part consists of all of the ps_*, which are used by the
  47    td_* routines to read/write memory, manipulate LWPs, lookup
  48    symbols, etc...  The ps_* routines actually do most of their work
  49    by calling functions in procfs.c.  */
  50
  51 #include "defs.h"
  52 #include <thread.h>
  53 #include <proc_service.h>
  54 #include <thread_db.h>
  55 #include "gdbthread.h"
  56 #include "target.h"
  57 #include "inferior.h"
  58 #include <fcntl.h>
  59 #include <sys/stat.h>
  60 #include <dlfcn.h>
  61 #include "gdbcmd.h"
  62 #include "gdbcore.h"
  63 #include "regcache.h"
  64 #include "solib.h"
  65 #include "symfile.h"
  66 #include "observer.h"
  67 #include <string.h>
  68 #include "procfs.h"
  69 #include "symtab.h"
  70 #include "minsyms.h"
  71 #include "objfiles.h"
  72
  73 struct target_ops sol_thread_ops;
  74
  75 /* Prototypes for supply_gregset etc.  */
  76 #include "gregset.h"
  77
  78 /* This struct is defined by us, but mainly used for the proc_service
  79    interface.  We don't have much use for it, except as a handy place
  80    to get a real PID for memory accesses.  */
  81
  82 struct ps_prochandle
  83 {
  84   ptid_t ptid;
  85 };
  86
  87 struct string_map
  88 {
  89   int num;
  90   char *str;
  91 };
  92
  93 static struct ps_prochandle main_ph;
  94 static td_thragent_t *main_ta;
  95 static int sol_thread_active = 0;
  96
  97 static void init_sol_thread_ops (void);
  98
  99 /* Default definitions: These must be defined in tm.h if they are to
 100    be shared with a process module such as procfs.  */
 101
 102 /* Pointers to routines from libthread_db resolved by dlopen().  */
 103
 104 static void (*p_td_log)(const int on_off);
 105 static td_err_e (*p_td_ta_new)(const struct ps_prochandle *ph_p,
 106                                td_thragent_t **ta_pp);
 107 static td_err_e (*p_td_ta_delete)(td_thragent_t *ta_p);
 108 static td_err_e (*p_td_init)(void);
 109 static td_err_e (*p_td_ta_get_ph)(const td_thragent_t *ta_p,
 110                                   struct ps_prochandle **ph_pp);
 111 static td_err_e (*p_td_ta_get_nthreads)(const td_thragent_t *ta_p,
 112                                         int *nthread_p);
 113 static td_err_e (*p_td_ta_tsd_iter)(const td_thragent_t *ta_p,
 114                                     td_key_iter_f *cb, void *cbdata_p);
 115 static td_err_e (*p_td_ta_thr_iter)(const td_thragent_t *ta_p,
 116                                     td_thr_iter_f *cb, void *cbdata_p,
 117                                     td_thr_state_e state, int ti_pri,
 118                                     sigset_t *ti_sigmask_p,
 119                                     unsigned ti_user_flags);
 120 static td_err_e (*p_td_thr_validate)(const td_thrhandle_t *th_p);
 121 static td_err_e (*p_td_thr_tsd)(const td_thrhandle_t * th_p,
 122                                 const thread_key_t key, void **data_pp);
 123 static td_err_e (*p_td_thr_get_info)(const td_thrhandle_t *th_p,
 124                                      td_thrinfo_t *ti_p);
 125 static td_err_e (*p_td_thr_getfpregs)(const td_thrhandle_t *th_p,
 126                                       prfpregset_t *fpregset);
 127 static td_err_e (*p_td_thr_getxregsize)(const td_thrhandle_t *th_p,
 128                                         int *xregsize);
 129 static td_err_e (*p_td_thr_getxregs)(const td_thrhandle_t *th_p,
 130                                      const caddr_t xregset);
 131 static td_err_e (*p_td_thr_sigsetmask)(const td_thrhandle_t *th_p,
 132                                        const sigset_t ti_sigmask);
 133 static td_err_e (*p_td_thr_setprio)(const td_thrhandle_t *th_p,
 134                                     const int ti_pri);
 135 static td_err_e (*p_td_thr_setsigpending)(const td_thrhandle_t *th_p,
 136                                           const uchar_t ti_pending_flag,
 137                                           const sigset_t ti_pending);
 138 static td_err_e (*p_td_thr_setfpregs)(const td_thrhandle_t *th_p,
 139                                       const prfpregset_t *fpregset);
 140 static td_err_e (*p_td_thr_setxregs)(const td_thrhandle_t *th_p,
 141                                      const caddr_t xregset);
 142 static td_err_e (*p_td_ta_map_id2thr)(const td_thragent_t *ta_p,
 143                                       thread_t tid,
 144                                       td_thrhandle_t *th_p);
 145 static td_err_e (*p_td_ta_map_lwp2thr)(const td_thragent_t *ta_p,
 146                                        lwpid_t lwpid,
 147                                        td_thrhandle_t *th_p);
 148 static td_err_e (*p_td_thr_getgregs)(const td_thrhandle_t *th_p,
 149                                      prgregset_t regset);
 150 static td_err_e (*p_td_thr_setgregs)(const td_thrhandle_t *th_p,
 151                                      const prgregset_t regset);
 152 \f
 153
 154 /* Return the libthread_db error string associated with ERRCODE.  If
 155    ERRCODE is unknown, return an appropriate message.  */
 156
 157 static char *
 158 td_err_string (td_err_e errcode)
 159 {
 160   static struct string_map td_err_table[] =
 161   {
 162     { TD_OK, "generic \"call succeeded\"" },
 163     { TD_ERR, "generic error." },
 164     { TD_NOTHR, "no thread can be found to satisfy query" },
 165     { TD_NOSV, "no synch. variable can be found to satisfy query" },
 166     { TD_NOLWP, "no lwp can be found to satisfy query" },
 167     { TD_BADPH, "invalid process handle" },
 168     { TD_BADTH, "invalid thread handle" },
 169     { TD_BADSH, "invalid synchronization handle" },
 170     { TD_BADTA, "invalid thread agent" },
 171     { TD_BADKEY, "invalid key" },
 172     { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
 173     { TD_NOFPREGS, "FPU register set not available for given thread" },
 174     { TD_NOLIBTHREAD, "application not linked with libthread" },
 175     { TD_NOEVENT, "requested event is not supported" },
 176     { TD_NOCAPAB, "capability not available" },
 177     { TD_DBERR, "Debugger service failed" },
 178     { TD_NOAPLIC, "Operation not applicable to" },
 179     { TD_NOTSD, "No thread specific data for this thread" },
 180     { TD_MALLOC, "Malloc failed" },
 181     { TD_PARTIALREG, "Only part of register set was written/read" },
 182     { TD_NOXREGS, "X register set not available for given thread" }
 183   };
 184   const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
 185   int i;
 186   static char buf[50];
 187
 188   for (i = 0; i < td_err_size; i++)
 189     if (td_err_table[i].num == errcode)
 190       return td_err_table[i].str;
 191
 192   xsnprintf (buf, sizeof (buf), "Unknown libthread_db error code: %d",
 193              errcode);
 194
 195   return buf;
 196 }
 197
 198 /* Return the libthread_db state string assicoated with STATECODE.
 199    If STATECODE is unknown, return an appropriate message.  */
 200
 201 static char *
 202 td_state_string (td_thr_state_e statecode)
 203 {
 204   static struct string_map td_thr_state_table[] =
 205   {
 206     { TD_THR_ANY_STATE, "any state" },
 207     { TD_THR_UNKNOWN, "unknown" },
 208     { TD_THR_STOPPED, "stopped" },
 209     { TD_THR_RUN, "run" },
 210     { TD_THR_ACTIVE, "active" },
 211     { TD_THR_ZOMBIE, "zombie" },
 212     { TD_THR_SLEEP, "sleep" },
 213     { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
 214   };
 215   const int td_thr_state_table_size =
 216     sizeof td_thr_state_table / sizeof (struct string_map);
 217   int i;
 218   static char buf[50];
 219
 220   for (i = 0; i < td_thr_state_table_size; i++)
 221     if (td_thr_state_table[i].num == statecode)
 222       return td_thr_state_table[i].str;
 223
 224   xsnprintf (buf, sizeof (buf), "Unknown libthread_db state code: %d",
 225              statecode);
 226
 227   return buf;
 228 }
 229 \f
 230
 231 /* Convert a POSIX or Solaris thread ID into a LWP ID.  If THREAD_ID
 232    doesn't exist, that's an error.  If it's an inactive thread, return
 233    DEFAULT_LWP.
 234
 235    NOTE: This function probably shouldn't call error().  */
 236
 237 static ptid_t
 238 thread_to_lwp (ptid_t thread_id, int default_lwp)
 239 {
 240   td_thrinfo_t ti;
 241   td_thrhandle_t th;
 242   td_err_e val;
 243
 244   if (ptid_lwp_p (thread_id))
 245     return thread_id;           /* It's already an LWP ID.  */
 246
 247   /* It's a thread.  Convert to LWP.  */
 248
 249   val = p_td_ta_map_id2thr (main_ta, ptid_get_tid (thread_id), &th);
 250   if (val == TD_NOTHR)
 251     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 252   else if (val != TD_OK)
 253     error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
 254
 255   val = p_td_thr_get_info (&th, &ti);
 256   if (val == TD_NOTHR)
 257     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 258   else if (val != TD_OK)
 259     error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
 260
 261   if (ti.ti_state != TD_THR_ACTIVE)
 262     {
 263       if (default_lwp != -1)
 264         return pid_to_ptid (default_lwp);
 265       error (_("thread_to_lwp: thread state not active: %s"),
 266              td_state_string (ti.ti_state));
 267     }
 268
 269   return ptid_build (ptid_get_pid (thread_id), ti.ti_lid, 0);
 270 }
 271
 272 /* Convert an LWP ID into a POSIX or Solaris thread ID.  If LWP_ID
 273    doesn't exists, that's an error.
 274
 275    NOTE: This function probably shouldn't call error().  */
 276
 277 static ptid_t
 278 lwp_to_thread (ptid_t lwp)
 279 {
 280   td_thrinfo_t ti;
 281   td_thrhandle_t th;
 282   td_err_e val;
 283
 284   if (ptid_tid_p (lwp))
 285     return lwp;                 /* It's already a thread ID.  */
 286
 287   /* It's an LWP.  Convert it to a thread ID.  */
 288
 289   if (!target_thread_alive (lwp))
 290     return pid_to_ptid (-1);    /* Must be a defunct LPW.  */
 291
 292   val = p_td_ta_map_lwp2thr (main_ta, ptid_get_lwp (lwp), &th);
 293   if (val == TD_NOTHR)
 294     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 295   else if (val != TD_OK)
 296     error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
 297
 298   val = p_td_thr_validate (&th);
 299   if (val == TD_NOTHR)
 300     return lwp;                 /* Unknown to libthread; just return LPW,  */
 301   else if (val != TD_OK)
 302     error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
 303
 304   val = p_td_thr_get_info (&th, &ti);
 305   if (val == TD_NOTHR)
 306     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 307   else if (val != TD_OK)
 308     error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
 309
 310   return ptid_build (ptid_get_pid (lwp), 0 , ti.ti_tid);
 311 }
 312 \f
 313
 314 /* Most target vector functions from here on actually just pass
 315    through to the layer beneath, as they don't need to do anything
 316    specific for threads.  */
 317
 318 /* Take a program previously attached to and detaches it.  The program
 319    resumes execution and will no longer stop on signals, etc.  We'd
 320    better not have left any breakpoints in the program or it'll die
 321    when it hits one.  For this to work, it may be necessary for the
 322    process to have been previously attached.  It *might* work if the
 323    program was started via the normal ptrace (PTRACE_TRACEME).  */
 324
 325 static void
 326 sol_thread_detach (struct target_ops *ops, const char *args, int from_tty)
 327 {
 328   struct target_ops *beneath = find_target_beneath (ops);
 329
 330   sol_thread_active = 0;
 331   inferior_ptid = pid_to_ptid (ptid_get_pid (main_ph.ptid));
 332   unpush_target (ops);
 333   beneath->to_detach (beneath, args, from_tty);
 334 }
 335
 336 /* Resume execution of process PTID.  If STEP is nozero, then just
 337    single step it.  If SIGNAL is nonzero, restart it with that signal
 338    activated.  We may have to convert PTID from a thread ID to an LWP
 339    ID for procfs.  */
 340
 341 static void
 342 sol_thread_resume (struct target_ops *ops,
 343                    ptid_t ptid, int step, enum gdb_signal signo)
 344 {
 345   struct cleanup *old_chain;
 346   struct target_ops *beneath = find_target_beneath (ops);
 347
 348   old_chain = save_inferior_ptid ();
 349
 350   inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
 351   if (ptid_get_pid (inferior_ptid) == -1)
 352     inferior_ptid = procfs_first_available ();
 353
 354   if (ptid_get_pid (ptid) != -1)
 355     {
 356       ptid_t save_ptid = ptid;
 357
 358       ptid = thread_to_lwp (ptid, -2);
 359       if (ptid_get_pid (ptid) == -2)            /* Inactive thread.  */
 360         error (_("This version of Solaris can't start inactive threads."));
 361       if (info_verbose && ptid_get_pid (ptid) == -1)
 362         warning (_("Specified thread %ld seems to have terminated"),
 363                  ptid_get_tid (save_ptid));
 364     }
 365
 366   beneath->to_resume (beneath, ptid, step, signo);
 367
 368   do_cleanups (old_chain);
 369 }
 370
 371 /* Wait for any threads to stop.  We may have to convert PTID from a
 372    thread ID to an LWP ID, and vice versa on the way out.  */
 373
 374 static ptid_t
 375 sol_thread_wait (struct target_ops *ops,
 376                  ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 377 {
 378   ptid_t rtnval;
 379   ptid_t save_ptid;
 380   struct target_ops *beneath = find_target_beneath (ops);
 381   struct cleanup *old_chain;
 382
 383   save_ptid = inferior_ptid;
 384   old_chain = save_inferior_ptid ();
 385
 386   inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
 387   if (ptid_get_pid (inferior_ptid) == -1)
 388     inferior_ptid = procfs_first_available ();
 389
 390   if (ptid_get_pid (ptid) != -1)
 391     {
 392       ptid_t save_ptid = ptid;
 393
 394       ptid = thread_to_lwp (ptid, -2);
 395       if (ptid_get_pid (ptid) == -2)            /* Inactive thread.  */
 396         error (_("This version of Solaris can't start inactive threads."));
 397       if (info_verbose && ptid_get_pid (ptid) == -1)
 398         warning (_("Specified thread %ld seems to have terminated"),
 399                  ptid_get_tid (save_ptid));
 400     }
 401
 402   rtnval = beneath->to_wait (beneath, ptid, ourstatus, options);
 403
 404   if (ourstatus->kind != TARGET_WAITKIND_EXITED)
 405     {
 406       /* Map the LWP of interest back to the appropriate thread ID.  */
 407       rtnval = lwp_to_thread (rtnval);
 408       if (ptid_get_pid (rtnval) == -1)
 409         rtnval = save_ptid;
 410
 411       /* See if we have a new thread.  */
 412       if (ptid_tid_p (rtnval)
 413           && !ptid_equal (rtnval, save_ptid)
 414           && (!in_thread_list (rtnval)
 415               || is_exited (rtnval)))
 416         add_thread (rtnval);
 417     }
 418
 419   /* During process initialization, we may get here without the thread
 420      package being initialized, since that can only happen after we've
 421      found the shared libs.  */
 422
 423   do_cleanups (old_chain);
 424
 425   return rtnval;
 426 }
 427
 428 static void
 429 sol_thread_fetch_registers (struct target_ops *ops,
 430                             struct regcache *regcache, int regnum)
 431 {
 432   thread_t thread;
 433   td_thrhandle_t thandle;
 434   td_err_e val;
 435   prgregset_t gregset;
 436   prfpregset_t fpregset;
 437   gdb_gregset_t *gregset_p = &gregset;
 438   gdb_fpregset_t *fpregset_p = &fpregset;
 439   struct target_ops *beneath = find_target_beneath (ops);
 440
 441   if (!ptid_tid_p (inferior_ptid))
 442     {
 443       /* It's an LWP; pass the request on to the layer beneath.  */
 444       beneath->to_fetch_registers (beneath, regcache, regnum);
 445       return;
 446     }
 447
 448   /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t.  */
 449   thread = ptid_get_tid (inferior_ptid);
 450   if (thread == 0)
 451     error (_("sol_thread_fetch_registers: thread == 0"));
 452
 453   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
 454   if (val != TD_OK)
 455     error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
 456            td_err_string (val));
 457
 458   /* Get the general-purpose registers.  */
 459
 460   val = p_td_thr_getgregs (&thandle, gregset);
 461   if (val != TD_OK && val != TD_PARTIALREG)
 462     error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
 463            td_err_string (val));
 464
 465   /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
 466      and %sp are saved (by a thread context switch).  */
 467
 468   /* And, now the floating-point registers.  */
 469
 470   val = p_td_thr_getfpregs (&thandle, &fpregset);
 471   if (val != TD_OK && val != TD_NOFPREGS)
 472     error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
 473            td_err_string (val));
 474
 475   /* Note that we must call supply_gregset and supply_fpregset *after*
 476      calling the td routines because the td routines call ps_lget*
 477      which affect the values stored in the registers array.  */
 478
 479   supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
 480   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
 481 }
 482
 483 static void
 484 sol_thread_store_registers (struct target_ops *ops,
 485                             struct regcache *regcache, int regnum)
 486 {
 487   thread_t thread;
 488   td_thrhandle_t thandle;
 489   td_err_e val;
 490   prgregset_t gregset;
 491   prfpregset_t fpregset;
 492
 493   if (!ptid_tid_p (inferior_ptid))
 494     {
 495       struct target_ops *beneath = find_target_beneath (ops);
 496
 497       /* It's an LWP; pass the request on to the layer beneath.  */
 498       beneath->to_store_registers (beneath, regcache, regnum);
 499       return;
 500     }
 501
 502   /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t.  */
 503   thread = ptid_get_tid (inferior_ptid);
 504
 505   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
 506   if (val != TD_OK)
 507     error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
 508            td_err_string (val));
 509
 510   if (regnum != -1)
 511     {
 512       /* Not writing all the registers.  */
 513       char old_value[MAX_REGISTER_SIZE];
 514
 515       /* Save new register value.  */
 516       regcache_raw_collect (regcache, regnum, old_value);
 517
 518       val = p_td_thr_getgregs (&thandle, gregset);
 519       if (val != TD_OK)
 520         error (_("sol_thread_store_registers: td_thr_getgregs %s"),
 521                td_err_string (val));
 522       val = p_td_thr_getfpregs (&thandle, &fpregset);
 523       if (val != TD_OK)
 524         error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
 525                td_err_string (val));
 526
 527       /* Restore new register value.  */
 528       regcache_raw_supply (regcache, regnum, old_value);
 529     }
 530
 531   fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
 532   fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
 533
 534   val = p_td_thr_setgregs (&thandle, gregset);
 535   if (val != TD_OK)
 536     error (_("sol_thread_store_registers: td_thr_setgregs %s"),
 537            td_err_string (val));
 538   val = p_td_thr_setfpregs (&thandle, &fpregset);
 539   if (val != TD_OK)
 540     error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
 541            td_err_string (val));
 542 }
 543
 544 /* Perform partial transfers on OBJECT.  See target_read_partial and
 545    target_write_partial for details of each variant.  One, and only
 546    one, of readbuf or writebuf must be non-NULL.  */
 547
 548 static enum target_xfer_status
 549 sol_thread_xfer_partial (struct target_ops *ops, enum target_object object,
 550                           const char *annex, gdb_byte *readbuf,
 551                           const gdb_byte *writebuf,
 552                          ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 553 {
 554   enum target_xfer_status retval;
 555   struct cleanup *old_chain;
 556   struct target_ops *beneath = find_target_beneath (ops);
 557
 558   old_chain = save_inferior_ptid ();
 559
 560   if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
 561     {
 562       /* It's either a thread or an LWP that isn't alive.  Any live
 563          LWP will do so use the first available.
 564
 565          NOTE: We don't need to call switch_to_thread; we're just
 566          reading memory.  */
 567       inferior_ptid = procfs_first_available ();
 568     }
 569
 570   retval = beneath->to_xfer_partial (beneath, object, annex, readbuf,
 571                                      writebuf, offset, len, xfered_len);
 572
 573   do_cleanups (old_chain);
 574
 575   return retval;
 576 }
 577
 578 static void
 579 check_for_thread_db (void)
 580 {
 581   td_err_e err;
 582   ptid_t ptid;
 583
 584   /* Don't attempt to use thread_db for remote targets.  */
 585   if (!(target_can_run (&current_target) || core_bfd))
 586     return;
 587
 588   /* Do nothing if we couldn't load libthread_db.so.1.  */
 589   if (p_td_ta_new == NULL)
 590     return;
 591
 592   if (sol_thread_active)
 593     /* Nothing to do.  The thread library was already detected and the
 594        target vector was already activated.  */
 595     return;
 596
 597   /* Now, initialize libthread_db.  This needs to be done after the
 598      shared libraries are located because it needs information from
 599      the user's thread library.  */
 600
 601   err = p_td_init ();
 602   if (err != TD_OK)
 603     {
 604       warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err));
 605       return;
 606     }
 607
 608   /* Now attempt to open a connection to the thread library.  */
 609   err = p_td_ta_new (&main_ph, &main_ta);
 610   switch (err)
 611     {
 612     case TD_NOLIBTHREAD:
 613       /* No thread library was detected.  */
 614       break;
 615
 616     case TD_OK:
 617       printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
 618
 619       /* The thread library was detected.  Activate the sol_thread target.  */
 620       push_target (&sol_thread_ops);
 621       sol_thread_active = 1;
 622
 623       main_ph.ptid = inferior_ptid; /* Save for xfer_memory.  */
 624       ptid = lwp_to_thread (inferior_ptid);
 625       if (ptid_get_pid (ptid) != -1)
 626         inferior_ptid = ptid;
 627
 628       target_find_new_threads ();
 629       break;
 630
 631     default:
 632       warning (_("Cannot initialize thread debugging library: %s"),
 633                td_err_string (err));
 634       break;
 635     }
 636 }
 637
 638 /* This routine is called whenever a new symbol table is read in, or
 639    when all symbol tables are removed.  libthread_db can only be
 640    initialized when it finds the right variables in libthread.so.
 641    Since it's a shared library, those variables don't show up until
 642    the library gets mapped and the symbol table is read in.  */
 643
 644 static void
 645 sol_thread_new_objfile (struct objfile *objfile)
 646 {
 647   if (objfile != NULL)
 648     check_for_thread_db ();
 649 }
 650
 651 /* Clean up after the inferior dies.  */
 652
 653 static void
 654 sol_thread_mourn_inferior (struct target_ops *ops)
 655 {
 656   struct target_ops *beneath = find_target_beneath (ops);
 657
 658   sol_thread_active = 0;
 659
 660   unpush_target (ops);
 661
 662   beneath->to_mourn_inferior (beneath);
 663 }
 664
 665 /* Return true if PTID is still active in the inferior.  */
 666
 667 static int
 668 sol_thread_alive (struct target_ops *ops, ptid_t ptid)
 669 {
 670   if (ptid_tid_p (ptid))
 671     {
 672       /* It's a (user-level) thread.  */
 673       td_err_e val;
 674       td_thrhandle_t th;
 675       int pid;
 676
 677       pid = ptid_get_tid (ptid);
 678       if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
 679         return 0;               /* Thread not found.  */
 680       if ((val = p_td_thr_validate (&th)) != TD_OK)
 681         return 0;               /* Thread not valid.  */
 682       return 1;                 /* Known thread.  */
 683     }
 684   else
 685     {
 686       struct target_ops *beneath = find_target_beneath (ops);
 687
 688       /* It's an LPW; pass the request on to the layer below.  */
 689       return beneath->to_thread_alive (beneath, ptid);
 690     }
 691 }
 692
 693 \f
 694 /* These routines implement the lower half of the thread_db interface,
 695    i.e. the ps_* routines.  */
 696
 697 /* Various versions of <proc_service.h> have slightly different
 698    function prototypes.  In particular, we have
 699
 700    NEWER                        OLDER
 701    struct ps_prochandle *       const struct ps_prochandle *
 702    void*                        char*
 703    const void*                  char*
 704    int                          size_t
 705
 706    Which one you have depends on the Solaris version and what patches
 707    you've applied.  On the theory that there are only two major
 708    variants, we have configure check the prototype of ps_pdwrite (),
 709    and use that info to make appropriate typedefs here.  */
 710
 711 #ifdef PROC_SERVICE_IS_OLD
 712 typedef const struct ps_prochandle *gdb_ps_prochandle_t;
 713 typedef char *gdb_ps_read_buf_t;
 714 typedef char *gdb_ps_write_buf_t;
 715 typedef int gdb_ps_size_t;
 716 typedef psaddr_t gdb_ps_addr_t;
 717 #else
 718 typedef struct ps_prochandle *gdb_ps_prochandle_t;
 719 typedef void *gdb_ps_read_buf_t;
 720 typedef const void *gdb_ps_write_buf_t;
 721 typedef size_t gdb_ps_size_t;
 722 typedef psaddr_t gdb_ps_addr_t;
 723 #endif
 724
 725 /* The next four routines are called by libthread_db to tell us to
 726    stop and stop a particular process or lwp.  Since GDB ensures that
 727    these are all stopped by the time we call anything in thread_db,
 728    these routines need to do nothing.  */
 729
 730 /* Process stop.  */
 731
 732 ps_err_e
 733 ps_pstop (gdb_ps_prochandle_t ph)
 734 {
 735   return PS_OK;
 736 }
 737
 738 /* Process continue.  */
 739
 740 ps_err_e
 741 ps_pcontinue (gdb_ps_prochandle_t ph)
 742 {
 743   return PS_OK;
 744 }
 745
 746 /* LWP stop.  */
 747
 748 ps_err_e
 749 ps_lstop (gdb_ps_prochandle_t ph, lwpid_t lwpid)
 750 {
 751   return PS_OK;
 752 }
 753
 754 /* LWP continue.  */
 755
 756 ps_err_e
 757 ps_lcontinue (gdb_ps_prochandle_t ph, lwpid_t lwpid)
 758 {
 759   return PS_OK;
 760 }
 761
 762 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table.  */
 763
 764 ps_err_e
 765 ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *ld_object_name,
 766                    const char *ld_symbol_name, gdb_ps_addr_t *ld_symbol_addr)
 767 {
 768   struct bound_minimal_symbol ms;
 769
 770   ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
 771   if (!ms.minsym)
 772     return PS_NOSYM;
 773
 774   *ld_symbol_addr = BMSYMBOL_VALUE_ADDRESS (ms);
 775   return PS_OK;
 776 }
 777
 778 /* Common routine for reading and writing memory.  */
 779
 780 static ps_err_e
 781 rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
 782            gdb_byte *buf, int size)
 783 {
 784   int ret;
 785   struct cleanup *old_chain;
 786
 787   old_chain = save_inferior_ptid ();
 788
 789   if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
 790     {
 791       /* It's either a thread or an LWP that isn't alive.  Any live
 792          LWP will do so use the first available.
 793
 794          NOTE: We don't need to call switch_to_thread; we're just
 795          reading memory.  */
 796       inferior_ptid = procfs_first_available ();
 797     }
 798
 799 #if defined (__sparcv9)
 800   /* For Sparc64 cross Sparc32, make sure the address has not been
 801      accidentally sign-extended (or whatever) to beyond 32 bits.  */
 802   if (bfd_get_arch_size (exec_bfd) == 32)
 803     addr &= 0xffffffff;
 804 #endif
 805
 806   if (dowrite)
 807     ret = target_write_memory (addr, (gdb_byte *) buf, size);
 808   else
 809     ret = target_read_memory (addr, (gdb_byte *) buf, size);
 810
 811   do_cleanups (old_chain);
 812
 813   return (ret == 0 ? PS_OK : PS_ERR);
 814 }
 815
 816 /* Copies SIZE bytes from target process .data segment to debugger memory.  */
 817
 818 ps_err_e
 819 ps_pdread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
 820            gdb_ps_read_buf_t buf, gdb_ps_size_t size)
 821 {
 822   return rw_common (0, ph, addr, buf, size);
 823 }
 824
 825 /* Copies SIZE bytes from debugger memory .data segment to target process.  */
 826
 827 ps_err_e
 828 ps_pdwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
 829             gdb_ps_write_buf_t buf, gdb_ps_size_t size)
 830 {
 831   return rw_common (1, ph, addr, (gdb_byte *) buf, size);
 832 }
 833
 834 /* Copies SIZE bytes from target process .text segment to debugger memory.  */
 835
 836 ps_err_e
 837 ps_ptread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
 838            gdb_ps_read_buf_t buf, gdb_ps_size_t size)
 839 {
 840   return rw_common (0, ph, addr, buf, size);
 841 }
 842
 843 /* Copies SIZE bytes from debugger memory .text segment to target process.  */
 844
 845 ps_err_e
 846 ps_ptwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
 847             gdb_ps_write_buf_t buf, gdb_ps_size_t size)
 848 {
 849   return rw_common (1, ph, addr, (gdb_byte *) buf, size);
 850 }
 851
 852 /* Get general-purpose registers for LWP.  */
 853
 854 ps_err_e
 855 ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
 856 {
 857   struct cleanup *old_chain;
 858   struct regcache *regcache;
 859
 860   old_chain = save_inferior_ptid ();
 861
 862   inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
 863   regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 864
 865   target_fetch_registers (regcache, -1);
 866   fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
 867
 868   do_cleanups (old_chain);
 869
 870   return PS_OK;
 871 }
 872
 873 /* Set general-purpose registers for LWP.  */
 874
 875 ps_err_e
 876 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 877              const prgregset_t gregset)
 878 {
 879   struct cleanup *old_chain;
 880   struct regcache *regcache;
 881
 882   old_chain = save_inferior_ptid ();
 883
 884   inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
 885   regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 886
 887   supply_gregset (regcache, (const gdb_gregset_t *) gregset);
 888   target_store_registers (regcache, -1);
 889
 890   do_cleanups (old_chain);
 891
 892   return PS_OK;
 893 }
 894
 895 /* Log a message (sends to gdb_stderr).  */
 896
 897 void
 898 ps_plog (const char *fmt, ...)
 899 {
 900   va_list args;
 901
 902   va_start (args, fmt);
 903
 904   vfprintf_filtered (gdb_stderr, fmt, args);
 905 }
 906
 907 /* Get size of extra register set.  Currently a noop.  */
 908
 909 ps_err_e
 910 ps_lgetxregsize (gdb_ps_prochandle_t ph, lwpid_t lwpid, int *xregsize)
 911 {
 912   return PS_OK;
 913 }
 914
 915 /* Get extra register set.  Currently a noop.  */
 916
 917 ps_err_e
 918 ps_lgetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
 919 {
 920   return PS_OK;
 921 }
 922
 923 /* Set extra register set.  Currently a noop.  */
 924
 925 ps_err_e
 926 ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
 927 {
 928   return PS_OK;
 929 }
 930
 931 /* Get floating-point registers for LWP.  */
 932
 933 ps_err_e
 934 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 935                prfpregset_t *fpregset)
 936 {
 937   struct cleanup *old_chain;
 938   struct regcache *regcache;
 939
 940   old_chain = save_inferior_ptid ();
 941
 942   inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
 943   regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 944
 945   target_fetch_registers (regcache, -1);
 946   fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
 947
 948   do_cleanups (old_chain);
 949
 950   return PS_OK;
 951 }
 952
 953 /* Set floating-point regs for LWP.  */
 954
 955 ps_err_e
 956 ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 957                const prfpregset_t * fpregset)
 958 {
 959   struct cleanup *old_chain;
 960   struct regcache *regcache;
 961
 962   old_chain = save_inferior_ptid ();
 963
 964   inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
 965   regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 966
 967   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
 968   target_store_registers (regcache, -1);
 969
 970   do_cleanups (old_chain);
 971
 972   return PS_OK;
 973 }
 974
 975 #ifdef PR_MODEL_LP64
 976 /* Identify process as 32-bit or 64-bit.  At the moment we're using
 977    BFD to do this.  There might be a more Solaris-specific
 978    (e.g. procfs) method, but this ought to work.  */
 979
 980 ps_err_e
 981 ps_pdmodel (gdb_ps_prochandle_t ph, int *data_model)
 982 {
 983   if (exec_bfd == 0)
 984     *data_model = PR_MODEL_UNKNOWN;
 985   else if (bfd_get_arch_size (exec_bfd) == 32)
 986     *data_model = PR_MODEL_ILP32;
 987   else
 988     *data_model = PR_MODEL_LP64;
 989
 990   return PS_OK;
 991 }
 992 #endif /* PR_MODEL_LP64 */
 993
 994 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
 995
 996 /* Reads the local descriptor table of a LWP.
 997
 998    This function is necessary on x86-solaris only.  Without it, the loading
 999    of libthread_db would fail because of ps_lgetLDT being undefined.  */
1000
1001 ps_err_e
1002 ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1003             struct ssd *pldt)
1004 {
1005   /* NOTE: only used on Solaris, therefore OK to refer to procfs.c.  */
1006   struct ssd *ret;
1007
1008   /* FIXME: can't I get the process ID from the prochandle or
1009      something?  */
1010
1011   if (ptid_get_pid (inferior_ptid) <= 0 || lwpid <= 0)
1012     return PS_BADLID;
1013
1014   ret = procfs_find_LDT_entry (ptid_build (ptid_get_pid (inferior_ptid),
1015                                lwpid, 0));
1016   if (ret)
1017     {
1018       memcpy (pldt, ret, sizeof (struct ssd));
1019       return PS_OK;
1020     }
1021   else
1022     /* LDT not found.  */
1023     return PS_ERR;
1024 }
1025 #endif
1026 \f
1027
1028 /* Convert PTID to printable form.  */
1029
1030 static char *
1031 solaris_pid_to_str (struct target_ops *ops, ptid_t ptid)
1032 {
1033   static char buf[100];
1034
1035   if (ptid_tid_p (ptid))
1036     {
1037       ptid_t lwp;
1038
1039       lwp = thread_to_lwp (ptid, -2);
1040
1041       if (ptid_get_pid (lwp) == -1)
1042         xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)",
1043                    ptid_get_tid (ptid));
1044       else if (ptid_get_pid (lwp) != -2)
1045         xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)",
1046                  ptid_get_tid (ptid), ptid_get_lwp (lwp));
1047       else
1048         xsnprintf (buf, sizeof (buf), "Thread %ld        ",
1049                    ptid_get_tid (ptid));
1050     }
1051   else if (ptid_get_lwp (ptid) != 0)
1052     xsnprintf (buf, sizeof (buf), "LWP    %ld        ", ptid_get_lwp (ptid));
1053   else
1054     xsnprintf (buf, sizeof (buf), "process %d    ", ptid_get_pid (ptid));
1055
1056   return buf;
1057 }
1058 \f
1059
1060 /* Worker bee for find_new_threads.  Callback function that gets
1061    called once per user-level thread (i.e. not for LWP's).  */
1062
1063 static int
1064 sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
1065 {
1066   td_err_e retval;
1067   td_thrinfo_t ti;
1068   ptid_t ptid;
1069
1070   retval = p_td_thr_get_info (th, &ti);
1071   if (retval != TD_OK)
1072     return -1;
1073
1074   ptid = ptid_build (ptid_get_pid (inferior_ptid), 0, ti.ti_tid);
1075   if (!in_thread_list (ptid) || is_exited (ptid))
1076     add_thread (ptid);
1077
1078   return 0;
1079 }
1080
1081 static void
1082 sol_find_new_threads (struct target_ops *ops)
1083 {
1084   struct target_ops *beneath = find_target_beneath (ops);
1085
1086   /* First Find any new LWP's.  */
1087   beneath->to_find_new_threads (beneath);
1088
1089   /* Then find any new user-level threads.  */
1090   p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0,
1091                     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1092                     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1093 }
1094
1095 /* Worker bee for the "info sol-thread" command.  This is a callback
1096    function that gets called once for each Solaris user-level thread
1097    (i.e. not for LWPs) in the inferior.  Print anything interesting
1098    that we can think of.  */
1099
1100 static int
1101 info_cb (const td_thrhandle_t *th, void *s)
1102 {
1103   td_err_e ret;
1104   td_thrinfo_t ti;
1105
1106   ret = p_td_thr_get_info (th, &ti);
1107   if (ret == TD_OK)
1108     {
1109       printf_filtered ("%s thread #%d, lwp %d, ",
1110                        ti.ti_type == TD_THR_SYSTEM ? "system" : "user  ",
1111                        ti.ti_tid, ti.ti_lid);
1112       switch (ti.ti_state)
1113         {
1114         default:
1115         case TD_THR_UNKNOWN:
1116           printf_filtered ("<unknown state>");
1117           break;
1118         case TD_THR_STOPPED:
1119           printf_filtered ("(stopped)");
1120           break;
1121         case TD_THR_RUN:
1122           printf_filtered ("(run)    ");
1123           break;
1124         case TD_THR_ACTIVE:
1125           printf_filtered ("(active) ");
1126           break;
1127         case TD_THR_ZOMBIE:
1128           printf_filtered ("(zombie) ");
1129           break;
1130         case TD_THR_SLEEP:
1131           printf_filtered ("(asleep) ");
1132           break;
1133         case TD_THR_STOPPED_ASLEEP:
1134           printf_filtered ("(stopped asleep)");
1135           break;
1136         }
1137       /* Print thr_create start function.  */
1138       if (ti.ti_startfunc != 0)
1139         {
1140           const struct bound_minimal_symbol msym
1141             = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
1142
1143           printf_filtered ("   startfunc=%s",
1144                            msym.minsym
1145                            ? MSYMBOL_PRINT_NAME (msym.minsym)
1146                            : paddress (target_gdbarch (), ti.ti_startfunc));
1147         }
1148
1149       /* If thread is asleep, print function that went to sleep.  */
1150       if (ti.ti_state == TD_THR_SLEEP)
1151         {
1152           const struct bound_minimal_symbol msym
1153             = lookup_minimal_symbol_by_pc (ti.ti_pc);
1154
1155           printf_filtered ("   sleepfunc=%s",
1156                            msym.minsym
1157                            ? MSYMBOL_PRINT_NAME (msym.minsym)
1158                            : paddress (target_gdbarch (), ti.ti_pc));
1159         }
1160
1161       printf_filtered ("\n");
1162     }
1163   else
1164     warning (_("info sol-thread: failed to get info for thread."));
1165
1166   return 0;
1167 }
1168
1169 /* List some state about each Solaris user-level thread in the
1170    inferior.  */
1171
1172 static void
1173 info_solthreads (char *args, int from_tty)
1174 {
1175   p_td_ta_thr_iter (main_ta, info_cb, args,
1176                     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1177                     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1178 }
1179
1180 /* Callback routine used to find a thread based on the TID part of
1181    its PTID.  */
1182
1183 static int
1184 thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
1185 {
1186   long *tid = (long *) data;
1187
1188   if (ptid_get_tid (thread->ptid) == *tid)
1189     return 1;
1190
1191   return 0;
1192 }
1193
1194 static ptid_t
1195 sol_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
1196 {
1197   struct thread_info *thread_info =
1198     iterate_over_threads (thread_db_find_thread_from_tid, &thread);
1199
1200   if (thread_info == NULL)
1201     {
1202       /* The list of threads is probably not up to date.  Find any
1203          thread that is missing from the list, and try again.  */
1204       sol_find_new_threads (&current_target);
1205       thread_info = iterate_over_threads (thread_db_find_thread_from_tid,
1206                                           &thread);
1207     }
1208
1209   gdb_assert (thread_info != NULL);
1210
1211   return (thread_info->ptid);
1212 }
1213
1214 static void
1215 init_sol_thread_ops (void)
1216 {
1217   sol_thread_ops.to_shortname = "solaris-threads";
1218   sol_thread_ops.to_longname = "Solaris threads and pthread.";
1219   sol_thread_ops.to_doc = "Solaris threads and pthread support.";
1220   sol_thread_ops.to_detach = sol_thread_detach;
1221   sol_thread_ops.to_resume = sol_thread_resume;
1222   sol_thread_ops.to_wait = sol_thread_wait;
1223   sol_thread_ops.to_fetch_registers = sol_thread_fetch_registers;
1224   sol_thread_ops.to_store_registers = sol_thread_store_registers;
1225   sol_thread_ops.to_xfer_partial = sol_thread_xfer_partial;
1226   sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior;
1227   sol_thread_ops.to_thread_alive = sol_thread_alive;
1228   sol_thread_ops.to_pid_to_str = solaris_pid_to_str;
1229   sol_thread_ops.to_find_new_threads = sol_find_new_threads;
1230   sol_thread_ops.to_stratum = thread_stratum;
1231   sol_thread_ops.to_get_ada_task_ptid = sol_get_ada_task_ptid;
1232   sol_thread_ops.to_magic = OPS_MAGIC;
1233 }
1234
1235 /* Silence -Wmissing-prototypes.  */
1236 extern void _initialize_sol_thread (void);
1237
1238 void
1239 _initialize_sol_thread (void)
1240 {
1241   void *dlhandle;
1242
1243   init_sol_thread_ops ();
1244
1245   dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1246   if (!dlhandle)
1247     goto die;
1248
1249 #define resolve(X) \
1250   if (!(p_##X = dlsym (dlhandle, #X))) \
1251     goto die;
1252
1253   resolve (td_log);
1254   resolve (td_ta_new);
1255   resolve (td_ta_delete);
1256   resolve (td_init);
1257   resolve (td_ta_get_ph);
1258   resolve (td_ta_get_nthreads);
1259   resolve (td_ta_tsd_iter);
1260   resolve (td_ta_thr_iter);
1261   resolve (td_thr_validate);
1262   resolve (td_thr_tsd);
1263   resolve (td_thr_get_info);
1264   resolve (td_thr_getfpregs);
1265   resolve (td_thr_getxregsize);
1266   resolve (td_thr_getxregs);
1267   resolve (td_thr_sigsetmask);
1268   resolve (td_thr_setprio);
1269   resolve (td_thr_setsigpending);
1270   resolve (td_thr_setfpregs);
1271   resolve (td_thr_setxregs);
1272   resolve (td_ta_map_id2thr);
1273   resolve (td_ta_map_lwp2thr);
1274   resolve (td_thr_getgregs);
1275   resolve (td_thr_setgregs);
1276
1277   complete_target_initialization (&sol_thread_ops);
1278
1279   add_cmd ("sol-threads", class_maintenance, info_solthreads,
1280            _("Show info on Solaris user threads."), &maintenanceinfolist);
1281
1282   /* Hook into new_objfile notification.  */
1283   observer_attach_new_objfile (sol_thread_new_objfile);
1284   return;
1285
1286  die:
1287   fprintf_unfiltered (gdb_stderr, "\
1288 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1289
1290   if (dlhandle)
1291     dlclose (dlhandle);
1292
1293   return;
1294 }