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 class sol_thread_target final : public target_ops
  73 {
  74 public:
  75   sol_thread_target ()
  76   { this->to_stratum = thread_stratum; }
  77
  78   const char *shortname () override
  79   { return "solaris-threads"; }
  80   const char *longname () override
  81   { return _("Solaris threads and pthread."); }
  82   const char *doc () override
  83   { return _("Solaris threads and pthread support."); }
  84
  85   void detach (inferior *, int) override;
  86   ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
  87   void resume (ptid_t, int, enum gdb_signal) override;
  88   void mourn_inferior () override;
  89   const char *pid_to_str (ptid_t) override;
  90   ptid_t get_ada_task_ptid (long lwp, long thread) override;
  91
  92   void fetch_registers (struct regcache *, int) override;
  93   void store_registers (struct regcache *, int) override;
  94
  95   enum target_xfer_status xfer_partial (enum target_object object,
  96                                         const char *annex,
  97                                         gdb_byte *readbuf,
  98                                         const gdb_byte *writebuf,
  99                                         ULONGEST offset, ULONGEST len,
 100                                         ULONGEST *xfered_len) override;
 101
 102   int thread_alive (ptid_t ptid) override;
 103   void update_thread_list () override;
 104 };
 105
 106 static sol_thread_target sol_thread_ops;
 107
 108 /* Prototypes for supply_gregset etc.  */
 109 #include "gregset.h"
 110
 111 /* This struct is defined by us, but mainly used for the proc_service
 112    interface.  We don't have much use for it, except as a handy place
 113    to get a real PID for memory accesses.  */
 114
 115 struct ps_prochandle
 116 {
 117   ptid_t ptid;
 118 };
 119
 120 struct string_map
 121 {
 122   int num;
 123   const char *str;
 124 };
 125
 126 static struct ps_prochandle main_ph;
 127 static td_thragent_t *main_ta;
 128 static int sol_thread_active = 0;
 129
 130 /* Default definitions: These must be defined in tm.h if they are to
 131    be shared with a process module such as procfs.  */
 132
 133 /* Types of the libthread_db functions.  */
 134
 135 typedef void (td_log_ftype)(const int on_off);
 136 typedef td_err_e (td_ta_new_ftype)(const struct ps_prochandle *ph_p,
 137                                    td_thragent_t **ta_pp);
 138 typedef td_err_e (td_ta_delete_ftype)(td_thragent_t *ta_p);
 139 typedef td_err_e (td_init_ftype)(void);
 140 typedef td_err_e (td_ta_get_ph_ftype)(const td_thragent_t *ta_p,
 141                                       struct ps_prochandle **ph_pp);
 142 typedef td_err_e (td_ta_get_nthreads_ftype)(const td_thragent_t *ta_p,
 143                                             int *nthread_p);
 144 typedef td_err_e (td_ta_tsd_iter_ftype)(const td_thragent_t *ta_p,
 145                                         td_key_iter_f *cb, void *cbdata_p);
 146 typedef td_err_e (td_ta_thr_iter_ftype)(const td_thragent_t *ta_p,
 147                                         td_thr_iter_f *cb, void *cbdata_p,
 148                                         td_thr_state_e state, int ti_pri,
 149                                         sigset_t *ti_sigmask_p,
 150                                         unsigned ti_user_flags);
 151 typedef td_err_e (td_thr_validate_ftype)(const td_thrhandle_t *th_p);
 152 typedef td_err_e (td_thr_tsd_ftype)(const td_thrhandle_t * th_p,
 153                                     const thread_key_t key, void **data_pp);
 154 typedef td_err_e (td_thr_get_info_ftype)(const td_thrhandle_t *th_p,
 155                                          td_thrinfo_t *ti_p);
 156 typedef td_err_e (td_thr_getfpregs_ftype)(const td_thrhandle_t *th_p,
 157                                           prfpregset_t *fpregset);
 158 typedef td_err_e (td_thr_getxregsize_ftype)(const td_thrhandle_t *th_p,
 159                                             int *xregsize);
 160 typedef td_err_e (td_thr_getxregs_ftype)(const td_thrhandle_t *th_p,
 161                                          const caddr_t xregset);
 162 typedef td_err_e (td_thr_sigsetmask_ftype)(const td_thrhandle_t *th_p,
 163                                            const sigset_t ti_sigmask);
 164 typedef td_err_e (td_thr_setprio_ftype)(const td_thrhandle_t *th_p,
 165                                         const int ti_pri);
 166 typedef td_err_e (td_thr_setsigpending_ftype)(const td_thrhandle_t *th_p,
 167                                               const uchar_t ti_pending_flag,
 168                                               const sigset_t ti_pending);
 169 typedef td_err_e (td_thr_setfpregs_ftype)(const td_thrhandle_t *th_p,
 170                                           const prfpregset_t *fpregset);
 171 typedef td_err_e (td_thr_setxregs_ftype)(const td_thrhandle_t *th_p,
 172                                          const caddr_t xregset);
 173 typedef td_err_e (td_ta_map_id2thr_ftype)(const td_thragent_t *ta_p,
 174                                           thread_t tid,
 175                                           td_thrhandle_t *th_p);
 176 typedef td_err_e (td_ta_map_lwp2thr_ftype)(const td_thragent_t *ta_p,
 177                                            lwpid_t lwpid,
 178                                            td_thrhandle_t *th_p);
 179 typedef td_err_e (td_thr_getgregs_ftype)(const td_thrhandle_t *th_p,
 180                                          prgregset_t regset);
 181 typedef td_err_e (td_thr_setgregs_ftype)(const td_thrhandle_t *th_p,
 182                                          const prgregset_t regset);
 183
 184 /* Pointers to routines from libthread_db resolved by dlopen().  */
 185
 186 static td_log_ftype *p_td_log;
 187 static td_ta_new_ftype *p_td_ta_new;
 188 static td_ta_delete_ftype *p_td_ta_delete;
 189 static td_init_ftype *p_td_init;
 190 static td_ta_get_ph_ftype *p_td_ta_get_ph;
 191 static td_ta_get_nthreads_ftype *p_td_ta_get_nthreads;
 192 static td_ta_tsd_iter_ftype *p_td_ta_tsd_iter;
 193 static td_ta_thr_iter_ftype *p_td_ta_thr_iter;
 194 static td_thr_validate_ftype *p_td_thr_validate;
 195 static td_thr_tsd_ftype *p_td_thr_tsd;
 196 static td_thr_get_info_ftype *p_td_thr_get_info;
 197 static td_thr_getfpregs_ftype *p_td_thr_getfpregs;
 198 static td_thr_getxregsize_ftype *p_td_thr_getxregsize;
 199 static td_thr_getxregs_ftype *p_td_thr_getxregs;
 200 static td_thr_sigsetmask_ftype *p_td_thr_sigsetmask;
 201 static td_thr_setprio_ftype *p_td_thr_setprio;
 202 static td_thr_setsigpending_ftype *p_td_thr_setsigpending;
 203 static td_thr_setfpregs_ftype *p_td_thr_setfpregs;
 204 static td_thr_setxregs_ftype *p_td_thr_setxregs;
 205 static td_ta_map_id2thr_ftype *p_td_ta_map_id2thr;
 206 static td_ta_map_lwp2thr_ftype *p_td_ta_map_lwp2thr;
 207 static td_thr_getgregs_ftype *p_td_thr_getgregs;
 208 static td_thr_setgregs_ftype *p_td_thr_setgregs;
 209 \f
 210
 211 /* Return the libthread_db error string associated with ERRCODE.  If
 212    ERRCODE is unknown, return an appropriate message.  */
 213
 214 static const char *
 215 td_err_string (td_err_e errcode)
 216 {
 217   static struct string_map td_err_table[] =
 218   {
 219     { TD_OK, "generic \"call succeeded\"" },
 220     { TD_ERR, "generic error." },
 221     { TD_NOTHR, "no thread can be found to satisfy query" },
 222     { TD_NOSV, "no synch. variable can be found to satisfy query" },
 223     { TD_NOLWP, "no lwp can be found to satisfy query" },
 224     { TD_BADPH, "invalid process handle" },
 225     { TD_BADTH, "invalid thread handle" },
 226     { TD_BADSH, "invalid synchronization handle" },
 227     { TD_BADTA, "invalid thread agent" },
 228     { TD_BADKEY, "invalid key" },
 229     { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
 230     { TD_NOFPREGS, "FPU register set not available for given thread" },
 231     { TD_NOLIBTHREAD, "application not linked with libthread" },
 232     { TD_NOEVENT, "requested event is not supported" },
 233     { TD_NOCAPAB, "capability not available" },
 234     { TD_DBERR, "Debugger service failed" },
 235     { TD_NOAPLIC, "Operation not applicable to" },
 236     { TD_NOTSD, "No thread specific data for this thread" },
 237     { TD_MALLOC, "Malloc failed" },
 238     { TD_PARTIALREG, "Only part of register set was written/read" },
 239     { TD_NOXREGS, "X register set not available for given thread" }
 240   };
 241   const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
 242   int i;
 243   static char buf[50];
 244
 245   for (i = 0; i < td_err_size; i++)
 246     if (td_err_table[i].num == errcode)
 247       return td_err_table[i].str;
 248
 249   xsnprintf (buf, sizeof (buf), "Unknown libthread_db error code: %d",
 250              errcode);
 251
 252   return buf;
 253 }
 254
 255 /* Return the libthread_db state string assicoated with STATECODE.
 256    If STATECODE is unknown, return an appropriate message.  */
 257
 258 static const char *
 259 td_state_string (td_thr_state_e statecode)
 260 {
 261   static struct string_map td_thr_state_table[] =
 262   {
 263     { TD_THR_ANY_STATE, "any state" },
 264     { TD_THR_UNKNOWN, "unknown" },
 265     { TD_THR_STOPPED, "stopped" },
 266     { TD_THR_RUN, "run" },
 267     { TD_THR_ACTIVE, "active" },
 268     { TD_THR_ZOMBIE, "zombie" },
 269     { TD_THR_SLEEP, "sleep" },
 270     { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
 271   };
 272   const int td_thr_state_table_size =
 273     sizeof td_thr_state_table / sizeof (struct string_map);
 274   int i;
 275   static char buf[50];
 276
 277   for (i = 0; i < td_thr_state_table_size; i++)
 278     if (td_thr_state_table[i].num == statecode)
 279       return td_thr_state_table[i].str;
 280
 281   xsnprintf (buf, sizeof (buf), "Unknown libthread_db state code: %d",
 282              statecode);
 283
 284   return buf;
 285 }
 286 \f
 287
 288 /* Convert a POSIX or Solaris thread ID into a LWP ID.  If THREAD_ID
 289    doesn't exist, that's an error.  If it's an inactive thread, return
 290    DEFAULT_LWP.
 291
 292    NOTE: This function probably shouldn't call error().  */
 293
 294 static ptid_t
 295 thread_to_lwp (ptid_t thread_id, int default_lwp)
 296 {
 297   td_thrinfo_t ti;
 298   td_thrhandle_t th;
 299   td_err_e val;
 300
 301   if (ptid_lwp_p (thread_id))
 302     return thread_id;           /* It's already an LWP ID.  */
 303
 304   /* It's a thread.  Convert to LWP.  */
 305
 306   val = p_td_ta_map_id2thr (main_ta, ptid_get_tid (thread_id), &th);
 307   if (val == TD_NOTHR)
 308     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 309   else if (val != TD_OK)
 310     error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
 311
 312   val = p_td_thr_get_info (&th, &ti);
 313   if (val == TD_NOTHR)
 314     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 315   else if (val != TD_OK)
 316     error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
 317
 318   if (ti.ti_state != TD_THR_ACTIVE)
 319     {
 320       if (default_lwp != -1)
 321         return pid_to_ptid (default_lwp);
 322       error (_("thread_to_lwp: thread state not active: %s"),
 323              td_state_string (ti.ti_state));
 324     }
 325
 326   return ptid_build (ptid_get_pid (thread_id), ti.ti_lid, 0);
 327 }
 328
 329 /* Convert an LWP ID into a POSIX or Solaris thread ID.  If LWP_ID
 330    doesn't exists, that's an error.
 331
 332    NOTE: This function probably shouldn't call error().  */
 333
 334 static ptid_t
 335 lwp_to_thread (ptid_t lwp)
 336 {
 337   td_thrinfo_t ti;
 338   td_thrhandle_t th;
 339   td_err_e val;
 340
 341   if (ptid_tid_p (lwp))
 342     return lwp;                 /* It's already a thread ID.  */
 343
 344   /* It's an LWP.  Convert it to a thread ID.  */
 345
 346   if (!target_thread_alive (lwp))
 347     return pid_to_ptid (-1);    /* Must be a defunct LPW.  */
 348
 349   val = p_td_ta_map_lwp2thr (main_ta, ptid_get_lwp (lwp), &th);
 350   if (val == TD_NOTHR)
 351     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 352   else if (val != TD_OK)
 353     error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
 354
 355   val = p_td_thr_validate (&th);
 356   if (val == TD_NOTHR)
 357     return lwp;                 /* Unknown to libthread; just return LPW,  */
 358   else if (val != TD_OK)
 359     error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
 360
 361   val = p_td_thr_get_info (&th, &ti);
 362   if (val == TD_NOTHR)
 363     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 364   else if (val != TD_OK)
 365     error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
 366
 367   return ptid_build (ptid_get_pid (lwp), 0 , ti.ti_tid);
 368 }
 369 \f
 370
 371 /* Most target vector functions from here on actually just pass
 372    through to the layer beneath, as they don't need to do anything
 373    specific for threads.  */
 374
 375 /* Take a program previously attached to and detaches it.  The program
 376    resumes execution and will no longer stop on signals, etc.  We'd
 377    better not have left any breakpoints in the program or it'll die
 378    when it hits one.  For this to work, it may be necessary for the
 379    process to have been previously attached.  It *might* work if the
 380    program was started via the normal ptrace (PTRACE_TRACEME).  */
 381
 382 void
 383 sol_thread_target::detach (inferior *inf, int from_tty)
 384 {
 385   struct target_ops *beneath = find_target_beneath (this);
 386
 387   sol_thread_active = 0;
 388   inferior_ptid = pid_to_ptid (ptid_get_pid (main_ph.ptid));
 389   unpush_target (this);
 390   beneath->detach (inf, from_tty);
 391 }
 392
 393 /* Resume execution of process PTID.  If STEP is nozero, then just
 394    single step it.  If SIGNAL is nonzero, restart it with that signal
 395    activated.  We may have to convert PTID from a thread ID to an LWP
 396    ID for procfs.  */
 397
 398 void
 399 sol_thread_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
 400 {
 401   struct target_ops *beneath = find_target_beneath (this);
 402
 403   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 404
 405   inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
 406   if (ptid_get_pid (inferior_ptid) == -1)
 407     inferior_ptid = procfs_first_available ();
 408
 409   if (ptid_get_pid (ptid) != -1)
 410     {
 411       ptid_t save_ptid = ptid;
 412
 413       ptid = thread_to_lwp (ptid, -2);
 414       if (ptid_get_pid (ptid) == -2)            /* Inactive thread.  */
 415         error (_("This version of Solaris can't start inactive threads."));
 416       if (info_verbose && ptid_get_pid (ptid) == -1)
 417         warning (_("Specified thread %ld seems to have terminated"),
 418                  ptid_get_tid (save_ptid));
 419     }
 420
 421   beneath->resume (ptid, step, signo);
 422 }
 423
 424 /* Wait for any threads to stop.  We may have to convert PTID from a
 425    thread ID to an LWP ID, and vice versa on the way out.  */
 426
 427 ptid_t
 428 sol_thread_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
 429                          int options)
 430 {
 431   ptid_t rtnval;
 432   ptid_t save_ptid;
 433   struct target_ops *beneath = find_target_beneath (this);
 434
 435   save_ptid = inferior_ptid;
 436   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 437
 438   inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
 439   if (ptid_get_pid (inferior_ptid) == -1)
 440     inferior_ptid = procfs_first_available ();
 441
 442   if (ptid_get_pid (ptid) != -1)
 443     {
 444       ptid_t save_ptid = ptid;
 445
 446       ptid = thread_to_lwp (ptid, -2);
 447       if (ptid_get_pid (ptid) == -2)            /* Inactive thread.  */
 448         error (_("This version of Solaris can't start inactive threads."));
 449       if (info_verbose && ptid_get_pid (ptid) == -1)
 450         warning (_("Specified thread %ld seems to have terminated"),
 451                  ptid_get_tid (save_ptid));
 452     }
 453
 454   rtnval = beneath->wait (ptid, ourstatus, options);
 455
 456   if (ourstatus->kind != TARGET_WAITKIND_EXITED)
 457     {
 458       /* Map the LWP of interest back to the appropriate thread ID.  */
 459       rtnval = lwp_to_thread (rtnval);
 460       if (ptid_get_pid (rtnval) == -1)
 461         rtnval = save_ptid;
 462
 463       /* See if we have a new thread.  */
 464       if (ptid_tid_p (rtnval)
 465           && !ptid_equal (rtnval, save_ptid)
 466           && (!in_thread_list (rtnval)
 467               || is_exited (rtnval)))
 468         add_thread (rtnval);
 469     }
 470
 471   /* During process initialization, we may get here without the thread
 472      package being initialized, since that can only happen after we've
 473      found the shared libs.  */
 474
 475   return rtnval;
 476 }
 477
 478 void
 479 sol_thread_target::fetch_registers (struct regcache *regcache, int regnum)
 480 {
 481   thread_t thread;
 482   td_thrhandle_t thandle;
 483   td_err_e val;
 484   prgregset_t gregset;
 485   prfpregset_t fpregset;
 486   gdb_gregset_t *gregset_p = &gregset;
 487   gdb_fpregset_t *fpregset_p = &fpregset;
 488   struct target_ops *beneath = find_target_beneath (this);
 489   ptid_t ptid = regcache_get_ptid (regcache);
 490
 491   if (!ptid_tid_p (ptid))
 492     {
 493       /* It's an LWP; pass the request on to the layer beneath.  */
 494       beneath->fetch_registers (regcache, regnum);
 495       return;
 496     }
 497
 498   /* Solaris thread: convert PTID into a td_thrhandle_t.  */
 499   thread = ptid_get_tid (ptid);
 500   if (thread == 0)
 501     error (_("sol_thread_fetch_registers: thread == 0"));
 502
 503   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
 504   if (val != TD_OK)
 505     error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
 506            td_err_string (val));
 507
 508   /* Get the general-purpose registers.  */
 509
 510   val = p_td_thr_getgregs (&thandle, gregset);
 511   if (val != TD_OK && val != TD_PARTIALREG)
 512     error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
 513            td_err_string (val));
 514
 515   /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
 516      and %sp are saved (by a thread context switch).  */
 517
 518   /* And, now the floating-point registers.  */
 519
 520   val = p_td_thr_getfpregs (&thandle, &fpregset);
 521   if (val != TD_OK && val != TD_NOFPREGS)
 522     error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
 523            td_err_string (val));
 524
 525   /* Note that we must call supply_gregset and supply_fpregset *after*
 526      calling the td routines because the td routines call ps_lget*
 527      which affect the values stored in the registers array.  */
 528
 529   supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
 530   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
 531 }
 532
 533 void
 534 sol_thread_target::store_registers (struct regcache *regcache, int regnum)
 535 {
 536   thread_t thread;
 537   td_thrhandle_t thandle;
 538   td_err_e val;
 539   prgregset_t gregset;
 540   prfpregset_t fpregset;
 541   ptid_t ptid = regcache_get_ptid (regcache);
 542
 543   if (!ptid_tid_p (ptid))
 544     {
 545       struct target_ops *beneath = find_target_beneath (this);
 546
 547       /* It's an LWP; pass the request on to the layer beneath.  */
 548       beneath->store_registers (regcache, regnum);
 549       return;
 550     }
 551
 552   /* Solaris thread: convert PTID into a td_thrhandle_t.  */
 553   thread = ptid_get_tid (ptid);
 554
 555   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
 556   if (val != TD_OK)
 557     error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
 558            td_err_string (val));
 559
 560   if (regnum != -1)
 561     {
 562       val = p_td_thr_getgregs (&thandle, gregset);
 563       if (val != TD_OK)
 564         error (_("sol_thread_store_registers: td_thr_getgregs %s"),
 565                td_err_string (val));
 566       val = p_td_thr_getfpregs (&thandle, &fpregset);
 567       if (val != TD_OK)
 568         error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
 569                td_err_string (val));
 570     }
 571
 572   fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
 573   fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
 574
 575   val = p_td_thr_setgregs (&thandle, gregset);
 576   if (val != TD_OK)
 577     error (_("sol_thread_store_registers: td_thr_setgregs %s"),
 578            td_err_string (val));
 579   val = p_td_thr_setfpregs (&thandle, &fpregset);
 580   if (val != TD_OK)
 581     error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
 582            td_err_string (val));
 583 }
 584
 585 /* Perform partial transfers on OBJECT.  See target_read_partial and
 586    target_write_partial for details of each variant.  One, and only
 587    one, of readbuf or writebuf must be non-NULL.  */
 588
 589 enum target_xfer_status
 590 sol_thread_target::xfer_partial (enum target_object object,
 591                                  const char *annex, gdb_byte *readbuf,
 592                                  const gdb_byte *writebuf,
 593                                  ULONGEST offset, ULONGEST len,
 594                                  ULONGEST *xfered_len)
 595 {
 596   struct target_ops *beneath = find_target_beneath (this);
 597
 598   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 599
 600   if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
 601     {
 602       /* It's either a thread or an LWP that isn't alive.  Any live
 603          LWP will do so use the first available.
 604
 605          NOTE: We don't need to call switch_to_thread; we're just
 606          reading memory.  */
 607       inferior_ptid = procfs_first_available ();
 608     }
 609
 610   return beneath->xfer_partial (object, annex, readbuf,
 611                                 writebuf, offset, len, xfered_len);
 612 }
 613
 614 static void
 615 check_for_thread_db (void)
 616 {
 617   td_err_e err;
 618   ptid_t ptid;
 619
 620   /* Don't attempt to use thread_db for remote targets.  */
 621   if (!(target_can_run () || core_bfd))
 622     return;
 623
 624   /* Do nothing if we couldn't load libthread_db.so.1.  */
 625   if (p_td_ta_new == NULL)
 626     return;
 627
 628   if (sol_thread_active)
 629     /* Nothing to do.  The thread library was already detected and the
 630        target vector was already activated.  */
 631     return;
 632
 633   /* Now, initialize libthread_db.  This needs to be done after the
 634      shared libraries are located because it needs information from
 635      the user's thread library.  */
 636
 637   err = p_td_init ();
 638   if (err != TD_OK)
 639     {
 640       warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err));
 641       return;
 642     }
 643
 644   /* Now attempt to open a connection to the thread library.  */
 645   err = p_td_ta_new (&main_ph, &main_ta);
 646   switch (err)
 647     {
 648     case TD_NOLIBTHREAD:
 649       /* No thread library was detected.  */
 650       break;
 651
 652     case TD_OK:
 653       printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
 654
 655       /* The thread library was detected.  Activate the sol_thread target.  */
 656       push_target (&sol_thread_ops);
 657       sol_thread_active = 1;
 658
 659       main_ph.ptid = inferior_ptid; /* Save for xfer_memory.  */
 660       ptid = lwp_to_thread (inferior_ptid);
 661       if (ptid_get_pid (ptid) != -1)
 662         inferior_ptid = ptid;
 663
 664       target_update_thread_list ();
 665       break;
 666
 667     default:
 668       warning (_("Cannot initialize thread debugging library: %s"),
 669                td_err_string (err));
 670       break;
 671     }
 672 }
 673
 674 /* This routine is called whenever a new symbol table is read in, or
 675    when all symbol tables are removed.  libthread_db can only be
 676    initialized when it finds the right variables in libthread.so.
 677    Since it's a shared library, those variables don't show up until
 678    the library gets mapped and the symbol table is read in.  */
 679
 680 static void
 681 sol_thread_new_objfile (struct objfile *objfile)
 682 {
 683   if (objfile != NULL)
 684     check_for_thread_db ();
 685 }
 686
 687 /* Clean up after the inferior dies.  */
 688
 689 void
 690 sol_thread_target::mourn_inferior ()
 691 {
 692   struct target_ops *beneath = find_target_beneath (this);
 693
 694   sol_thread_active = 0;
 695
 696   unpush_target (this);
 697
 698   beneath->mourn_inferior ();
 699 }
 700
 701 /* Return true if PTID is still active in the inferior.  */
 702
 703 int
 704 sol_thread_target::thread_alive (ptid_t ptid)
 705 {
 706   if (ptid_tid_p (ptid))
 707     {
 708       /* It's a (user-level) thread.  */
 709       td_err_e val;
 710       td_thrhandle_t th;
 711       int pid;
 712
 713       pid = ptid_get_tid (ptid);
 714       if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
 715         return 0;               /* Thread not found.  */
 716       if ((val = p_td_thr_validate (&th)) != TD_OK)
 717         return 0;               /* Thread not valid.  */
 718       return 1;                 /* Known thread.  */
 719     }
 720   else
 721     {
 722       struct target_ops *beneath = find_target_beneath (this);
 723
 724       /* It's an LPW; pass the request on to the layer below.  */
 725       return beneath->thread_alive (ptid);
 726     }
 727 }
 728
 729 \f
 730 /* These routines implement the lower half of the thread_db interface,
 731    i.e. the ps_* routines.  */
 732
 733 /* The next four routines are called by libthread_db to tell us to
 734    stop and stop a particular process or lwp.  Since GDB ensures that
 735    these are all stopped by the time we call anything in thread_db,
 736    these routines need to do nothing.  */
 737
 738 /* Process stop.  */
 739
 740 ps_err_e
 741 ps_pstop (struct ps_prochandle *ph)
 742 {
 743   return PS_OK;
 744 }
 745
 746 /* Process continue.  */
 747
 748 ps_err_e
 749 ps_pcontinue (struct ps_prochandle *ph)
 750 {
 751   return PS_OK;
 752 }
 753
 754 /* LWP stop.  */
 755
 756 ps_err_e
 757 ps_lstop (struct ps_prochandle *ph, lwpid_t lwpid)
 758 {
 759   return PS_OK;
 760 }
 761
 762 /* LWP continue.  */
 763
 764 ps_err_e
 765 ps_lcontinue (struct ps_prochandle *ph, lwpid_t lwpid)
 766 {
 767   return PS_OK;
 768 }
 769
 770 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table.  */
 771
 772 ps_err_e
 773 ps_pglobal_lookup (struct ps_prochandle *ph, const char *ld_object_name,
 774                    const char *ld_symbol_name, psaddr_t *ld_symbol_addr)
 775 {
 776   struct bound_minimal_symbol ms;
 777
 778   ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
 779   if (!ms.minsym)
 780     return PS_NOSYM;
 781
 782   *ld_symbol_addr = BMSYMBOL_VALUE_ADDRESS (ms);
 783   return PS_OK;
 784 }
 785
 786 /* Common routine for reading and writing memory.  */
 787
 788 static ps_err_e
 789 rw_common (int dowrite, const struct ps_prochandle *ph, psaddr_t addr,
 790            gdb_byte *buf, int size)
 791 {
 792   int ret;
 793
 794   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 795
 796   if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
 797     {
 798       /* It's either a thread or an LWP that isn't alive.  Any live
 799          LWP will do so use the first available.
 800
 801          NOTE: We don't need to call switch_to_thread; we're just
 802          reading memory.  */
 803       inferior_ptid = procfs_first_available ();
 804     }
 805
 806 #if defined (__sparcv9)
 807   /* For Sparc64 cross Sparc32, make sure the address has not been
 808      accidentally sign-extended (or whatever) to beyond 32 bits.  */
 809   if (bfd_get_arch_size (exec_bfd) == 32)
 810     addr &= 0xffffffff;
 811 #endif
 812
 813   if (dowrite)
 814     ret = target_write_memory (addr, (gdb_byte *) buf, size);
 815   else
 816     ret = target_read_memory (addr, (gdb_byte *) buf, size);
 817
 818   return (ret == 0 ? PS_OK : PS_ERR);
 819 }
 820
 821 /* Copies SIZE bytes from target process .data segment to debugger memory.  */
 822
 823 ps_err_e
 824 ps_pdread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
 825 {
 826   return rw_common (0, ph, addr, (gdb_byte *) buf, size);
 827 }
 828
 829 /* Copies SIZE bytes from debugger memory .data segment to target process.  */
 830
 831 ps_err_e
 832 ps_pdwrite (struct ps_prochandle *ph, psaddr_t addr,
 833             const void *buf, size_t size)
 834 {
 835   return rw_common (1, ph, addr, (gdb_byte *) buf, size);
 836 }
 837
 838 /* Copies SIZE bytes from target process .text segment to debugger memory.  */
 839
 840 ps_err_e
 841 ps_ptread (struct ps_prochandle *ph, psaddr_t addr, void *buf, 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 (struct ps_prochandle *ph, psaddr_t addr,
 850             const void *buf, 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 (struct ps_prochandle *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 (struct ps_prochandle *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 (struct ps_prochandle *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 (struct ps_prochandle *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 (struct ps_prochandle *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 (struct ps_prochandle *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 (struct ps_prochandle *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 (struct ps_prochandle *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 (struct ps_prochandle *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 const char *
1010 sol_thread_target::pid_to_str (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 void
1061 sol_thread_target::update_thread_list ()
1062 {
1063   struct target_ops *beneath = find_target_beneath (this);
1064
1065   /* Delete dead threads.  */
1066   prune_threads ();
1067
1068   /* Find any new LWP's.  */
1069   beneath->update_thread_list ();
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 (const char *args, int from_tty)
1156 {
1157   p_td_ta_thr_iter (main_ta, info_cb, (void *) 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 ptid_t
1177 sol_thread_target::get_ada_task_ptid (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       update_thread_list ();
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 void
1197 _initialize_sol_thread (void)
1198 {
1199   void *dlhandle;
1200
1201   dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1202   if (!dlhandle)
1203     goto die;
1204
1205 #define resolve(X) \
1206   if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X)))  \
1207     goto die;
1208
1209   resolve (td_log);
1210   resolve (td_ta_new);
1211   resolve (td_ta_delete);
1212   resolve (td_init);
1213   resolve (td_ta_get_ph);
1214   resolve (td_ta_get_nthreads);
1215   resolve (td_ta_tsd_iter);
1216   resolve (td_ta_thr_iter);
1217   resolve (td_thr_validate);
1218   resolve (td_thr_tsd);
1219   resolve (td_thr_get_info);
1220   resolve (td_thr_getfpregs);
1221   resolve (td_thr_getxregsize);
1222   resolve (td_thr_getxregs);
1223   resolve (td_thr_sigsetmask);
1224   resolve (td_thr_setprio);
1225   resolve (td_thr_setsigpending);
1226   resolve (td_thr_setfpregs);
1227   resolve (td_thr_setxregs);
1228   resolve (td_ta_map_id2thr);
1229   resolve (td_ta_map_lwp2thr);
1230   resolve (td_thr_getgregs);
1231   resolve (td_thr_setgregs);
1232
1233   add_cmd ("sol-threads", class_maintenance, info_solthreads,
1234            _("Show info on Solaris user threads."), &maintenanceinfolist);
1235
1236   /* Hook into new_objfile notification.  */
1237   gdb::observers::new_objfile.attach (sol_thread_new_objfile);
1238   return;
1239
1240  die:
1241   fprintf_unfiltered (gdb_stderr, "\
1242 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1243
1244   if (dlhandle)
1245     dlclose (dlhandle);
1246
1247   return;
1248 }