gdb/sol-thread.c

   1 /* Solaris threads debugging interface.
   2
   3    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 /* This module implements a sort of half target that sits between the
  24    machine-independent parts of GDB and the /proc interface (procfs.c)
  25    to provide access to the Solaris user-mode thread implementation.
  26
  27    Solaris threads are true user-mode threads, which are invoked via
  28    the thr_* and pthread_* (native and POSIX respectivly) interfaces.
  29    These are mostly implemented in user-space, with all thread context
  30    kept in various structures that live in the user's heap.  These
  31    should not be confused with lightweight processes (LWPs), which are
  32    implemented by the kernel, and scheduled without explicit
  33    intervention by the process.
  34
  35    Just to confuse things a little, Solaris threads (both native and
  36    POSIX) are actually implemented using LWPs.  In general, there are
  37    going to be more threads than LWPs.  There is no fixed
  38    correspondence between a thread and an LWP.  When a thread wants to
  39    run, it gets scheduled onto the first available LWP and can
  40    therefore migrate from one LWP to another as time goes on.  A
  41    sleeping thread may not be associated with an LWP at all!
  42
  43    To make it possible to mess with threads, Sun provides a library
  44    called libthread_db.so.1 (not to be confused with
  45    libthread_db.so.0, which doesn't have a published interface).  This
  46    interface has an upper part, which it provides, and a lower part
  47    which we provide.  The upper part consists of the td_* routines,
  48    which allow us to find all the threads, query their state, etc...
  49    The lower part consists of all of the ps_*, which are used by the
  50    td_* routines to read/write memory, manipulate LWPs, lookup
  51    symbols, etc...  The ps_* routines actually do most of their work
  52    by calling functions in procfs.c.  */
  53
  54 #include "defs.h"
  55 #include <thread.h>
  56 #include <proc_service.h>
  57 #include <thread_db.h>
  58 #include "gdbthread.h"
  59 #include "target.h"
  60 #include "inferior.h"
  61 #include <fcntl.h>
  62 #include "gdb_stat.h"
  63 #include <dlfcn.h>
  64 #include "gdbcmd.h"
  65 #include "gdbcore.h"
  66 #include "regcache.h"
  67 #include "symfile.h"
  68
  69 #include "gdb_string.h"
  70
  71 extern struct target_ops sol_thread_ops;        /* Forward declaration */
  72 extern struct target_ops sol_core_ops;  /* Forward declaration */
  73
  74 /* place to store core_ops before we overwrite it */
  75 static struct target_ops orig_core_ops;
  76
  77 struct target_ops sol_thread_ops;
  78 struct target_ops sol_core_ops;
  79
  80 extern int procfs_suppress_run;
  81 extern struct target_ops procfs_ops;    /* target vector for procfs.c */
  82 extern struct target_ops core_ops;      /* target vector for corelow.c */
  83 extern char *procfs_pid_to_str (ptid_t ptid);
  84
  85 /* Prototypes for supply_gregset etc. */
  86 #include "gregset.h"
  87
  88 /* This struct is defined by us, but mainly used for the proc_service
  89    interface.  We don't have much use for it, except as a handy place
  90    to get a real PID for memory accesses.  */
  91
  92 struct ps_prochandle
  93 {
  94   ptid_t ptid;
  95 };
  96
  97 struct string_map
  98 {
  99   int num;
 100   char *str;
 101 };
 102
 103 static struct ps_prochandle main_ph;
 104 static td_thragent_t *main_ta;
 105 static int sol_thread_active = 0;
 106
 107 static void sol_thread_resume (ptid_t ptid, int step, enum target_signal signo);
 108 static int sol_thread_alive (ptid_t ptid);
 109 static void sol_core_close (int quitting);
 110
 111 static void init_sol_thread_ops (void);
 112 static void init_sol_core_ops (void);
 113
 114 /* Default definitions: These must be defined in tm.h if they are to
 115    be shared with a process module such as procfs.  */
 116
 117 #define GET_PID(ptid)           ptid_get_pid (ptid)
 118 #define GET_LWP(ptid)           ptid_get_lwp (ptid)
 119 #define GET_THREAD(ptid)        ptid_get_tid (ptid)
 120
 121 #define is_lwp(ptid)            (GET_LWP (ptid) != 0)
 122 #define is_thread(ptid)         (GET_THREAD (ptid) != 0)
 123
 124 #define BUILD_LWP(lwp, pid)     ptid_build (pid, lwp, 0)
 125 #define BUILD_THREAD(tid, pid)  ptid_build (pid, 0, tid)
 126
 127 /* Pointers to routines from libthread_db resolved by dlopen().  */
 128
 129 static void (*p_td_log)(const int on_off);
 130 static td_err_e (*p_td_ta_new)(const struct ps_prochandle *ph_p,
 131                                td_thragent_t **ta_pp);
 132 static td_err_e (*p_td_ta_delete)(td_thragent_t *ta_p);
 133 static td_err_e (*p_td_init)(void);
 134 static td_err_e (*p_td_ta_get_ph)(const td_thragent_t *ta_p,
 135                                   struct ps_prochandle **ph_pp);
 136 static td_err_e (*p_td_ta_get_nthreads)(const td_thragent_t *ta_p,
 137                                         int *nthread_p);
 138 static td_err_e (*p_td_ta_tsd_iter)(const td_thragent_t *ta_p,
 139                                     td_key_iter_f *cb, void *cbdata_p);
 140 static td_err_e (*p_td_ta_thr_iter)(const td_thragent_t *ta_p,
 141                                     td_thr_iter_f *cb, void *cbdata_p,
 142                                     td_thr_state_e state, int ti_pri,
 143                                     sigset_t *ti_sigmask_p,
 144                                     unsigned ti_user_flags);
 145 static td_err_e (*p_td_thr_validate)(const td_thrhandle_t *th_p);
 146 static td_err_e (*p_td_thr_tsd)(const td_thrhandle_t * th_p,
 147                                 const thread_key_t key, void **data_pp);
 148 static td_err_e (*p_td_thr_get_info)(const td_thrhandle_t *th_p,
 149                                      td_thrinfo_t *ti_p);
 150 static td_err_e (*p_td_thr_getfpregs)(const td_thrhandle_t *th_p,
 151                                       prfpregset_t *fpregset);
 152 static td_err_e (*p_td_thr_getxregsize)(const td_thrhandle_t *th_p,
 153                                         int *xregsize);
 154 static td_err_e (*p_td_thr_getxregs)(const td_thrhandle_t *th_p,
 155                                      const caddr_t xregset);
 156 static td_err_e (*p_td_thr_sigsetmask)(const td_thrhandle_t *th_p,
 157                                        const sigset_t ti_sigmask);
 158 static td_err_e (*p_td_thr_setprio)(const td_thrhandle_t *th_p,
 159                                     const int ti_pri);
 160 static td_err_e (*p_td_thr_setsigpending)(const td_thrhandle_t *th_p,
 161                                           const uchar_t ti_pending_flag,
 162                                           const sigset_t ti_pending);
 163 static td_err_e (*p_td_thr_setfpregs)(const td_thrhandle_t *th_p,
 164                                       const prfpregset_t *fpregset);
 165 static td_err_e (*p_td_thr_setxregs)(const td_thrhandle_t *th_p,
 166                                      const caddr_t xregset);
 167 static td_err_e (*p_td_ta_map_id2thr)(const td_thragent_t *ta_p,
 168                                       thread_t tid,
 169                                       td_thrhandle_t *th_p);
 170 static td_err_e (*p_td_ta_map_lwp2thr)(const td_thragent_t *ta_p,
 171                                        lwpid_t lwpid,
 172                                        td_thrhandle_t *th_p);
 173 static td_err_e (*p_td_thr_getgregs)(const td_thrhandle_t *th_p,
 174                                      prgregset_t regset);
 175 static td_err_e (*p_td_thr_setgregs)(const td_thrhandle_t *th_p,
 176                                      const prgregset_t regset);
 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 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   sprintf (buf, "Unknown libthread_db error code: %d", errcode);
 218
 219   return buf;
 220 }
 221
 222 /* Return the the libthread_db state string assicoated with STATECODE.
 223    If STATECODE is unknown, return an appropriate message.  */
 224
 225 static char *
 226 td_state_string (td_thr_state_e statecode)
 227 {
 228   static struct string_map td_thr_state_table[] =
 229   {
 230     { TD_THR_ANY_STATE, "any state" },
 231     { TD_THR_UNKNOWN, "unknown" },
 232     { TD_THR_STOPPED, "stopped" },
 233     { TD_THR_RUN, "run" },
 234     { TD_THR_ACTIVE, "active" },
 235     { TD_THR_ZOMBIE, "zombie" },
 236     { TD_THR_SLEEP, "sleep" },
 237     { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
 238   };
 239   const int td_thr_state_table_size =
 240     sizeof td_thr_state_table / sizeof (struct string_map);
 241   int i;
 242   static char buf[50];
 243
 244   for (i = 0; i < td_thr_state_table_size; i++)
 245     if (td_thr_state_table[i].num == statecode)
 246       return td_thr_state_table[i].str;
 247
 248   sprintf (buf, "Unknown libthread_db state code: %d", statecode);
 249
 250   return buf;
 251 }
 252 \f
 253
 254 /* Convert a POSIX or Solaris thread ID into a LWP ID.  If THREAD_ID
 255    doesn't exist, that's an error.  If it's an inactive thread, return
 256    DEFAULT_LPW.
 257
 258    NOTE: This function probably shouldn't call error().  */
 259
 260 static ptid_t
 261 thread_to_lwp (ptid_t thread_id, int default_lwp)
 262 {
 263   td_thrinfo_t ti;
 264   td_thrhandle_t th;
 265   td_err_e val;
 266
 267   if (is_lwp (thread_id))
 268     return thread_id;           /* It's already an LWP ID.  */
 269
 270   /* It's a thread.  Convert to LWP.  */
 271
 272   val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);
 273   if (val == TD_NOTHR)
 274     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 275   else if (val != TD_OK)
 276     error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val));
 277
 278   val = p_td_thr_get_info (&th, &ti);
 279   if (val == TD_NOTHR)
 280     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 281   else if (val != TD_OK)
 282     error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val));
 283
 284   if (ti.ti_state != TD_THR_ACTIVE)
 285     {
 286       if (default_lwp != -1)
 287         return pid_to_ptid (default_lwp);
 288       error ("thread_to_lwp: thread state not active: %s",
 289              td_state_string (ti.ti_state));
 290     }
 291
 292   return BUILD_LWP (ti.ti_lid, PIDGET (thread_id));
 293 }
 294
 295 /* Convert an LWP ID into a POSIX or Solaris thread ID.  If LWP_ID
 296    doesn't exists, that's an error.
 297
 298    NOTE: This function probably shouldn't call error().  */
 299
 300 static ptid_t
 301 lwp_to_thread (ptid_t lwp)
 302 {
 303   td_thrinfo_t ti;
 304   td_thrhandle_t th;
 305   td_err_e val;
 306
 307   if (is_thread (lwp))
 308     return lwp;                 /* It's already a thread ID.  */
 309
 310   /* It's an LWP.  Convert it to a thread ID.  */
 311
 312   if (!sol_thread_alive (lwp))
 313     return pid_to_ptid (-1);    /* Must be a defunct LPW.  */
 314
 315   val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
 316   if (val == TD_NOTHR)
 317     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 318   else if (val != TD_OK)
 319     error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val));
 320
 321   val = p_td_thr_validate (&th);
 322   if (val == TD_NOTHR)
 323     return lwp;                 /* Unknown to libthread; just return LPW,  */
 324   else if (val != TD_OK)
 325     error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val));
 326
 327   val = p_td_thr_get_info (&th, &ti);
 328   if (val == TD_NOTHR)
 329     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 330   else if (val != TD_OK)
 331     error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val));
 332
 333   return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));
 334 }
 335 \f
 336
 337 /* Most target vector functions from here on actually just pass
 338    through to procfs.c, as they don't need to do anything specific for
 339    threads.  */
 340
 341 static void
 342 sol_thread_open (char *arg, int from_tty)
 343 {
 344   procfs_ops.to_open (arg, from_tty);
 345 }
 346
 347 /* Attach to process PID, then initialize for debugging it and wait
 348    for the trace-trap that results from attaching.  */
 349
 350 static void
 351 sol_thread_attach (char *args, int from_tty)
 352 {
 353   procfs_ops.to_attach (args, from_tty);
 354
 355   /* Must get symbols from shared libraries before libthread_db can run!  */
 356   SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0, auto_solib_add);
 357
 358   if (sol_thread_active)
 359     {
 360       printf_filtered ("sol-thread active.\n");
 361       main_ph.ptid = inferior_ptid; /* Save for xfer_memory.  */
 362       push_target (&sol_thread_ops);
 363       inferior_ptid = lwp_to_thread (inferior_ptid);
 364       if (PIDGET (inferior_ptid) == -1)
 365         inferior_ptid = main_ph.ptid;
 366       else
 367         add_thread (inferior_ptid);
 368     }
 369
 370   /* FIXME: Might want to iterate over all the threads and register
 371      them.  */
 372 }
 373
 374 /* Take a program previously attached to and detaches it.  The program
 375    resumes execution and will no longer stop on signals, etc.  We'd
 376    better not have left any breakpoints in the program or it'll die
 377    when it hits one.  For this to work, it may be necessary for the
 378    process to have been previously attached.  It *might* work if the
 379    program was started via the normal ptrace (PTRACE_TRACEME).  */
 380
 381 static void
 382 sol_thread_detach (char *args, int from_tty)
 383 {
 384   inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid));
 385   unpush_target (&sol_thread_ops);
 386   procfs_ops.to_detach (args, from_tty);
 387 }
 388
 389 /* Resume execution of process PTID.  If STEP is nozero, then just
 390    single step it.  If SIGNAL is nonzero, restart it with that signal
 391    activated.  We may have to convert PTID from a thread ID to an LWP
 392    ID for procfs.  */
 393
 394 static void
 395 sol_thread_resume (ptid_t ptid, int step, enum target_signal signo)
 396 {
 397   struct cleanup *old_chain;
 398
 399   old_chain = save_inferior_ptid ();
 400
 401   inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
 402   if (PIDGET (inferior_ptid) == -1)
 403     inferior_ptid = procfs_first_available ();
 404
 405   if (PIDGET (ptid) != -1)
 406     {
 407       ptid_t save_ptid = ptid;
 408
 409       ptid = thread_to_lwp (ptid, -2);
 410       if (PIDGET (ptid) == -2)          /* Inactive thread.  */
 411         error ("This version of Solaris can't start inactive threads.");
 412       if (info_verbose && PIDGET (ptid) == -1)
 413         warning ("Specified thread %ld seems to have terminated",
 414                  GET_THREAD (save_ptid));
 415     }
 416
 417   procfs_ops.to_resume (ptid, step, signo);
 418
 419   do_cleanups (old_chain);
 420 }
 421
 422 /* Wait for any threads to stop.  We may have to convert PIID from a
 423    thread ID to an LWP ID, and vice versa on the way out.  */
 424
 425 static ptid_t
 426 sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 427 {
 428   ptid_t rtnval;
 429   ptid_t save_ptid;
 430   struct cleanup *old_chain;
 431
 432   save_ptid = inferior_ptid;
 433   old_chain = save_inferior_ptid ();
 434
 435   inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
 436   if (PIDGET (inferior_ptid) == -1)
 437     inferior_ptid = procfs_first_available ();
 438
 439   if (PIDGET (ptid) != -1)
 440     {
 441       ptid_t save_ptid = ptid;
 442
 443       ptid = thread_to_lwp (ptid, -2);
 444       if (PIDGET (ptid) == -2)          /* Inactive thread.  */
 445         error ("This version of Solaris can't start inactive threads.");
 446       if (info_verbose && PIDGET (ptid) == -1)
 447         warning ("Specified thread %ld seems to have terminated",
 448                  GET_THREAD (save_ptid));
 449     }
 450
 451   rtnval = procfs_ops.to_wait (ptid, ourstatus);
 452
 453   if (ourstatus->kind != TARGET_WAITKIND_EXITED)
 454     {
 455       /* Map the LWP of interest back to the appropriate thread ID.  */
 456       rtnval = lwp_to_thread (rtnval);
 457       if (PIDGET (rtnval) == -1)
 458         rtnval = save_ptid;
 459
 460       /* See if we have a new thread.  */
 461       if (is_thread (rtnval)
 462           && !ptid_equal (rtnval, save_ptid)
 463           && !in_thread_list (rtnval))
 464         {
 465           printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));
 466           add_thread (rtnval);
 467         }
 468     }
 469
 470   /* During process initialization, we may get here without the thread
 471      package being initialized, since that can only happen after we've
 472      found the shared libs.  */
 473
 474   do_cleanups (old_chain);
 475
 476   return rtnval;
 477 }
 478
 479 static void
 480 sol_thread_fetch_registers (int regnum)
 481 {
 482   thread_t thread;
 483   td_thrhandle_t thandle;
 484   td_err_e val;
 485   prgregset_t gregset;
 486   prfpregset_t fpregset;
 487 #if 0
 488   int xregsize;
 489   caddr_t xregset;
 490 #endif
 491
 492   if (!is_thread (inferior_ptid))
 493     {
 494       /* It's an LWP; pass the request on to procfs.  */
 495       if (target_has_execution)
 496         procfs_ops.to_fetch_registers (regnum);
 497       else
 498         orig_core_ops.to_fetch_registers (regnum);
 499       return;
 500     }
 501
 502   /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t.  */
 503   thread = GET_THREAD (inferior_ptid);
 504   if (thread == 0)
 505     error ("sol_thread_fetch_registers: thread == 0");
 506
 507   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
 508   if (val != TD_OK)
 509     error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
 510            td_err_string (val));
 511
 512   /* Get the general-purpose registers.  */
 513
 514   val = p_td_thr_getgregs (&thandle, gregset);
 515   if (val != TD_OK && val != TD_PARTIALREG)
 516     error ("sol_thread_fetch_registers: td_thr_getgregs %s",
 517            td_err_string (val));
 518
 519   /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
 520      and %sp are saved (by a thread context switch).  */
 521
 522   /* And, now the floating-point registers.  */
 523
 524   val = p_td_thr_getfpregs (&thandle, &fpregset);
 525   if (val != TD_OK && val != TD_NOFPREGS)
 526     error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
 527            td_err_string (val));
 528
 529   /* Note that we must call supply_gregset and supply_fpregset *after*
 530      calling the td routines because the td routines call ps_lget*
 531      which affect the values stored in the registers array.  */
 532
 533   supply_gregset ((gdb_gregset_t *) &gregset);
 534   supply_fpregset ((gdb_fpregset_t *) &fpregset);
 535
 536 #if 0
 537   /* FIXME: libthread_db doesn't seem to handle this right.  */
 538   val = td_thr_getxregsize (&thandle, &xregsize);
 539   if (val != TD_OK && val != TD_NOXREGS)
 540     error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
 541            td_err_string (val));
 542
 543   if (val == TD_OK)
 544     {
 545       xregset = alloca (xregsize);
 546       val = td_thr_getxregs (&thandle, xregset);
 547       if (val != TD_OK)
 548         error ("sol_thread_fetch_registers: td_thr_getxregs %s",
 549                td_err_string (val));
 550     }
 551 #endif
 552 }
 553
 554 static void
 555 sol_thread_store_registers (int regnum)
 556 {
 557   thread_t thread;
 558   td_thrhandle_t thandle;
 559   td_err_e val;
 560   prgregset_t gregset;
 561   prfpregset_t fpregset;
 562 #if 0
 563   int xregsize;
 564   caddr_t xregset;
 565 #endif
 566
 567   if (!is_thread (inferior_ptid))
 568     {
 569       /* It's an LWP; pass the request on to procfs.c.  */
 570       procfs_ops.to_store_registers (regnum);
 571       return;
 572     }
 573
 574   /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t.  */
 575   thread = GET_THREAD (inferior_ptid);
 576
 577   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
 578   if (val != TD_OK)
 579     error ("sol_thread_store_registers: td_ta_map_id2thr %s",
 580            td_err_string (val));
 581
 582   if (regnum != -1)
 583     {
 584       /* Not writing all the registers.  */
 585       char old_value[MAX_REGISTER_SIZE];
 586
 587       /* Save new register value.  */
 588       regcache_collect (regnum, old_value);
 589
 590       val = p_td_thr_getgregs (&thandle, gregset);
 591       if (val != TD_OK)
 592         error ("sol_thread_store_registers: td_thr_getgregs %s",
 593                td_err_string (val));
 594       val = p_td_thr_getfpregs (&thandle, &fpregset);
 595       if (val != TD_OK)
 596         error ("sol_thread_store_registers: td_thr_getfpregs %s",
 597                td_err_string (val));
 598
 599       /* Restore new register value.  */
 600       supply_register (regnum, old_value);
 601
 602 #if 0
 603       /* FIXME: libthread_db doesn't seem to handle this right.  */
 604       val = td_thr_getxregsize (&thandle, &xregsize);
 605       if (val != TD_OK && val != TD_NOXREGS)
 606         error ("sol_thread_store_registers: td_thr_getxregsize %s",
 607                td_err_string (val));
 608
 609       if (val == TD_OK)
 610         {
 611           xregset = alloca (xregsize);
 612           val = td_thr_getxregs (&thandle, xregset);
 613           if (val != TD_OK)
 614             error ("sol_thread_store_registers: td_thr_getxregs %s",
 615                    td_err_string (val));
 616         }
 617 #endif
 618     }
 619
 620   fill_gregset ((gdb_gregset_t *) &gregset, regnum);
 621   fill_fpregset ((gdb_fpregset_t *) &fpregset, regnum);
 622
 623   val = p_td_thr_setgregs (&thandle, gregset);
 624   if (val != TD_OK)
 625     error ("sol_thread_store_registers: td_thr_setgregs %s",
 626            td_err_string (val));
 627   val = p_td_thr_setfpregs (&thandle, &fpregset);
 628   if (val != TD_OK)
 629     error ("sol_thread_store_registers: td_thr_setfpregs %s",
 630            td_err_string (val));
 631
 632 #if 0
 633   /* FIXME: libthread_db doesn't seem to handle this right.  */
 634   val = td_thr_getxregsize (&thandle, &xregsize);
 635   if (val != TD_OK && val != TD_NOXREGS)
 636     error ("sol_thread_store_registers: td_thr_getxregsize %s",
 637            td_err_string (val));
 638
 639   /* ??? Should probably do something about writing the xregs here,
 640      but what are they?  */
 641 #endif
 642 }
 643
 644 /* Get ready to modify the registers array.  On machines which store
 645    individual registers, this doesn't need to do anything.  On
 646    machines which store all the registers in one fell swoop, this
 647    makes sure that registers contains all the registers from the
 648    program being debugged.  */
 649
 650 static void
 651 sol_thread_prepare_to_store (void)
 652 {
 653   procfs_ops.to_prepare_to_store ();
 654 }
 655
 656 /* Transfer LEN bytes between GDB address MYADDR and target address
 657    MEMADDR.  If DOWRITE is non-zero, transfer them to the target,
 658    otherwise transfer them from the target.  TARGET is unused.
 659
 660    Returns the number of bytes transferred.  */
 661
 662 static int
 663 sol_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite,
 664                         struct mem_attrib *attrib,
 665                         struct target_ops *target)
 666 {
 667   int retval;
 668   struct cleanup *old_chain;
 669
 670   old_chain = save_inferior_ptid ();
 671
 672   if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
 673     {
 674       /* It's either a thread or an LWP that isn't alive.  Any live
 675          LWP will do so use the first available.
 676
 677          NOTE: We don't need to call switch_to_thread; we're just
 678          reading memory.  */
 679       inferior_ptid = procfs_first_available ();
 680     }
 681
 682   if (target_has_execution)
 683     retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len,
 684                                         dowrite, attrib, target);
 685   else
 686     retval = orig_core_ops.to_xfer_memory (memaddr, myaddr, len,
 687                                            dowrite, attrib, target);
 688
 689   do_cleanups (old_chain);
 690
 691   return retval;
 692 }
 693
 694 /* Perform partial transfers on OBJECT.  See target_read_partial and
 695    target_write_partial for details of each variant.  One, and only
 696    one, of readbuf or writebuf must be non-NULL.  */
 697
 698 static LONGEST
 699 sol_thread_xfer_partial (struct target_ops *ops, enum target_object object,
 700                           const char *annex, void *readbuf,
 701                           const void *writebuf, ULONGEST offset, LONGEST len)
 702 {
 703   int retval;
 704   struct cleanup *old_chain;
 705
 706   old_chain = save_inferior_ptid ();
 707
 708   if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
 709     {
 710       /* It's either a thread or an LWP that isn't alive.  Any live
 711          LWP will do so use the first available.
 712
 713          NOTE: We don't need to call switch_to_thread; we're just
 714          reading memory.  */
 715       inferior_ptid = procfs_first_available ();
 716     }
 717
 718   if (target_has_execution)
 719     retval = procfs_ops.to_xfer_partial (ops, object, annex,
 720                                          readbuf, writebuf, offset, len);
 721   else
 722     retval = orig_core_ops.to_xfer_partial (ops, object, annex,
 723                                             readbuf, writebuf, offset, len);
 724
 725   do_cleanups (old_chain);
 726
 727   return retval;
 728 }
 729
 730 /* Print status information about what we're accessing.  */
 731
 732 static void
 733 sol_thread_files_info (struct target_ops *ignore)
 734 {
 735   procfs_ops.to_files_info (ignore);
 736 }
 737
 738 static void
 739 sol_thread_kill_inferior (void)
 740 {
 741   procfs_ops.to_kill ();
 742 }
 743
 744 static void
 745 sol_thread_notice_signals (ptid_t ptid)
 746 {
 747   procfs_ops.to_notice_signals (pid_to_ptid (PIDGET (ptid)));
 748 }
 749
 750 /* Fork an inferior process, and start debugging it with /proc.  */
 751
 752 static void
 753 sol_thread_create_inferior (char *exec_file, char *allargs, char **env)
 754 {
 755   procfs_ops.to_create_inferior (exec_file, allargs, env);
 756
 757   if (sol_thread_active && !ptid_equal (inferior_ptid, null_ptid))
 758     {
 759       /* Save for xfer_memory.  */
 760       main_ph.ptid = inferior_ptid;
 761
 762       push_target (&sol_thread_ops);
 763
 764       inferior_ptid = lwp_to_thread (inferior_ptid);
 765       if (PIDGET (inferior_ptid) == -1)
 766         inferior_ptid = main_ph.ptid;
 767
 768       if (!in_thread_list (inferior_ptid))
 769         add_thread (inferior_ptid);
 770     }
 771 }
 772
 773 /* This routine is called whenever a new symbol table is read in, or
 774    when all symbol tables are removed.  libthread_db can only be
 775    initialized when it finds the right variables in libthread.so.
 776    Since it's a shared library, those variables don't show up until
 777    the library gets mapped and the symbol table is read in.
 778
 779    This new_objfile event is managed by a chained function pointer.
 780    It is the callee's responsability to call the next client on the
 781    chain.  */
 782
 783 /* Saved pointer to previous owner of the new_objfile event. */
 784 static void (*target_new_objfile_chain) (struct objfile *);
 785
 786 void
 787 sol_thread_new_objfile (struct objfile *objfile)
 788 {
 789   td_err_e val;
 790
 791   if (!objfile)
 792     {
 793       sol_thread_active = 0;
 794       goto quit;
 795     }
 796
 797   /* Don't do anything if init failed to resolve the libthread_db
 798      library.  */
 799   if (!procfs_suppress_run)
 800     goto quit;
 801
 802   /* Now, initialize libthread_db.  This needs to be done after the
 803      shared libraries are located because it needs information from
 804      the user's thread library.  */
 805
 806   val = p_td_init ();
 807   if (val != TD_OK)
 808     {
 809       warning ("sol_thread_new_objfile: td_init: %s", td_err_string (val));
 810       goto quit;
 811     }
 812
 813   val = p_td_ta_new (&main_ph, &main_ta);
 814   if (val == TD_NOLIBTHREAD)
 815     goto quit;
 816   else if (val != TD_OK)
 817     {
 818       warning ("sol_thread_new_objfile: td_ta_new: %s", td_err_string (val));
 819       goto quit;
 820     }
 821
 822   sol_thread_active = 1;
 823
 824 quit:
 825   /* Call predecessor on chain, if any.  */
 826   if (target_new_objfile_chain)
 827     target_new_objfile_chain (objfile);
 828 }
 829
 830 /* Clean up after the inferior dies.  */
 831
 832 static void
 833 sol_thread_mourn_inferior (void)
 834 {
 835   unpush_target (&sol_thread_ops);
 836   procfs_ops.to_mourn_inferior ();
 837 }
 838
 839 /* Mark our target-struct as eligible for stray "run" and "attach"
 840    commands.  */
 841
 842 static int
 843 sol_thread_can_run (void)
 844 {
 845   return procfs_suppress_run;
 846 }
 847
 848 /*
 849
 850    LOCAL FUNCTION
 851
 852    sol_thread_alive     - test thread for "aliveness"
 853
 854    SYNOPSIS
 855
 856    static bool sol_thread_alive (ptid_t ptid);
 857
 858    DESCRIPTION
 859
 860    returns true if thread still active in inferior.
 861
 862  */
 863
 864 /* Return true if PTID is still active in the inferior.  */
 865
 866 static int
 867 sol_thread_alive (ptid_t ptid)
 868 {
 869   if (is_thread (ptid))
 870     {
 871       /* It's a (user-level) thread.  */
 872       td_err_e val;
 873       td_thrhandle_t th;
 874       int pid;
 875
 876       pid = GET_THREAD (ptid);
 877       if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
 878         return 0;               /* Thread not found.  */
 879       if ((val = p_td_thr_validate (&th)) != TD_OK)
 880         return 0;               /* Thread not valid.  */
 881       return 1;                 /* Known thread.  */
 882     }
 883   else
 884     {
 885       /* It's an LPW; pass the request on to procfs.  */
 886       if (target_has_execution)
 887         return procfs_ops.to_thread_alive (ptid);
 888       else
 889         return orig_core_ops.to_thread_alive (ptid);
 890     }
 891 }
 892
 893 static void
 894 sol_thread_stop (void)
 895 {
 896   procfs_ops.to_stop ();
 897 }
 898 \f
 899 /* These routines implement the lower half of the thread_db interface,
 900    i.e. the ps_* routines.  */
 901
 902 /* Various versions of <proc_service.h> have slightly different
 903    function prototypes.  In particular, we have
 904
 905    NEWER                        OLDER
 906    struct ps_prochandle *       const struct ps_prochandle *
 907    void*                        char*
 908    const void*                  char*
 909    int                          size_t
 910
 911    Which one you have depends on the Solaris version and what patches
 912    you've applied.  On the theory that there are only two major
 913    variants, we have configure check the prototype of ps_pdwrite (),
 914    and use that info to make appropriate typedefs here. */
 915
 916 #ifdef PROC_SERVICE_IS_OLD
 917 typedef const struct ps_prochandle *gdb_ps_prochandle_t;
 918 typedef char *gdb_ps_read_buf_t;
 919 typedef char *gdb_ps_write_buf_t;
 920 typedef int gdb_ps_size_t;
 921 typedef paddr_t gdb_ps_addr_t;
 922 #else
 923 typedef struct ps_prochandle *gdb_ps_prochandle_t;
 924 typedef void *gdb_ps_read_buf_t;
 925 typedef const void *gdb_ps_write_buf_t;
 926 typedef size_t gdb_ps_size_t;
 927 typedef psaddr_t gdb_ps_addr_t;
 928 #endif
 929
 930 /* The next four routines are called by libthread_db to tell us to
 931    stop and stop a particular process or lwp.  Since GDB ensures that
 932    these are all stopped by the time we call anything in thread_db,
 933    these routines need to do nothing.  */
 934
 935 /* Process stop.  */
 936
 937 ps_err_e
 938 ps_pstop (gdb_ps_prochandle_t ph)
 939 {
 940   return PS_OK;
 941 }
 942
 943 /* Process continue.  */
 944
 945 ps_err_e
 946 ps_pcontinue (gdb_ps_prochandle_t ph)
 947 {
 948   return PS_OK;
 949 }
 950
 951 /* LWP stop.  */
 952
 953 ps_err_e
 954 ps_lstop (gdb_ps_prochandle_t ph, lwpid_t lwpid)
 955 {
 956   return PS_OK;
 957 }
 958
 959 /* LWP continue.  */
 960
 961 ps_err_e
 962 ps_lcontinue (gdb_ps_prochandle_t ph, lwpid_t lwpid)
 963 {
 964   return PS_OK;
 965 }
 966
 967 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table.  */
 968
 969 ps_err_e
 970 ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *ld_object_name,
 971                    const char *ld_symbol_name, gdb_ps_addr_t *ld_symbol_addr)
 972 {
 973   struct minimal_symbol *ms;
 974
 975   ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
 976   if (!ms)
 977     return PS_NOSYM;
 978
 979   *ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
 980   return PS_OK;
 981 }
 982
 983 /* Common routine for reading and writing memory.  */
 984
 985 static ps_err_e
 986 rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
 987            char *buf, int size)
 988 {
 989   struct cleanup *old_chain;
 990
 991   old_chain = save_inferior_ptid ();
 992
 993   if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
 994     {
 995       /* It's either a thread or an LWP that isn't alive.  Any live
 996          LWP will do so use the first available.
 997
 998          NOTE: We don't need to call switch_to_thread; we're just
 999          reading memory.  */
1000       inferior_ptid = procfs_first_available ();
1001     }
1002
1003 #if defined (__sparcv9)
1004   /* For Sparc64 cross Sparc32, make sure the address has not been
1005      accidentally sign-extended (or whatever) to beyond 32 bits.  */
1006   if (bfd_get_arch_size (exec_bfd) == 32)
1007     addr &= 0xffffffff;
1008 #endif
1009
1010   while (size > 0)
1011     {
1012       int cc;
1013
1014       /* FIXME: passing 0 as attrib argument.  */
1015       if (target_has_execution)
1016         cc = procfs_ops.to_xfer_memory (addr, buf, size,
1017                                         dowrite, 0, &procfs_ops);
1018       else
1019         cc = orig_core_ops.to_xfer_memory (addr, buf, size,
1020                                            dowrite, 0, &core_ops);
1021
1022       if (cc < 0)
1023         {
1024           if (dowrite == 0)
1025             print_sys_errmsg ("rw_common (): read", errno);
1026           else
1027             print_sys_errmsg ("rw_common (): write", errno);
1028
1029           do_cleanups (old_chain);
1030
1031           return PS_ERR;
1032         }
1033       else if (cc == 0)
1034         {
1035           if (dowrite == 0)
1036             warning ("rw_common (): unable to read at addr 0x%lx",
1037                      (long) addr);
1038           else
1039             warning ("rw_common (): unable to write at addr 0x%lx",
1040                      (long) addr);
1041
1042           do_cleanups (old_chain);
1043
1044           return PS_ERR;
1045         }
1046
1047       size -= cc;
1048       buf += cc;
1049     }
1050
1051   do_cleanups (old_chain);
1052
1053   return PS_OK;
1054 }
1055
1056 /* Copies SIZE bytes from target process .data segment to debugger memory.  */
1057
1058 ps_err_e
1059 ps_pdread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1060            gdb_ps_read_buf_t buf, gdb_ps_size_t size)
1061 {
1062   return rw_common (0, ph, addr, buf, size);
1063 }
1064
1065 /* Copies SIZE bytes from debugger memory .data segment to target process.  */
1066
1067 ps_err_e
1068 ps_pdwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1069             gdb_ps_write_buf_t buf, gdb_ps_size_t size)
1070 {
1071   return rw_common (1, ph, addr, (char *) buf, size);
1072 }
1073
1074 /* Copies SIZE bytes from target process .text segment to debugger memory.  */
1075
1076 ps_err_e
1077 ps_ptread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1078            gdb_ps_read_buf_t buf, gdb_ps_size_t size)
1079 {
1080   return rw_common (0, ph, addr, buf, size);
1081 }
1082
1083 /* Copies SIZE bytes from debugger memory .text segment to target process.  */
1084
1085 ps_err_e
1086 ps_ptwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1087             gdb_ps_write_buf_t buf, gdb_ps_size_t size)
1088 {
1089   return rw_common (1, ph, addr, (char *) buf, size);
1090 }
1091
1092 /* Get general-purpose registers for LWP.  */
1093
1094 ps_err_e
1095 ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
1096 {
1097   struct cleanup *old_chain;
1098
1099   old_chain = save_inferior_ptid ();
1100
1101   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1102
1103   if (target_has_execution)
1104     procfs_ops.to_fetch_registers (-1);
1105   else
1106     orig_core_ops.to_fetch_registers (-1);
1107   fill_gregset ((gdb_gregset_t *) gregset, -1);
1108
1109   do_cleanups (old_chain);
1110
1111   return PS_OK;
1112 }
1113
1114 /* Set general-purpose registers for LWP.  */
1115
1116 ps_err_e
1117 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1118              const prgregset_t gregset)
1119 {
1120   struct cleanup *old_chain;
1121
1122   old_chain = save_inferior_ptid ();
1123
1124   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1125
1126   supply_gregset ((gdb_gregset_t *) gregset);
1127   if (target_has_execution)
1128     procfs_ops.to_store_registers (-1);
1129   else
1130     orig_core_ops.to_store_registers (-1);
1131
1132   do_cleanups (old_chain);
1133
1134   return PS_OK;
1135 }
1136
1137 /* Log a message (sends to gdb_stderr).  */
1138
1139 void
1140 ps_plog (const char *fmt, ...)
1141 {
1142   va_list args;
1143
1144   va_start (args, fmt);
1145
1146   vfprintf_filtered (gdb_stderr, fmt, args);
1147 }
1148
1149 /* Get size of extra register set.  Currently a noop.  */
1150
1151 ps_err_e
1152 ps_lgetxregsize (gdb_ps_prochandle_t ph, lwpid_t lwpid, int *xregsize)
1153 {
1154 #if 0
1155   int lwp_fd;
1156   int regsize;
1157   ps_err_e val;
1158
1159   val = get_lwp_fd (ph, lwpid, &lwp_fd);
1160   if (val != PS_OK)
1161     return val;
1162
1163   if (ioctl (lwp_fd, PIOCGXREGSIZE, &regsize))
1164     {
1165       if (errno == EINVAL)
1166         return PS_NOFREGS;      /* XXX Wrong code, but this is the closest
1167                                    thing in proc_service.h  */
1168
1169       print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno);
1170       return PS_ERR;
1171     }
1172 #endif
1173
1174   return PS_OK;
1175 }
1176
1177 /* Get extra register set.  Currently a noop.  */
1178
1179 ps_err_e
1180 ps_lgetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
1181 {
1182 #if 0
1183   int lwp_fd;
1184   ps_err_e val;
1185
1186   val = get_lwp_fd (ph, lwpid, &lwp_fd);
1187   if (val != PS_OK)
1188     return val;
1189
1190   if (ioctl (lwp_fd, PIOCGXREG, xregset))
1191     {
1192       print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno);
1193       return PS_ERR;
1194     }
1195 #endif
1196
1197   return PS_OK;
1198 }
1199
1200 /* Set extra register set.  Currently a noop.  */
1201
1202 ps_err_e
1203 ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
1204 {
1205 #if 0
1206   int lwp_fd;
1207   ps_err_e val;
1208
1209   val = get_lwp_fd (ph, lwpid, &lwp_fd);
1210   if (val != PS_OK)
1211     return val;
1212
1213   if (ioctl (lwp_fd, PIOCSXREG, xregset))
1214     {
1215       print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno);
1216       return PS_ERR;
1217     }
1218 #endif
1219
1220   return PS_OK;
1221 }
1222
1223 /* Get floating-point registers for LWP.  */
1224
1225 ps_err_e
1226 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1227                prfpregset_t *fpregset)
1228 {
1229   struct cleanup *old_chain;
1230
1231   old_chain = save_inferior_ptid ();
1232
1233   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1234
1235   if (target_has_execution)
1236     procfs_ops.to_fetch_registers (-1);
1237   else
1238     orig_core_ops.to_fetch_registers (-1);
1239   fill_fpregset ((gdb_fpregset_t *) fpregset, -1);
1240
1241   do_cleanups (old_chain);
1242
1243   return PS_OK;
1244 }
1245
1246 /* Set floating-point regs for LWP */
1247
1248 ps_err_e
1249 ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1250                const prfpregset_t * fpregset)
1251 {
1252   struct cleanup *old_chain;
1253
1254   old_chain = save_inferior_ptid ();
1255
1256   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1257
1258   supply_fpregset ((gdb_fpregset_t *) fpregset);
1259   if (target_has_execution)
1260     procfs_ops.to_store_registers (-1);
1261   else
1262     orig_core_ops.to_store_registers (-1);
1263
1264   do_cleanups (old_chain);
1265
1266   return PS_OK;
1267 }
1268
1269 #ifdef PR_MODEL_LP64
1270 /* Identify process as 32-bit or 64-bit.  At the moment we're using
1271    BFD to do this.  There might be a more Solaris-specific
1272    (e.g. procfs) method, but this ought to work.  */
1273
1274 ps_err_e
1275 ps_pdmodel (gdb_ps_prochandle_t ph, int *data_model)
1276 {
1277   if (exec_bfd == 0)
1278     *data_model = PR_MODEL_UNKNOWN;
1279   else if (bfd_get_arch_size (exec_bfd) == 32)
1280     *data_model = PR_MODEL_ILP32;
1281   else
1282     *data_model = PR_MODEL_LP64;
1283
1284   return PS_OK;
1285 }
1286 #endif /* PR_MODEL_LP64 */
1287
1288 #ifdef TM_I386SOL2_H
1289
1290 /* Reads the local descriptor table of a LWP.  */
1291
1292 ps_err_e
1293 ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1294             struct ssd *pldt)
1295 {
1296   /* NOTE: only used on Solaris, therefore OK to refer to procfs.c.  */
1297   extern struct ssd *procfs_find_LDT_entry (ptid_t);
1298   struct ssd *ret;
1299
1300   /* FIXME: can't I get the process ID from the prochandle or
1301      something?  */
1302
1303   if (PIDGET (inferior_ptid) <= 0 || lwpid <= 0)
1304     return PS_BADLID;
1305
1306   ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_ptid)));
1307   if (ret)
1308     {
1309       memcpy (pldt, ret, sizeof (struct ssd));
1310       return PS_OK;
1311     }
1312   else
1313     /* LDT not found.  */
1314     return PS_ERR;
1315 }
1316 #endif /* TM_I386SOL2_H */
1317 \f
1318
1319 /* Convert PTID to printable form.  */
1320
1321 char *
1322 solaris_pid_to_str (ptid_t ptid)
1323 {
1324   static char buf[100];
1325
1326   /* In case init failed to resolve the libthread_db library.  */
1327   if (!procfs_suppress_run)
1328     return procfs_pid_to_str (ptid);
1329
1330   if (is_thread (ptid))
1331     {
1332       ptid_t lwp;
1333
1334       lwp = thread_to_lwp (ptid, -2);
1335
1336       if (PIDGET (lwp) == -1)
1337         sprintf (buf, "Thread %ld (defunct)", GET_THREAD (ptid));
1338       else if (PIDGET (lwp) != -2)
1339         sprintf (buf, "Thread %ld (LWP %ld)",
1340                  GET_THREAD (ptid), GET_LWP (lwp));
1341       else
1342         sprintf (buf, "Thread %ld        ", GET_THREAD (ptid));
1343     }
1344   else if (GET_LWP (ptid) != 0)
1345     sprintf (buf, "LWP    %ld        ", GET_LWP (ptid));
1346   else
1347     sprintf (buf, "process %d    ", PIDGET (ptid));
1348
1349   return buf;
1350 }
1351 \f
1352
1353 /* Worker bee for find_new_threads.  Callback function that gets
1354    called once per user-level thread (i.e. not for LWP's).  */
1355
1356 static int
1357 sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
1358 {
1359   td_err_e retval;
1360   td_thrinfo_t ti;
1361   ptid_t ptid;
1362
1363   retval = p_td_thr_get_info (th, &ti);
1364   if (retval != TD_OK)
1365     return -1;
1366
1367   ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid));
1368   if (!in_thread_list (ptid))
1369     add_thread (ptid);
1370
1371   return 0;
1372 }
1373
1374 static void
1375 sol_find_new_threads (void)
1376 {
1377   /* Don't do anything if init failed to resolve the libthread_db
1378      library.  */
1379   if (!procfs_suppress_run)
1380     return;
1381
1382   if (PIDGET (inferior_ptid) == -1)
1383     {
1384       printf_filtered ("No process.\n");
1385       return;
1386     }
1387
1388   /* First Find any new LWP's.  */
1389   procfs_ops.to_find_new_threads ();
1390
1391   /* Then find any new user-level threads.  */
1392   p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0,
1393                     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1394                     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1395 }
1396
1397 static void
1398 sol_core_open (char *filename, int from_tty)
1399 {
1400   orig_core_ops.to_open (filename, from_tty);
1401 }
1402
1403 static void
1404 sol_core_close (int quitting)
1405 {
1406   orig_core_ops.to_close (quitting);
1407 }
1408
1409 static void
1410 sol_core_detach (char *args, int from_tty)
1411 {
1412   unpush_target (&core_ops);
1413   orig_core_ops.to_detach (args, from_tty);
1414 }
1415
1416 static void
1417 sol_core_files_info (struct target_ops *t)
1418 {
1419   orig_core_ops.to_files_info (t);
1420 }
1421
1422 /* Worker bee for the "info sol-thread" command.  This is a callback
1423    function that gets called once for each Solaris user-level thread
1424    (i.e. not for LWPs) in the inferior.  Print anything interesting
1425    that we can think of.  */
1426
1427 static int
1428 info_cb (const td_thrhandle_t *th, void *s)
1429 {
1430   td_err_e ret;
1431   td_thrinfo_t ti;
1432
1433   ret = p_td_thr_get_info (th, &ti);
1434   if (ret == TD_OK)
1435     {
1436       printf_filtered ("%s thread #%d, lwp %d, ",
1437                        ti.ti_type == TD_THR_SYSTEM ? "system" : "user  ",
1438                        ti.ti_tid, ti.ti_lid);
1439       switch (ti.ti_state)
1440         {
1441         default:
1442         case TD_THR_UNKNOWN:
1443           printf_filtered ("<unknown state>");
1444           break;
1445         case TD_THR_STOPPED:
1446           printf_filtered ("(stopped)");
1447           break;
1448         case TD_THR_RUN:
1449           printf_filtered ("(run)    ");
1450           break;
1451         case TD_THR_ACTIVE:
1452           printf_filtered ("(active) ");
1453           break;
1454         case TD_THR_ZOMBIE:
1455           printf_filtered ("(zombie) ");
1456           break;
1457         case TD_THR_SLEEP:
1458           printf_filtered ("(asleep) ");
1459           break;
1460         case TD_THR_STOPPED_ASLEEP:
1461           printf_filtered ("(stopped asleep)");
1462           break;
1463         }
1464       /* Print thr_create start function.  */
1465       if (ti.ti_startfunc != 0)
1466         {
1467           struct minimal_symbol *msym;
1468           msym = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
1469           if (msym)
1470             printf_filtered ("   startfunc: %s\n",
1471                              DEPRECATED_SYMBOL_NAME (msym));
1472           else
1473             printf_filtered ("   startfunc: 0x%s\n", paddr (ti.ti_startfunc));
1474         }
1475
1476       /* If thread is asleep, print function that went to sleep.  */
1477       if (ti.ti_state == TD_THR_SLEEP)
1478         {
1479           struct minimal_symbol *msym;
1480           msym = lookup_minimal_symbol_by_pc (ti.ti_pc);
1481           if (msym)
1482             printf_filtered (" - Sleep func: %s\n",
1483                              DEPRECATED_SYMBOL_NAME (msym));
1484           else
1485             printf_filtered (" - Sleep func: 0x%s\n", paddr (ti.ti_startfunc));
1486         }
1487
1488       /* Wrap up line, if necessary.  */
1489       if (ti.ti_state != TD_THR_SLEEP && ti.ti_startfunc == 0)
1490         printf_filtered ("\n"); /* don't you hate counting newlines? */
1491     }
1492   else
1493     warning ("info sol-thread: failed to get info for thread.");
1494
1495   return 0;
1496 }
1497
1498 /* List some state about each Solaris user-level thread in the
1499    inferior.  */
1500
1501 static void
1502 info_solthreads (char *args, int from_tty)
1503 {
1504   p_td_ta_thr_iter (main_ta, info_cb, args,
1505                     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1506                     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1507 }
1508
1509 static int
1510 sol_find_memory_regions (int (*func) (CORE_ADDR, unsigned long,
1511                                       int, int, int, void *),
1512                          void *data)
1513 {
1514   return procfs_ops.to_find_memory_regions (func, data);
1515 }
1516
1517 static char *
1518 sol_make_note_section (bfd *obfd, int *note_size)
1519 {
1520   return procfs_ops.to_make_corefile_notes (obfd, note_size);
1521 }
1522
1523 static int
1524 ignore (CORE_ADDR addr, char *contents)
1525 {
1526   return 0;
1527 }
1528
1529 static void
1530 init_sol_thread_ops (void)
1531 {
1532   sol_thread_ops.to_shortname = "solaris-threads";
1533   sol_thread_ops.to_longname = "Solaris threads and pthread.";
1534   sol_thread_ops.to_doc = "Solaris threads and pthread support.";
1535   sol_thread_ops.to_open = sol_thread_open;
1536   sol_thread_ops.to_attach = sol_thread_attach;
1537   sol_thread_ops.to_detach = sol_thread_detach;
1538   sol_thread_ops.to_resume = sol_thread_resume;
1539   sol_thread_ops.to_wait = sol_thread_wait;
1540   sol_thread_ops.to_fetch_registers = sol_thread_fetch_registers;
1541   sol_thread_ops.to_store_registers = sol_thread_store_registers;
1542   sol_thread_ops.to_prepare_to_store = sol_thread_prepare_to_store;
1543   sol_thread_ops.to_xfer_memory = sol_thread_xfer_memory;
1544   sol_thread_ops.to_xfer_partial = sol_thread_xfer_partial;
1545   sol_thread_ops.to_files_info = sol_thread_files_info;
1546   sol_thread_ops.to_insert_breakpoint = memory_insert_breakpoint;
1547   sol_thread_ops.to_remove_breakpoint = memory_remove_breakpoint;
1548   sol_thread_ops.to_terminal_init = terminal_init_inferior;
1549   sol_thread_ops.to_terminal_inferior = terminal_inferior;
1550   sol_thread_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1551   sol_thread_ops.to_terminal_ours = terminal_ours;
1552   sol_thread_ops.to_terminal_save_ours = terminal_save_ours;
1553   sol_thread_ops.to_terminal_info = child_terminal_info;
1554   sol_thread_ops.to_kill = sol_thread_kill_inferior;
1555   sol_thread_ops.to_create_inferior = sol_thread_create_inferior;
1556   sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior;
1557   sol_thread_ops.to_can_run = sol_thread_can_run;
1558   sol_thread_ops.to_notice_signals = sol_thread_notice_signals;
1559   sol_thread_ops.to_thread_alive = sol_thread_alive;
1560   sol_thread_ops.to_pid_to_str = solaris_pid_to_str;
1561   sol_thread_ops.to_find_new_threads = sol_find_new_threads;
1562   sol_thread_ops.to_stop = sol_thread_stop;
1563   sol_thread_ops.to_stratum = process_stratum;
1564   sol_thread_ops.to_has_all_memory = 1;
1565   sol_thread_ops.to_has_memory = 1;
1566   sol_thread_ops.to_has_stack = 1;
1567   sol_thread_ops.to_has_registers = 1;
1568   sol_thread_ops.to_has_execution = 1;
1569   sol_thread_ops.to_has_thread_control = tc_none;
1570   sol_thread_ops.to_find_memory_regions = sol_find_memory_regions;
1571   sol_thread_ops.to_make_corefile_notes = sol_make_note_section;
1572   sol_thread_ops.to_magic = OPS_MAGIC;
1573 }
1574
1575 static void
1576 init_sol_core_ops (void)
1577 {
1578   sol_core_ops.to_shortname = "solaris-core";
1579   sol_core_ops.to_longname = "Solaris core threads and pthread.";
1580   sol_core_ops.to_doc = "Solaris threads and pthread support for core files.";
1581   sol_core_ops.to_open = sol_core_open;
1582   sol_core_ops.to_close = sol_core_close;
1583   sol_core_ops.to_attach = sol_thread_attach;
1584   sol_core_ops.to_detach = sol_core_detach;
1585   sol_core_ops.to_fetch_registers = sol_thread_fetch_registers;
1586   sol_core_ops.to_xfer_memory = sol_thread_xfer_memory;
1587   sol_core_ops.to_xfer_partial = sol_thread_xfer_partial;
1588   sol_core_ops.to_files_info = sol_core_files_info;
1589   sol_core_ops.to_insert_breakpoint = ignore;
1590   sol_core_ops.to_remove_breakpoint = ignore;
1591   sol_core_ops.to_create_inferior = sol_thread_create_inferior;
1592   sol_core_ops.to_stratum = core_stratum;
1593   sol_core_ops.to_has_memory = 1;
1594   sol_core_ops.to_has_stack = 1;
1595   sol_core_ops.to_has_registers = 1;
1596   sol_core_ops.to_has_thread_control = tc_none;
1597   sol_core_ops.to_thread_alive = sol_thread_alive;
1598   sol_core_ops.to_pid_to_str = solaris_pid_to_str;
1599   /* On Solaris/x86, when debugging a threaded core file from process
1600      <n>, the following causes "info threads" to produce "procfs:
1601      couldn't find pid <n> in procinfo list" where <n> is the pid of
1602      the process that produced the core file.  Disable it for now. */
1603 #if 0
1604   sol_core_ops.to_find_new_threads = sol_find_new_threads;
1605 #endif
1606   sol_core_ops.to_magic = OPS_MAGIC;
1607 }
1608
1609 /* We suppress the call to add_target of core_ops in corelow because
1610    if there are two targets in the stratum core_stratum,
1611    find_core_target won't know which one to return.  See corelow.c for
1612    an additonal comment on coreops_suppress_target.  */
1613 int coreops_suppress_target = 1;
1614
1615 void
1616 _initialize_sol_thread (void)
1617 {
1618   void *dlhandle;
1619
1620   init_sol_thread_ops ();
1621   init_sol_core_ops ();
1622
1623   dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1624   if (!dlhandle)
1625     goto die;
1626
1627 #define resolve(X) \
1628   if (!(p_##X = dlsym (dlhandle, #X))) \
1629     goto die;
1630
1631   resolve (td_log);
1632   resolve (td_ta_new);
1633   resolve (td_ta_delete);
1634   resolve (td_init);
1635   resolve (td_ta_get_ph);
1636   resolve (td_ta_get_nthreads);
1637   resolve (td_ta_tsd_iter);
1638   resolve (td_ta_thr_iter);
1639   resolve (td_thr_validate);
1640   resolve (td_thr_tsd);
1641   resolve (td_thr_get_info);
1642   resolve (td_thr_getfpregs);
1643   resolve (td_thr_getxregsize);
1644   resolve (td_thr_getxregs);
1645   resolve (td_thr_sigsetmask);
1646   resolve (td_thr_setprio);
1647   resolve (td_thr_setsigpending);
1648   resolve (td_thr_setfpregs);
1649   resolve (td_thr_setxregs);
1650   resolve (td_ta_map_id2thr);
1651   resolve (td_ta_map_lwp2thr);
1652   resolve (td_thr_getgregs);
1653   resolve (td_thr_setgregs);
1654
1655   add_target (&sol_thread_ops);
1656
1657   procfs_suppress_run = 1;
1658
1659   add_cmd ("sol-threads", class_maintenance, info_solthreads,
1660            "Show info on Solaris user threads.\n", &maintenanceinfolist);
1661
1662   memcpy (&orig_core_ops, &core_ops, sizeof (struct target_ops));
1663   memcpy (&core_ops, &sol_core_ops, sizeof (struct target_ops));
1664   add_target (&core_ops);
1665
1666   /* Hook into new_objfile notification.  */
1667   target_new_objfile_chain = deprecated_target_new_objfile_hook;
1668   deprecated_target_new_objfile_hook  = sol_thread_new_objfile;
1669   return;
1670
1671  die:
1672   fprintf_unfiltered (gdb_stderr, "\
1673 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1674
1675   if (dlhandle)
1676     dlclose (dlhandle);
1677
1678   /* Allow the user to debug non-threaded core files.  */
1679   add_target (&core_ops);
1680
1681   return;
1682 }