gdb/linux-thread-db.c

   1 /* libthread_db assisted debugging support, generic parts.
   2
   3    Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005
   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., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "defs.h"
  24
  25 #include "gdb_assert.h"
  26 #include <dlfcn.h>
  27 #include "gdb_proc_service.h"
  28 #include "gdb_thread_db.h"
  29
  30 #include "bfd.h"
  31 #include "exceptions.h"
  32 #include "gdbthread.h"
  33 #include "inferior.h"
  34 #include "symfile.h"
  35 #include "objfiles.h"
  36 #include "target.h"
  37 #include "regcache.h"
  38 #include "solib-svr4.h"
  39 #include "gdbcore.h"
  40
  41 #ifdef HAVE_GNU_LIBC_VERSION_H
  42 #include <gnu/libc-version.h>
  43 #endif
  44
  45 #ifndef LIBTHREAD_DB_SO
  46 #define LIBTHREAD_DB_SO "libthread_db.so.1"
  47 #endif
  48
  49 /* If we're running on GNU/Linux, we must explicitly attach to any new
  50    threads.  */
  51
  52 /* FIXME: There is certainly some room for improvements:
  53    - Cache LWP ids.
  54    - Bypass libthread_db when fetching or storing registers for
  55    threads bound to a LWP.  */
  56
  57 /* This module's target vector.  */
  58 static struct target_ops thread_db_ops;
  59
  60 /* The target vector that we call for things this module can't handle.  */
  61 static struct target_ops *target_beneath;
  62
  63 /* Pointer to the next function on the objfile event chain.  */
  64 static void (*target_new_objfile_chain) (struct objfile * objfile);
  65
  66 /* Non-zero if we're using this module's target vector.  */
  67 static int using_thread_db;
  68
  69 /* Non-zero if we have determined the signals used by the threads
  70    library.  */
  71 static int thread_signals;
  72 static sigset_t thread_stop_set;
  73 static sigset_t thread_print_set;
  74
  75 /* Structure that identifies the child process for the
  76    <proc_service.h> interface.  */
  77 static struct ps_prochandle proc_handle;
  78
  79 /* Connection to the libthread_db library.  */
  80 static td_thragent_t *thread_agent;
  81
  82 /* Pointers to the libthread_db functions.  */
  83
  84 static td_err_e (*td_init_p) (void);
  85
  86 static td_err_e (*td_ta_new_p) (struct ps_prochandle * ps,
  87                                 td_thragent_t **ta);
  88 static td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
  89                                        td_thrhandle_t *__th);
  90 static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta,
  91                                         lwpid_t lwpid, td_thrhandle_t *th);
  92 static td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
  93                                      td_thr_iter_f *callback, void *cbdata_p,
  94                                      td_thr_state_e state, int ti_pri,
  95                                      sigset_t *ti_sigmask_p,
  96                                      unsigned int ti_user_flags);
  97 static td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
  98                                        td_event_e event, td_notify_t *ptr);
  99 static td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
 100                                       td_thr_events_t *event);
 101 static td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
 102                                          td_event_msg_t *msg);
 103
 104 static td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
 105 static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
 106                                       td_thrinfo_t *infop);
 107 static td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th,
 108                                        gdb_prfpregset_t *regset);
 109 static td_err_e (*td_thr_getgregs_p) (const td_thrhandle_t *th,
 110                                       prgregset_t gregs);
 111 static td_err_e (*td_thr_setfpregs_p) (const td_thrhandle_t *th,
 112                                        const gdb_prfpregset_t *fpregs);
 113 static td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th,
 114                                       prgregset_t gregs);
 115 static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th,
 116                                           int event);
 117
 118 static td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
 119                                           void *map_address,
 120                                           size_t offset, void **address);
 121
 122 /* Location of the thread creation event breakpoint.  The code at this
 123    location in the child process will be called by the pthread library
 124    whenever a new thread is created.  By setting a special breakpoint
 125    at this location, GDB can detect when a new thread is created.  We
 126    obtain this location via the td_ta_event_addr call.  */
 127 static CORE_ADDR td_create_bp_addr;
 128
 129 /* Location of the thread death event breakpoint.  */
 130 static CORE_ADDR td_death_bp_addr;
 131
 132 /* Prototypes for local functions.  */
 133 static void thread_db_find_new_threads (void);
 134 static void attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
 135                            const td_thrinfo_t *ti_p, int verbose);
 136 static void detach_thread (ptid_t ptid, int verbose);
 137 \f
 138
 139 /* Building process ids.  */
 140
 141 #define GET_PID(ptid)           ptid_get_pid (ptid)
 142 #define GET_LWP(ptid)           ptid_get_lwp (ptid)
 143 #define GET_THREAD(ptid)        ptid_get_tid (ptid)
 144
 145 #define is_lwp(ptid)            (GET_LWP (ptid) != 0)
 146 #define is_thread(ptid)         (GET_THREAD (ptid) != 0)
 147
 148 #define BUILD_LWP(lwp, pid)     ptid_build (pid, lwp, 0)
 149 \f
 150
 151 /* Use "struct private_thread_info" to cache thread state.  This is
 152    a substantial optimization.  */
 153
 154 struct private_thread_info
 155 {
 156   /* Flag set when we see a TD_DEATH event for this thread.  */
 157   unsigned int dying:1;
 158
 159   /* Cached thread state.  */
 160   unsigned int th_valid:1;
 161   unsigned int ti_valid:1;
 162
 163   td_thrhandle_t th;
 164   td_thrinfo_t ti;
 165 };
 166 \f
 167
 168 static char *
 169 thread_db_err_str (td_err_e err)
 170 {
 171   static char buf[64];
 172
 173   switch (err)
 174     {
 175     case TD_OK:
 176       return "generic 'call succeeded'";
 177     case TD_ERR:
 178       return "generic error";
 179     case TD_NOTHR:
 180       return "no thread to satisfy query";
 181     case TD_NOSV:
 182       return "no sync handle to satisfy query";
 183     case TD_NOLWP:
 184       return "no LWP to satisfy query";
 185     case TD_BADPH:
 186       return "invalid process handle";
 187     case TD_BADTH:
 188       return "invalid thread handle";
 189     case TD_BADSH:
 190       return "invalid synchronization handle";
 191     case TD_BADTA:
 192       return "invalid thread agent";
 193     case TD_BADKEY:
 194       return "invalid key";
 195     case TD_NOMSG:
 196       return "no event message for getmsg";
 197     case TD_NOFPREGS:
 198       return "FPU register set not available";
 199     case TD_NOLIBTHREAD:
 200       return "application not linked with libthread";
 201     case TD_NOEVENT:
 202       return "requested event is not supported";
 203     case TD_NOCAPAB:
 204       return "capability not available";
 205     case TD_DBERR:
 206       return "debugger service failed";
 207     case TD_NOAPLIC:
 208       return "operation not applicable to";
 209     case TD_NOTSD:
 210       return "no thread-specific data for this thread";
 211     case TD_MALLOC:
 212       return "malloc failed";
 213     case TD_PARTIALREG:
 214       return "only part of register set was written/read";
 215     case TD_NOXREGS:
 216       return "X register set not available for this thread";
 217     default:
 218       snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
 219       return buf;
 220     }
 221 }
 222
 223 static char *
 224 thread_db_state_str (td_thr_state_e state)
 225 {
 226   static char buf[64];
 227
 228   switch (state)
 229     {
 230     case TD_THR_STOPPED:
 231       return "stopped by debugger";
 232     case TD_THR_RUN:
 233       return "runnable";
 234     case TD_THR_ACTIVE:
 235       return "active";
 236     case TD_THR_ZOMBIE:
 237       return "zombie";
 238     case TD_THR_SLEEP:
 239       return "sleeping";
 240     case TD_THR_STOPPED_ASLEEP:
 241       return "stopped by debugger AND blocked";
 242     default:
 243       snprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
 244       return buf;
 245     }
 246 }
 247 \f
 248 /* A callback function for td_ta_thr_iter, which we use to map all
 249    threads to LWPs.
 250
 251    THP is a handle to the current thread; if INFOP is not NULL, the
 252    struct thread_info associated with this thread is returned in
 253    *INFOP.
 254
 255    If the thread is a zombie, TD_THR_ZOMBIE is returned.  Otherwise,
 256    zero is returned to indicate success.  */
 257
 258 static int
 259 thread_get_info_callback (const td_thrhandle_t *thp, void *infop)
 260 {
 261   td_thrinfo_t ti;
 262   td_err_e err;
 263   struct thread_info *thread_info;
 264   ptid_t thread_ptid;
 265
 266   err = td_thr_get_info_p (thp, &ti);
 267   if (err != TD_OK)
 268     error (_("thread_get_info_callback: cannot get thread info: %s"),
 269            thread_db_err_str (err));
 270
 271   /* Fill the cache.  */
 272   thread_ptid = ptid_build (GET_PID (inferior_ptid), ti.ti_lid, ti.ti_tid);
 273   thread_info = find_thread_pid (thread_ptid);
 274
 275   /* In the case of a zombie thread, don't continue.  We don't want to
 276      attach to it thinking it is a new thread.  */
 277   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
 278     {
 279       if (infop != NULL)
 280         *(struct thread_info **) infop = thread_info;
 281       if (thread_info != NULL)
 282         {
 283           memcpy (&thread_info->private->th, thp, sizeof (*thp));
 284           thread_info->private->th_valid = 1;
 285           memcpy (&thread_info->private->ti, &ti, sizeof (ti));
 286           thread_info->private->ti_valid = 1;
 287         }
 288       return TD_THR_ZOMBIE;
 289     }
 290
 291   if (thread_info == NULL)
 292     {
 293       /* New thread.  Attach to it now (why wait?).  */
 294       attach_thread (thread_ptid, thp, &ti, 1);
 295       thread_info = find_thread_pid (thread_ptid);
 296       gdb_assert (thread_info != NULL);
 297     }
 298
 299   memcpy (&thread_info->private->th, thp, sizeof (*thp));
 300   thread_info->private->th_valid = 1;
 301   memcpy (&thread_info->private->ti, &ti, sizeof (ti));
 302   thread_info->private->ti_valid = 1;
 303
 304   if (infop != NULL)
 305     *(struct thread_info **) infop = thread_info;
 306
 307   return 0;
 308 }
 309
 310 /* Accessor functions for the thread_db information, with caching.  */
 311
 312 static void
 313 thread_db_map_id2thr (struct thread_info *thread_info, int fatal)
 314 {
 315   td_err_e err;
 316
 317   if (thread_info->private->th_valid)
 318     return;
 319
 320   err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (thread_info->ptid),
 321                             &thread_info->private->th);
 322   if (err != TD_OK)
 323     {
 324       if (fatal)
 325         error (_("Cannot find thread %ld: %s"),
 326                (long) GET_THREAD (thread_info->ptid),
 327                thread_db_err_str (err));
 328     }
 329   else
 330     thread_info->private->th_valid = 1;
 331 }
 332
 333 static td_thrinfo_t *
 334 thread_db_get_info (struct thread_info *thread_info)
 335 {
 336   td_err_e err;
 337
 338   if (thread_info->private->ti_valid)
 339     return &thread_info->private->ti;
 340
 341   if (!thread_info->private->th_valid)
 342     thread_db_map_id2thr (thread_info, 1);
 343
 344   err =
 345     td_thr_get_info_p (&thread_info->private->th, &thread_info->private->ti);
 346   if (err != TD_OK)
 347     error (_("thread_db_get_info: cannot get thread info: %s"),
 348            thread_db_err_str (err));
 349
 350   thread_info->private->ti_valid = 1;
 351   return &thread_info->private->ti;
 352 }
 353 \f
 354 /* Convert between user-level thread ids and LWP ids.  */
 355
 356 static ptid_t
 357 thread_from_lwp (ptid_t ptid)
 358 {
 359   td_thrhandle_t th;
 360   td_err_e err;
 361   struct thread_info *thread_info;
 362   ptid_t thread_ptid;
 363
 364   if (GET_LWP (ptid) == 0)
 365     ptid = BUILD_LWP (GET_PID (ptid), GET_PID (ptid));
 366
 367   gdb_assert (is_lwp (ptid));
 368
 369   err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
 370   if (err != TD_OK)
 371     error (_("Cannot find user-level thread for LWP %ld: %s"),
 372            GET_LWP (ptid), thread_db_err_str (err));
 373
 374   thread_info = NULL;
 375
 376   /* Fetch the thread info.  If we get back TD_THR_ZOMBIE, then the
 377      event thread has already died.  If another gdb interface has called
 378      thread_alive() previously, the thread won't be found on the thread list
 379      anymore.  In that case, we don't want to process this ptid anymore
 380      to avoid the possibility of later treating it as a newly
 381      discovered thread id that we should add to the list.  Thus,
 382      we return a -1 ptid which is also how the thread list marks a
 383      dead thread.  */
 384   if (thread_get_info_callback (&th, &thread_info) == TD_THR_ZOMBIE
 385       && thread_info == NULL)
 386     return pid_to_ptid (-1);
 387
 388   gdb_assert (thread_info && thread_info->private->ti_valid);
 389
 390   return ptid_build (GET_PID (ptid), GET_LWP (ptid),
 391                      thread_info->private->ti.ti_tid);
 392 }
 393
 394 static ptid_t
 395 lwp_from_thread (ptid_t ptid)
 396 {
 397   return BUILD_LWP (GET_LWP (ptid), GET_PID (ptid));
 398 }
 399 \f
 400
 401 void
 402 thread_db_init (struct target_ops *target)
 403 {
 404   target_beneath = target;
 405 }
 406
 407 static void *
 408 verbose_dlsym (void *handle, const char *name)
 409 {
 410   void *sym = dlsym (handle, name);
 411   if (sym == NULL)
 412     warning (_("Symbol \"%s\" not found in libthread_db: %s"), name, dlerror ());
 413   return sym;
 414 }
 415
 416 static int
 417 thread_db_load (void)
 418 {
 419   void *handle;
 420   td_err_e err;
 421
 422   handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW);
 423   if (handle == NULL)
 424     {
 425       fprintf_filtered (gdb_stderr, "\n\ndlopen failed on '%s' - %s\n",
 426                         LIBTHREAD_DB_SO, dlerror ());
 427       fprintf_filtered (gdb_stderr,
 428                         "GDB will not be able to debug pthreads.\n\n");
 429       return 0;
 430     }
 431
 432   /* Initialize pointers to the dynamic library functions we will use.
 433      Essential functions first.  */
 434
 435   td_init_p = verbose_dlsym (handle, "td_init");
 436   if (td_init_p == NULL)
 437     return 0;
 438
 439   td_ta_new_p = verbose_dlsym (handle, "td_ta_new");
 440   if (td_ta_new_p == NULL)
 441     return 0;
 442
 443   td_ta_map_id2thr_p = verbose_dlsym (handle, "td_ta_map_id2thr");
 444   if (td_ta_map_id2thr_p == NULL)
 445     return 0;
 446
 447   td_ta_map_lwp2thr_p = verbose_dlsym (handle, "td_ta_map_lwp2thr");
 448   if (td_ta_map_lwp2thr_p == NULL)
 449     return 0;
 450
 451   td_ta_thr_iter_p = verbose_dlsym (handle, "td_ta_thr_iter");
 452   if (td_ta_thr_iter_p == NULL)
 453     return 0;
 454
 455   td_thr_validate_p = verbose_dlsym (handle, "td_thr_validate");
 456   if (td_thr_validate_p == NULL)
 457     return 0;
 458
 459   td_thr_get_info_p = verbose_dlsym (handle, "td_thr_get_info");
 460   if (td_thr_get_info_p == NULL)
 461     return 0;
 462
 463   td_thr_getfpregs_p = verbose_dlsym (handle, "td_thr_getfpregs");
 464   if (td_thr_getfpregs_p == NULL)
 465     return 0;
 466
 467   td_thr_getgregs_p = verbose_dlsym (handle, "td_thr_getgregs");
 468   if (td_thr_getgregs_p == NULL)
 469     return 0;
 470
 471   td_thr_setfpregs_p = verbose_dlsym (handle, "td_thr_setfpregs");
 472   if (td_thr_setfpregs_p == NULL)
 473     return 0;
 474
 475   td_thr_setgregs_p = verbose_dlsym (handle, "td_thr_setgregs");
 476   if (td_thr_setgregs_p == NULL)
 477     return 0;
 478
 479   /* Initialize the library.  */
 480   err = td_init_p ();
 481   if (err != TD_OK)
 482     {
 483       warning (_("Cannot initialize libthread_db: %s"), thread_db_err_str (err));
 484       return 0;
 485     }
 486
 487   /* These are not essential.  */
 488   td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr");
 489   td_ta_set_event_p = dlsym (handle, "td_ta_set_event");
 490   td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg");
 491   td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable");
 492   td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr");
 493
 494   return 1;
 495 }
 496
 497 static td_err_e
 498 enable_thread_event (td_thragent_t *thread_agent, int event, CORE_ADDR *bp)
 499 {
 500   td_notify_t notify;
 501   td_err_e err;
 502
 503   /* Get the breakpoint address for thread EVENT.  */
 504   err = td_ta_event_addr_p (thread_agent, event, &notify);
 505   if (err != TD_OK)
 506     return err;
 507
 508   /* Set up the breakpoint.  */
 509   gdb_assert (exec_bfd);
 510   (*bp) = (gdbarch_convert_from_func_ptr_addr
 511            (current_gdbarch,
 512             /* Do proper sign extension for the target.  */
 513             (bfd_get_sign_extend_vma (exec_bfd) > 0
 514              ? (CORE_ADDR) (intptr_t) notify.u.bptaddr
 515              : (CORE_ADDR) (uintptr_t) notify.u.bptaddr),
 516             &current_target));
 517   create_thread_event_breakpoint ((*bp));
 518
 519   return TD_OK;
 520 }
 521
 522 static void
 523 enable_thread_event_reporting (void)
 524 {
 525   td_thr_events_t events;
 526   td_notify_t notify;
 527   td_err_e err;
 528 #ifdef HAVE_GNU_LIBC_VERSION_H
 529   const char *libc_version;
 530   int libc_major, libc_minor;
 531 #endif
 532
 533   /* We cannot use the thread event reporting facility if these
 534      functions aren't available.  */
 535   if (td_ta_event_addr_p == NULL || td_ta_set_event_p == NULL
 536       || td_ta_event_getmsg_p == NULL || td_thr_event_enable_p == NULL)
 537     return;
 538
 539   /* Set the process wide mask saying which events we're interested in.  */
 540   td_event_emptyset (&events);
 541   td_event_addset (&events, TD_CREATE);
 542
 543 #ifdef HAVE_GNU_LIBC_VERSION_H
 544   /* FIXME: kettenis/2000-04-23: The event reporting facility is
 545      broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
 546      now.  */
 547   libc_version = gnu_get_libc_version ();
 548   if (sscanf (libc_version, "%d.%d", &libc_major, &libc_minor) == 2
 549       && (libc_major > 2 || (libc_major == 2 && libc_minor > 1)))
 550 #endif
 551     td_event_addset (&events, TD_DEATH);
 552
 553   err = td_ta_set_event_p (thread_agent, &events);
 554   if (err != TD_OK)
 555     {
 556       warning (_("Unable to set global thread event mask: %s"),
 557                thread_db_err_str (err));
 558       return;
 559     }
 560
 561   /* Delete previous thread event breakpoints, if any.  */
 562   remove_thread_event_breakpoints ();
 563   td_create_bp_addr = 0;
 564   td_death_bp_addr = 0;
 565
 566   /* Set up the thread creation event.  */
 567   err = enable_thread_event (thread_agent, TD_CREATE, &td_create_bp_addr);
 568   if (err != TD_OK)
 569     {
 570       warning (_("Unable to get location for thread creation breakpoint: %s"),
 571                thread_db_err_str (err));
 572       return;
 573     }
 574
 575   /* Set up the thread death event.  */
 576   err = enable_thread_event (thread_agent, TD_DEATH, &td_death_bp_addr);
 577   if (err != TD_OK)
 578     {
 579       warning (_("Unable to get location for thread death breakpoint: %s"),
 580                thread_db_err_str (err));
 581       return;
 582     }
 583 }
 584
 585 static void
 586 disable_thread_event_reporting (void)
 587 {
 588   td_thr_events_t events;
 589
 590   /* Set the process wide mask saying we aren't interested in any
 591      events anymore.  */
 592   td_event_emptyset (&events);
 593   td_ta_set_event_p (thread_agent, &events);
 594
 595   /* Delete thread event breakpoints, if any.  */
 596   remove_thread_event_breakpoints ();
 597   td_create_bp_addr = 0;
 598   td_death_bp_addr = 0;
 599 }
 600
 601 static void
 602 check_thread_signals (void)
 603 {
 604 #ifdef GET_THREAD_SIGNALS
 605   if (!thread_signals)
 606     {
 607       sigset_t mask;
 608       int i;
 609
 610       GET_THREAD_SIGNALS (&mask);
 611       sigemptyset (&thread_stop_set);
 612       sigemptyset (&thread_print_set);
 613
 614       for (i = 1; i < NSIG; i++)
 615         {
 616           if (sigismember (&mask, i))
 617             {
 618               if (signal_stop_update (target_signal_from_host (i), 0))
 619                 sigaddset (&thread_stop_set, i);
 620               if (signal_print_update (target_signal_from_host (i), 0))
 621                 sigaddset (&thread_print_set, i);
 622               thread_signals = 1;
 623             }
 624         }
 625     }
 626 #endif
 627 }
 628
 629 static void
 630 thread_db_new_objfile (struct objfile *objfile)
 631 {
 632   td_err_e err;
 633
 634   /* First time through, report that libthread_db was successfuly
 635      loaded.  Can't print this in in thread_db_load as, at that stage,
 636      the interpreter and it's console haven't started.  The real
 637      problem here is that libthread_db is loaded too early - it should
 638      only be loaded when there is a program to debug.  */
 639   {
 640     static int dejavu;
 641     if (!dejavu)
 642       {
 643         Dl_info info;
 644         const char *library = NULL;
 645         /* Try dladdr.  */
 646         if (dladdr ((*td_ta_new_p), &info) != 0)
 647           library = info.dli_fname;
 648         /* Try dlinfo?  */
 649         if (library == NULL)
 650           /* Paranoid - don't let a NULL path slip through.  */
 651           library = LIBTHREAD_DB_SO;
 652         printf_unfiltered (_("Using host libthread_db library \"%s\".\n"),
 653                            library);
 654         dejavu = 1;
 655       }
 656   }
 657
 658   /* Don't attempt to use thread_db on targets which can not run
 659      (core files).  */
 660   if (objfile == NULL || !target_has_execution)
 661     {
 662       /* All symbols have been discarded.  If the thread_db target is
 663          active, deactivate it now.  */
 664       if (using_thread_db)
 665         {
 666           gdb_assert (proc_handle.pid == 0);
 667           unpush_target (&thread_db_ops);
 668           using_thread_db = 0;
 669         }
 670
 671       goto quit;
 672     }
 673
 674   if (using_thread_db)
 675     /* Nothing to do.  The thread library was already detected and the
 676        target vector was already activated.  */
 677     goto quit;
 678
 679   /* Initialize the structure that identifies the child process.  Note
 680      that at this point there is no guarantee that we actually have a
 681      child process.  */
 682   proc_handle.pid = GET_PID (inferior_ptid);
 683
 684   /* Now attempt to open a connection to the thread library.  */
 685   err = td_ta_new_p (&proc_handle, &thread_agent);
 686   switch (err)
 687     {
 688     case TD_NOLIBTHREAD:
 689       /* No thread library was detected.  */
 690       break;
 691
 692     case TD_OK:
 693       printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
 694
 695       /* The thread library was detected.  Activate the thread_db target.  */
 696       push_target (&thread_db_ops);
 697       using_thread_db = 1;
 698
 699       enable_thread_event_reporting ();
 700       thread_db_find_new_threads ();
 701       break;
 702
 703     default:
 704       warning (_("Cannot initialize thread debugging library: %s"),
 705                thread_db_err_str (err));
 706       break;
 707     }
 708
 709 quit:
 710   if (target_new_objfile_chain)
 711     target_new_objfile_chain (objfile);
 712 }
 713
 714 /* Attach to a new thread.  This function is called when we receive a
 715    TD_CREATE event or when we iterate over all threads and find one
 716    that wasn't already in our list.  */
 717
 718 static void
 719 attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
 720                const td_thrinfo_t *ti_p, int verbose)
 721 {
 722   struct thread_info *tp;
 723   td_err_e err;
 724
 725   /* If we're being called after a TD_CREATE event, we may already
 726      know about this thread.  There are two ways this can happen.  We
 727      may have iterated over all threads between the thread creation
 728      and the TD_CREATE event, for instance when the user has issued
 729      the `info threads' command before the SIGTRAP for hitting the
 730      thread creation breakpoint was reported.  Alternatively, the
 731      thread may have exited and a new one been created with the same
 732      thread ID.  In the first case we don't need to do anything; in
 733      the second case we should discard information about the dead
 734      thread and attach to the new one.  */
 735   if (in_thread_list (ptid))
 736     {
 737       tp = find_thread_pid (ptid);
 738       gdb_assert (tp != NULL);
 739
 740       if (!tp->private->dying)
 741         return;
 742
 743       delete_thread (ptid);
 744     }
 745
 746   check_thread_signals ();
 747
 748   /* Add the thread to GDB's thread list.  */
 749   tp = add_thread (ptid);
 750   tp->private = xmalloc (sizeof (struct private_thread_info));
 751   memset (tp->private, 0, sizeof (struct private_thread_info));
 752
 753   if (verbose)
 754     printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
 755
 756   if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
 757     return;                     /* A zombie thread -- do not attach.  */
 758
 759   /* Under GNU/Linux, we have to attach to each and every thread.  */
 760 #ifdef ATTACH_LWP
 761   ATTACH_LWP (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0);
 762 #endif
 763
 764   /* Enable thread event reporting for this thread.  */
 765   err = td_thr_event_enable_p (th_p, 1);
 766   if (err != TD_OK)
 767     error (_("Cannot enable thread event reporting for %s: %s"),
 768            target_pid_to_str (ptid), thread_db_err_str (err));
 769 }
 770
 771 static void
 772 thread_db_attach (char *args, int from_tty)
 773 {
 774   target_beneath->to_attach (args, from_tty);
 775
 776   /* Destroy thread info; it's no longer valid.  */
 777   init_thread_list ();
 778
 779   /* The child process is now the actual multi-threaded
 780      program.  Snatch its process ID...  */
 781   proc_handle.pid = GET_PID (inferior_ptid);
 782
 783   /* ...and perform the remaining initialization steps.  */
 784   enable_thread_event_reporting ();
 785   thread_db_find_new_threads ();
 786 }
 787
 788 static void
 789 detach_thread (ptid_t ptid, int verbose)
 790 {
 791   struct thread_info *thread_info;
 792
 793   if (verbose)
 794     printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid));
 795
 796   /* Don't delete the thread now, because it still reports as active
 797      until it has executed a few instructions after the event
 798      breakpoint - if we deleted it now, "info threads" would cause us
 799      to re-attach to it.  Just mark it as having had a TD_DEATH
 800      event.  This means that we won't delete it from our thread list
 801      until we notice that it's dead (via prune_threads), or until
 802      something re-uses its thread ID.  */
 803   thread_info = find_thread_pid (ptid);
 804   gdb_assert (thread_info != NULL);
 805   thread_info->private->dying = 1;
 806 }
 807
 808 static void
 809 thread_db_detach (char *args, int from_tty)
 810 {
 811   disable_thread_event_reporting ();
 812
 813   /* There's no need to save & restore inferior_ptid here, since the
 814      inferior is supposed to be survive this function call.  */
 815   inferior_ptid = lwp_from_thread (inferior_ptid);
 816
 817   /* Forget about the child's process ID.  We shouldn't need it
 818      anymore.  */
 819   proc_handle.pid = 0;
 820
 821   target_beneath->to_detach (args, from_tty);
 822 }
 823
 824 static int
 825 clear_lwpid_callback (struct thread_info *thread, void *dummy)
 826 {
 827   /* If we know that our thread implementation is 1-to-1, we could save
 828      a certain amount of information; it's not clear how much, so we
 829      are always conservative.  */
 830
 831   thread->private->th_valid = 0;
 832   thread->private->ti_valid = 0;
 833
 834   return 0;
 835 }
 836
 837 static void
 838 thread_db_resume (ptid_t ptid, int step, enum target_signal signo)
 839 {
 840   struct cleanup *old_chain = save_inferior_ptid ();
 841
 842   if (GET_PID (ptid) == -1)
 843     inferior_ptid = lwp_from_thread (inferior_ptid);
 844   else if (is_thread (ptid))
 845     ptid = lwp_from_thread (ptid);
 846
 847   /* Clear cached data which may not be valid after the resume.  */
 848   iterate_over_threads (clear_lwpid_callback, NULL);
 849
 850   target_beneath->to_resume (ptid, step, signo);
 851
 852   do_cleanups (old_chain);
 853 }
 854
 855 /* Check if PID is currently stopped at the location of a thread event
 856    breakpoint location.  If it is, read the event message and act upon
 857    the event.  */
 858
 859 static void
 860 check_event (ptid_t ptid)
 861 {
 862   td_event_msg_t msg;
 863   td_thrinfo_t ti;
 864   td_err_e err;
 865   CORE_ADDR stop_pc;
 866   int loop = 0;
 867
 868   /* Bail out early if we're not at a thread event breakpoint.  */
 869   stop_pc = read_pc_pid (ptid) - DECR_PC_AFTER_BREAK;
 870   if (stop_pc != td_create_bp_addr && stop_pc != td_death_bp_addr)
 871     return;
 872
 873   /* If we are at a create breakpoint, we do not know what new lwp
 874      was created and cannot specifically locate the event message for it.
 875      We have to call td_ta_event_getmsg() to get
 876      the latest message.  Since we have no way of correlating whether
 877      the event message we get back corresponds to our breakpoint, we must
 878      loop and read all event messages, processing them appropriately.
 879      This guarantees we will process the correct message before continuing
 880      from the breakpoint.
 881
 882      Currently, death events are not enabled.  If they are enabled,
 883      the death event can use the td_thr_event_getmsg() interface to
 884      get the message specifically for that lwp and avoid looping
 885      below.  */
 886
 887   loop = 1;
 888
 889   do
 890     {
 891       err = td_ta_event_getmsg_p (thread_agent, &msg);
 892       if (err != TD_OK)
 893         {
 894           if (err == TD_NOMSG)
 895             return;
 896
 897           error (_("Cannot get thread event message: %s"),
 898                  thread_db_err_str (err));
 899         }
 900
 901       err = td_thr_get_info_p (msg.th_p, &ti);
 902       if (err != TD_OK)
 903         error (_("Cannot get thread info: %s"), thread_db_err_str (err));
 904
 905       ptid = ptid_build (GET_PID (ptid), ti.ti_lid, ti.ti_tid);
 906
 907       switch (msg.event)
 908         {
 909         case TD_CREATE:
 910           /* Call attach_thread whether or not we already know about a
 911              thread with this thread ID.  */
 912           attach_thread (ptid, msg.th_p, &ti, 1);
 913
 914           break;
 915
 916         case TD_DEATH:
 917
 918           if (!in_thread_list (ptid))
 919             error (_("Spurious thread death event."));
 920
 921           detach_thread (ptid, 1);
 922
 923           break;
 924
 925         default:
 926           error (_("Spurious thread event."));
 927         }
 928     }
 929   while (loop);
 930 }
 931
 932 static ptid_t
 933 thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 934 {
 935   extern ptid_t trap_ptid;
 936
 937   if (GET_PID (ptid) != -1 && is_thread (ptid))
 938     ptid = lwp_from_thread (ptid);
 939
 940   ptid = target_beneath->to_wait (ptid, ourstatus);
 941
 942   if (proc_handle.pid == 0)
 943     /* The current child process isn't the actual multi-threaded
 944        program yet, so don't try to do any special thread-specific
 945        post-processing and bail out early.  */
 946     return ptid;
 947
 948   if (ourstatus->kind == TARGET_WAITKIND_EXITED)
 949     return pid_to_ptid (-1);
 950
 951   if (ourstatus->kind == TARGET_WAITKIND_STOPPED
 952       && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
 953     /* Check for a thread event.  */
 954     check_event (ptid);
 955
 956   if (!ptid_equal (trap_ptid, null_ptid))
 957     trap_ptid = thread_from_lwp (trap_ptid);
 958
 959   /* Change the ptid back into the higher level PID + TID format.
 960      If the thread is dead and no longer on the thread list, we will
 961      get back a dead ptid.  This can occur if the thread death event
 962      gets postponed by other simultaneous events.  In such a case,
 963      we want to just ignore the event and continue on.  */
 964   ptid = thread_from_lwp (ptid);
 965   if (GET_PID (ptid) == -1)
 966     ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 967
 968   return ptid;
 969 }
 970
 971 static LONGEST
 972 thread_db_xfer_partial (struct target_ops *ops, enum target_object object,
 973                         const char *annex, gdb_byte *readbuf,
 974                         const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
 975 {
 976   struct cleanup *old_chain = save_inferior_ptid ();
 977   LONGEST xfer;
 978
 979   if (is_thread (inferior_ptid))
 980     {
 981       /* FIXME: This seems to be necessary to make sure breakpoints
 982          are removed.  */
 983       if (!target_thread_alive (inferior_ptid))
 984         inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
 985       else
 986         inferior_ptid = lwp_from_thread (inferior_ptid);
 987     }
 988
 989   xfer = target_beneath->to_xfer_partial (ops, object, annex,
 990                                           readbuf, writebuf, offset, len);
 991
 992   do_cleanups (old_chain);
 993   return xfer;
 994 }
 995
 996 static void
 997 thread_db_fetch_registers (int regno)
 998 {
 999   struct thread_info *thread_info;
1000   prgregset_t gregset;
1001   gdb_prfpregset_t fpregset;
1002   td_err_e err;
1003
1004   if (!is_thread (inferior_ptid))
1005     {
1006       /* Pass the request to the target beneath us.  */
1007       target_beneath->to_fetch_registers (regno);
1008       return;
1009     }
1010
1011   thread_info = find_thread_pid (inferior_ptid);
1012   thread_db_map_id2thr (thread_info, 1);
1013
1014   err = td_thr_getgregs_p (&thread_info->private->th, gregset);
1015   if (err != TD_OK)
1016     error (_("Cannot fetch general-purpose registers for thread %ld: %s"),
1017            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
1018
1019   err = td_thr_getfpregs_p (&thread_info->private->th, &fpregset);
1020   if (err != TD_OK)
1021     error (_("Cannot get floating-point registers for thread %ld: %s"),
1022            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
1023
1024   /* Note that we must call supply_gregset after calling the thread_db
1025      routines because the thread_db routines call ps_lgetgregs and
1026      friends which clobber GDB's register cache.  */
1027   supply_gregset ((gdb_gregset_t *) gregset);
1028   supply_fpregset (&fpregset);
1029 }
1030
1031 static void
1032 thread_db_store_registers (int regno)
1033 {
1034   prgregset_t gregset;
1035   gdb_prfpregset_t fpregset;
1036   td_err_e err;
1037   struct thread_info *thread_info;
1038
1039   if (!is_thread (inferior_ptid))
1040     {
1041       /* Pass the request to the target beneath us.  */
1042       target_beneath->to_store_registers (regno);
1043       return;
1044     }
1045
1046   thread_info = find_thread_pid (inferior_ptid);
1047   thread_db_map_id2thr (thread_info, 1);
1048
1049   if (regno != -1)
1050     {
1051       char raw[MAX_REGISTER_SIZE];
1052
1053       deprecated_read_register_gen (regno, raw);
1054       thread_db_fetch_registers (-1);
1055       regcache_raw_supply (current_regcache, regno, raw);
1056     }
1057
1058   fill_gregset ((gdb_gregset_t *) gregset, -1);
1059   fill_fpregset (&fpregset, -1);
1060
1061   err = td_thr_setgregs_p (&thread_info->private->th, gregset);
1062   if (err != TD_OK)
1063     error (_("Cannot store general-purpose registers for thread %ld: %s"),
1064            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
1065   err = td_thr_setfpregs_p (&thread_info->private->th, &fpregset);
1066   if (err != TD_OK)
1067     error (_("Cannot store floating-point registers  for thread %ld: %s"),
1068            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
1069 }
1070
1071 static void
1072 thread_db_kill (void)
1073 {
1074   /* There's no need to save & restore inferior_ptid here, since the
1075      inferior isn't supposed to survive this function call.  */
1076   inferior_ptid = lwp_from_thread (inferior_ptid);
1077   target_beneath->to_kill ();
1078 }
1079
1080 static void
1081 thread_db_create_inferior (char *exec_file, char *allargs, char **env,
1082                            int from_tty)
1083 {
1084   unpush_target (&thread_db_ops);
1085   using_thread_db = 0;
1086   target_beneath->to_create_inferior (exec_file, allargs, env, from_tty);
1087 }
1088
1089 static void
1090 thread_db_post_startup_inferior (ptid_t ptid)
1091 {
1092   if (proc_handle.pid == 0)
1093     {
1094       /* The child process is now the actual multi-threaded
1095          program.  Snatch its process ID...  */
1096       proc_handle.pid = GET_PID (ptid);
1097
1098       /* ...and perform the remaining initialization steps.  */
1099       enable_thread_event_reporting ();
1100       thread_db_find_new_threads ();
1101     }
1102 }
1103
1104 static void
1105 thread_db_mourn_inferior (void)
1106 {
1107   remove_thread_event_breakpoints ();
1108
1109   /* Forget about the child's process ID.  We shouldn't need it
1110      anymore.  */
1111   proc_handle.pid = 0;
1112
1113   target_beneath->to_mourn_inferior ();
1114
1115   /* Detach thread_db target ops.  */
1116   unpush_target (&thread_db_ops);
1117   using_thread_db = 0;
1118 }
1119
1120 static int
1121 thread_db_thread_alive (ptid_t ptid)
1122 {
1123   td_thrhandle_t th;
1124   td_err_e err;
1125
1126   if (is_thread (ptid))
1127     {
1128       struct thread_info *thread_info;
1129       thread_info = find_thread_pid (ptid);
1130
1131       thread_db_map_id2thr (thread_info, 0);
1132       if (!thread_info->private->th_valid)
1133         return 0;
1134
1135       err = td_thr_validate_p (&thread_info->private->th);
1136       if (err != TD_OK)
1137         return 0;
1138
1139       if (!thread_info->private->ti_valid)
1140         {
1141           err =
1142             td_thr_get_info_p (&thread_info->private->th,
1143                                &thread_info->private->ti);
1144           if (err != TD_OK)
1145             return 0;
1146           thread_info->private->ti_valid = 1;
1147         }
1148
1149       if (thread_info->private->ti.ti_state == TD_THR_UNKNOWN
1150           || thread_info->private->ti.ti_state == TD_THR_ZOMBIE)
1151         return 0;               /* A zombie thread.  */
1152
1153       return 1;
1154     }
1155
1156   if (target_beneath->to_thread_alive)
1157     return target_beneath->to_thread_alive (ptid);
1158
1159   return 0;
1160 }
1161
1162 static int
1163 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
1164 {
1165   td_thrinfo_t ti;
1166   td_err_e err;
1167   ptid_t ptid;
1168
1169   err = td_thr_get_info_p (th_p, &ti);
1170   if (err != TD_OK)
1171     error (_("find_new_threads_callback: cannot get thread info: %s"),
1172            thread_db_err_str (err));
1173
1174   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
1175     return 0;                   /* A zombie -- ignore.  */
1176
1177   ptid = ptid_build (GET_PID (inferior_ptid), ti.ti_lid, ti.ti_tid);
1178
1179   if (!in_thread_list (ptid))
1180     attach_thread (ptid, th_p, &ti, 1);
1181
1182   return 0;
1183 }
1184
1185 static void
1186 thread_db_find_new_threads (void)
1187 {
1188   td_err_e err;
1189
1190   /* Iterate over all user-space threads to discover new threads.  */
1191   err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback, NULL,
1192                           TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1193                           TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1194   if (err != TD_OK)
1195     error (_("Cannot find new threads: %s"), thread_db_err_str (err));
1196 }
1197
1198 static char *
1199 thread_db_pid_to_str (ptid_t ptid)
1200 {
1201   if (is_thread (ptid))
1202     {
1203       static char buf[64];
1204       td_thrinfo_t *ti_p;
1205       td_err_e err;
1206       struct thread_info *thread_info;
1207
1208       thread_info = find_thread_pid (ptid);
1209       thread_db_map_id2thr (thread_info, 0);
1210       if (!thread_info->private->th_valid)
1211         {
1212           snprintf (buf, sizeof (buf), "Thread %ld (Missing)",
1213                     GET_THREAD (ptid));
1214           return buf;
1215         }
1216
1217       ti_p = thread_db_get_info (thread_info);
1218
1219       if (ti_p->ti_state == TD_THR_ACTIVE && ti_p->ti_lid != 0)
1220         {
1221           snprintf (buf, sizeof (buf), "Thread %ld (LWP %d)",
1222                     (long) ti_p->ti_tid, ti_p->ti_lid);
1223         }
1224       else
1225         {
1226           snprintf (buf, sizeof (buf), "Thread %ld (%s)",
1227                     (long) ti_p->ti_tid,
1228                     thread_db_state_str (ti_p->ti_state));
1229         }
1230
1231       return buf;
1232     }
1233
1234   if (target_beneath->to_pid_to_str (ptid))
1235     return target_beneath->to_pid_to_str (ptid);
1236
1237   return normal_pid_to_str (ptid);
1238 }
1239
1240 /* Get the address of the thread local variable in load module LM which
1241    is stored at OFFSET within the thread local storage for thread PTID.  */
1242
1243 static CORE_ADDR
1244 thread_db_get_thread_local_address (ptid_t ptid,
1245                                     CORE_ADDR lm,
1246                                     CORE_ADDR offset)
1247 {
1248   if (is_thread (ptid))
1249     {
1250       td_err_e err;
1251       void *address;
1252       struct thread_info *thread_info;
1253
1254       /* glibc doesn't provide the needed interface.  */
1255       if (!td_thr_tls_get_addr_p)
1256         throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR,
1257                      _("No TLS library support"));
1258
1259       /* Caller should have verified that lm != 0.  */
1260       gdb_assert (lm != 0);
1261
1262       /* Get info about the thread.  */
1263       thread_info = find_thread_pid (ptid);
1264       thread_db_map_id2thr (thread_info, 1);
1265
1266       /* Finally, get the address of the variable.  */
1267       err = td_thr_tls_get_addr_p (&thread_info->private->th, (void *) lm,
1268                                    offset, &address);
1269
1270 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1271       /* The memory hasn't been allocated, yet.  */
1272       if (err == TD_NOTALLOC)
1273           /* Now, if libthread_db provided the initialization image's
1274              address, we *could* try to build a non-lvalue value from
1275              the initialization image.  */
1276         throw_error (TLS_NOT_ALLOCATED_YET_ERROR,
1277                      _("TLS not allocated yet"));
1278 #endif
1279
1280       /* Something else went wrong.  */
1281       if (err != TD_OK)
1282         throw_error (TLS_GENERIC_ERROR,
1283                      (("%s")), thread_db_err_str (err));
1284
1285       /* Cast assuming host == target.  Joy.  */
1286       /* Do proper sign extension for the target.  */
1287       gdb_assert (exec_bfd);
1288       return (bfd_get_sign_extend_vma (exec_bfd) > 0
1289               ? (CORE_ADDR) (intptr_t) address
1290               : (CORE_ADDR) (uintptr_t) address);
1291     }
1292
1293   if (target_beneath->to_get_thread_local_address)
1294     return target_beneath->to_get_thread_local_address (ptid, lm, offset);
1295   else
1296     throw_error (TLS_GENERIC_ERROR,
1297                  _("TLS not supported on this target"));
1298 }
1299
1300 static void
1301 init_thread_db_ops (void)
1302 {
1303   thread_db_ops.to_shortname = "multi-thread";
1304   thread_db_ops.to_longname = "multi-threaded child process.";
1305   thread_db_ops.to_doc = "Threads and pthreads support.";
1306   thread_db_ops.to_attach = thread_db_attach;
1307   thread_db_ops.to_detach = thread_db_detach;
1308   thread_db_ops.to_resume = thread_db_resume;
1309   thread_db_ops.to_wait = thread_db_wait;
1310   thread_db_ops.to_fetch_registers = thread_db_fetch_registers;
1311   thread_db_ops.to_store_registers = thread_db_store_registers;
1312   thread_db_ops.to_xfer_partial = thread_db_xfer_partial;
1313   thread_db_ops.to_kill = thread_db_kill;
1314   thread_db_ops.to_create_inferior = thread_db_create_inferior;
1315   thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior;
1316   thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
1317   thread_db_ops.to_thread_alive = thread_db_thread_alive;
1318   thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
1319   thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
1320   thread_db_ops.to_stratum = thread_stratum;
1321   thread_db_ops.to_has_thread_control = tc_schedlock;
1322   thread_db_ops.to_get_thread_local_address
1323     = thread_db_get_thread_local_address;
1324   thread_db_ops.to_magic = OPS_MAGIC;
1325 }
1326
1327 void
1328 _initialize_thread_db (void)
1329 {
1330   /* Only initialize the module if we can load libthread_db.  */
1331   if (thread_db_load ())
1332     {
1333       init_thread_db_ops ();
1334       add_target (&thread_db_ops);
1335
1336       /* Add ourselves to objfile event chain.  */
1337       target_new_objfile_chain = deprecated_target_new_objfile_hook;
1338       deprecated_target_new_objfile_hook = thread_db_new_objfile;
1339     }
1340 }