gdb/sol-thread.c

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