gdb/sol-thread.c

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