gdb/sol-thread.c

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