toolchain/gdb/patches/710-debian_thread-db-multiple-libraries.patch

   1 Support loading two libthread_db DSOs.  In this case, the LinuxThreads
   2 and NPTL ones.
   3
   4 Index: gdb-6.3/gdb/thread-db.c
   5 ===================================================================
   6 --- gdb-6.3.orig/gdb/thread-db.c        2004-11-10 10:46:24.000000000 -0500
   7 +++ gdb-6.3/gdb/thread-db.c     2004-11-10 11:22:34.858812426 -0500
   8 @@ -79,53 +79,63 @@ static td_thragent_t *thread_agent;
   9
  10  /* Pointers to the libthread_db functions.  */
  11
  12 -static td_err_e (*td_init_p) (void);
  13 +struct thread_db_pointers
  14 +{
  15 +  const char *filename;
  16 +
  17 +  td_err_e (*td_init_p) (void);
  18
  19 -static td_err_e (*td_ta_new_p) (struct ps_prochandle * ps,
  20 -                               td_thragent_t **ta);
  21 -static td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
  22 -                                      td_thrhandle_t *__th);
  23 -static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta,
  24 -                                       lwpid_t lwpid, td_thrhandle_t *th);
  25 -static td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
  26 -                                    td_thr_iter_f *callback, void *cbdata_p,
  27 -                                    td_thr_state_e state, int ti_pri,
  28 -                                    sigset_t *ti_sigmask_p,
  29 -                                    unsigned int ti_user_flags);
  30 -static td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
  31 -                                      td_event_e event, td_notify_t *ptr);
  32 -static td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
  33 -                                     td_thr_events_t *event);
  34 -static td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
  35 -                                        td_event_msg_t *msg);
  36 -
  37 -static td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
  38 -static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
  39 -                                     td_thrinfo_t *infop);
  40 -static td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th,
  41 -                                      gdb_prfpregset_t *regset);
  42 -static td_err_e (*td_thr_getgregs_p) (const td_thrhandle_t *th,
  43 -                                     prgregset_t gregs);
  44 -static td_err_e (*td_thr_setfpregs_p) (const td_thrhandle_t *th,
  45 -                                      const gdb_prfpregset_t *fpregs);
  46 -static td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th,
  47 -                                     prgregset_t gregs);
  48 -static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th,
  49 -                                         int event);
  50 -
  51 -static td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
  52 -                                         void *map_address,
  53 -                                         size_t offset, void **address);
  54 +  td_err_e (*td_ta_new_p) (struct ps_prochandle * ps,
  55 +                          td_thragent_t **ta);
  56 +  td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
  57 +                                 td_thrhandle_t *__th);
  58 +  td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta,
  59 +                                  lwpid_t lwpid, td_thrhandle_t *th);
  60 +
  61 +  td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
  62 +                               td_thr_iter_f *callback, void *cbdata_p,
  63 +                               td_thr_state_e state, int ti_pri,
  64 +                               sigset_t *ti_sigmask_p,
  65 +                               unsigned int ti_user_flags);
  66 +  td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
  67 +                                 td_event_e event, td_notify_t *ptr);
  68 +  td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
  69 +                                td_thr_events_t *event);
  70 +  td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
  71 +                                   td_event_msg_t *msg);
  72 +
  73 +  td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
  74 +  td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
  75 +                                td_thrinfo_t *infop);
  76 +  td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th,
  77 +                                 gdb_prfpregset_t *regset);
  78 +  td_err_e (*td_thr_getgregs_p) (const td_thrhandle_t *th,
  79 +                                prgregset_t gregs);
  80 +  td_err_e (*td_thr_setfpregs_p) (const td_thrhandle_t *th,
  81 +                                 const gdb_prfpregset_t *fpregs);
  82 +  td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th,
  83 +                                prgregset_t gregs);
  84 +  td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th,
  85 +                                    int event);
  86 +
  87 +  td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
  88 +                                    void *map_address,
  89 +                                    size_t offset, void **address);
  90 +
  91 +  struct thread_db_pointers *next;
  92 +};
  93
  94  /* Location of the thread creation event breakpoint.  The code at this
  95     location in the child process will be called by the pthread library
  96     whenever a new thread is created.  By setting a special breakpoint
  97     at this location, GDB can detect when a new thread is created.  We
  98     obtain this location via the td_ta_event_addr call.  */
  99 -static CORE_ADDR td_create_bp_addr;
 100 +CORE_ADDR td_create_bp_addr;
 101
 102  /* Location of the thread death event breakpoint.  */
 103 -static CORE_ADDR td_death_bp_addr;
 104 +CORE_ADDR td_death_bp_addr;
 105 +
 106 +static struct thread_db_pointers *current_pointers, *all_pointers;
 107
 108  /* Prototypes for local functions.  */
 109  static void thread_db_find_new_threads (void);
 110 @@ -262,7 +272,7 @@ thread_get_info_callback (const td_thrha
 111    struct thread_info *thread_info;
 112    ptid_t thread_ptid;
 113
 114 -  err = td_thr_get_info_p (thp, &ti);
 115 +  err = current_pointers->td_thr_get_info_p (thp, &ti);
 116    if (err != TD_OK)
 117      error ("thread_get_info_callback: cannot get thread info: %s",
 118            thread_db_err_str (err));
 119 @@ -316,8 +326,9 @@ thread_db_map_id2thr (struct thread_info
 120    if (thread_info->private->th_valid)
 121      return;
 122
 123 -  err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (thread_info->ptid),
 124 -                           &thread_info->private->th);
 125 +  err = current_pointers->td_ta_map_id2thr_p (thread_agent,
 126 +                                             GET_THREAD (thread_info->ptid),
 127 +                                             &thread_info->private->th);
 128    if (err != TD_OK)
 129      {
 130        if (fatal)
 131 @@ -340,8 +351,8 @@ thread_db_get_info (struct thread_info *
 132    if (!thread_info->private->th_valid)
 133      thread_db_map_id2thr (thread_info, 1);
 134
 135 -  err =
 136 -    td_thr_get_info_p (&thread_info->private->th, &thread_info->private->ti);
 137 +  err = current_pointers->td_thr_get_info_p (&thread_info->private->th,
 138 +                                            &thread_info->private->ti);
 139    if (err != TD_OK)
 140      error ("thread_db_get_info: cannot get thread info: %s",
 141            thread_db_err_str (err));
 142 @@ -365,7 +376,8 @@ thread_from_lwp (ptid_t ptid)
 143
 144    gdb_assert (is_lwp (ptid));
 145
 146 -  err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
 147 +  err = current_pointers->td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid),
 148 +                                              &th);
 149    if (err != TD_OK)
 150      error ("Cannot find user-level thread for LWP %ld: %s",
 151            GET_LWP (ptid), thread_db_err_str (err));
 152 @@ -420,85 +432,102 @@ verbose_dlsym (void *handle, const char
 153    return sym;
 154  }
 155
 156 -static int
 157 -thread_db_load (void)
 158 +static struct thread_db_pointers *
 159 +thread_db_load (const char *name)
 160  {
 161 +  struct thread_db_pointers *ptrs;
 162 +  Dl_info info;
 163    void *handle;
 164    td_err_e err;
 165
 166 -  handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW);
 167 +  ptrs = xcalloc (1, sizeof (struct thread_db_pointers));
 168 +
 169 +  handle = dlopen (name, RTLD_NOW);
 170    if (handle == NULL)
 171      {
 172 -      fprintf_filtered (gdb_stderr, "\n\ndlopen failed on '%s' - %s\n",
 173 -                       LIBTHREAD_DB_SO, dlerror ());
 174 -      fprintf_filtered (gdb_stderr,
 175 -                       "GDB will not be able to debug pthreads.\n\n");
 176 +      if (all_pointers == NULL)
 177 +       {
 178 +         fprintf_filtered (gdb_stderr, "\n\ndlopen failed on '%s' - %s\n",
 179 +                           name, dlerror ());
 180 +         fprintf_filtered (gdb_stderr,
 181 +                           "GDB will not be able to debug pthreads.\n\n");
 182 +       }
 183        return 0;
 184      }
 185
 186    /* Initialize pointers to the dynamic library functions we will use.
 187       Essential functions first.  */
 188
 189 -  td_init_p = verbose_dlsym (handle, "td_init");
 190 -  if (td_init_p == NULL)
 191 +  ptrs->td_init_p = verbose_dlsym (handle, "td_init");
 192 +  if (ptrs->td_init_p == NULL)
 193      return 0;
 194
 195 -  td_ta_new_p = verbose_dlsym (handle, "td_ta_new");
 196 -  if (td_ta_new_p == NULL)
 197 +  ptrs->td_ta_new_p = verbose_dlsym (handle, "td_ta_new");
 198 +  if (ptrs->td_ta_new_p == NULL)
 199      return 0;
 200
 201 -  td_ta_map_id2thr_p = verbose_dlsym (handle, "td_ta_map_id2thr");
 202 -  if (td_ta_map_id2thr_p == NULL)
 203 +  ptrs->td_ta_map_id2thr_p = verbose_dlsym (handle, "td_ta_map_id2thr");
 204 +  if (ptrs->td_ta_map_id2thr_p == NULL)
 205      return 0;
 206
 207 -  td_ta_map_lwp2thr_p = verbose_dlsym (handle, "td_ta_map_lwp2thr");
 208 -  if (td_ta_map_lwp2thr_p == NULL)
 209 +  ptrs->td_ta_map_lwp2thr_p = verbose_dlsym (handle, "td_ta_map_lwp2thr");
 210 +  if (ptrs->td_ta_map_lwp2thr_p == NULL)
 211      return 0;
 212
 213 -  td_ta_thr_iter_p = verbose_dlsym (handle, "td_ta_thr_iter");
 214 -  if (td_ta_thr_iter_p == NULL)
 215 +  ptrs->td_ta_thr_iter_p = verbose_dlsym (handle, "td_ta_thr_iter");
 216 +  if (ptrs->td_ta_thr_iter_p == NULL)
 217      return 0;
 218
 219 -  td_thr_validate_p = verbose_dlsym (handle, "td_thr_validate");
 220 -  if (td_thr_validate_p == NULL)
 221 +  ptrs->td_thr_validate_p = verbose_dlsym (handle, "td_thr_validate");
 222 +  if (ptrs->td_thr_validate_p == NULL)
 223      return 0;
 224
 225 -  td_thr_get_info_p = verbose_dlsym (handle, "td_thr_get_info");
 226 -  if (td_thr_get_info_p == NULL)
 227 +  ptrs->td_thr_get_info_p = verbose_dlsym (handle, "td_thr_get_info");
 228 +  if (ptrs->td_thr_get_info_p == NULL)
 229      return 0;
 230
 231 -  td_thr_getfpregs_p = verbose_dlsym (handle, "td_thr_getfpregs");
 232 -  if (td_thr_getfpregs_p == NULL)
 233 +  ptrs->td_thr_getfpregs_p = verbose_dlsym (handle, "td_thr_getfpregs");
 234 +  if (ptrs->td_thr_getfpregs_p == NULL)
 235      return 0;
 236
 237 -  td_thr_getgregs_p = verbose_dlsym (handle, "td_thr_getgregs");
 238 -  if (td_thr_getgregs_p == NULL)
 239 +  ptrs->td_thr_getgregs_p = verbose_dlsym (handle, "td_thr_getgregs");
 240 +  if (ptrs->td_thr_getgregs_p == NULL)
 241      return 0;
 242
 243 -  td_thr_setfpregs_p = verbose_dlsym (handle, "td_thr_setfpregs");
 244 -  if (td_thr_setfpregs_p == NULL)
 245 +  ptrs->td_thr_setfpregs_p = verbose_dlsym (handle, "td_thr_setfpregs");
 246 +  if (ptrs->td_thr_setfpregs_p == NULL)
 247      return 0;
 248
 249 -  td_thr_setgregs_p = verbose_dlsym (handle, "td_thr_setgregs");
 250 -  if (td_thr_setgregs_p == NULL)
 251 +  ptrs->td_thr_setgregs_p = verbose_dlsym (handle, "td_thr_setgregs");
 252 +  if (ptrs->td_thr_setgregs_p == NULL)
 253      return 0;
 254
 255    /* Initialize the library.  */
 256 -  err = td_init_p ();
 257 +  err = ptrs->td_init_p ();
 258    if (err != TD_OK)
 259      {
 260        warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err));
 261 +      xfree (ptrs);
 262        return 0;
 263      }
 264
 265    /* These are not essential.  */
 266 -  td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr");
 267 -  td_ta_set_event_p = dlsym (handle, "td_ta_set_event");
 268 -  td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg");
 269 -  td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable");
 270 -  td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr");
 271 +  ptrs->td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr");
 272 +  ptrs->td_ta_set_event_p = dlsym (handle, "td_ta_set_event");
 273 +  ptrs->td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg");
 274 +  ptrs->td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable");
 275 +  ptrs->td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr");
 276 +
 277 +  if (dladdr (ptrs->td_ta_new_p, &info) != 0)
 278 +    ptrs->filename = info.dli_fname;
 279 +
 280 +  /* Try dlinfo?  */
 281 +
 282 +  if (ptrs->filename == NULL)
 283 +    /* Paranoid - don't let a NULL path slip through.  */
 284 +    ptrs->filename = name;
 285
 286 -  return 1;
 287 +  return ptrs;
 288  }
 289
 290  static td_err_e
 291 @@ -508,7 +537,7 @@ enable_thread_event (td_thragent_t *thre
 292    td_err_e err;
 293
 294    /* Get the breakpoint address for thread EVENT.  */
 295 -  err = td_ta_event_addr_p (thread_agent, event, &notify);
 296 +  err = current_pointers->td_ta_event_addr_p (thread_agent, event, &notify);
 297    if (err != TD_OK)
 298      return err;
 299
 300 @@ -534,8 +563,10 @@ enable_thread_event_reporting (void)
 301
 302    /* We cannot use the thread event reporting facility if these
 303       functions aren't available.  */
 304 -  if (td_ta_event_addr_p == NULL || td_ta_set_event_p == NULL
 305 -      || td_ta_event_getmsg_p == NULL || td_thr_event_enable_p == NULL)
 306 +  if (current_pointers->td_ta_event_addr_p == NULL
 307 +      || current_pointers->td_ta_set_event_p == NULL
 308 +      || current_pointers->td_ta_event_getmsg_p == NULL
 309 +      || current_pointers->td_thr_event_enable_p == NULL)
 310      return;
 311
 312    /* Set the process wide mask saying which events we're interested in.  */
 313 @@ -552,7 +583,7 @@ enable_thread_event_reporting (void)
 314  #endif
 315      td_event_addset (&events, TD_DEATH);
 316
 317 -  err = td_ta_set_event_p (thread_agent, &events);
 318 +  err = current_pointers->td_ta_set_event_p (thread_agent, &events);
 319    if (err != TD_OK)
 320      {
 321        warning ("Unable to set global thread event mask: %s",
 322 @@ -592,7 +623,7 @@ disable_thread_event_reporting (void)
 323    /* Set the process wide mask saying we aren't interested in any
 324       events anymore.  */
 325    td_event_emptyset (&events);
 326 -  td_ta_set_event_p (thread_agent, &events);
 327 +  current_pointers->td_ta_set_event_p (thread_agent, &events);
 328
 329    /* Delete thread event breakpoints, if any.  */
 330    remove_thread_event_breakpoints ();
 331 @@ -635,7 +666,6 @@ check_thread_signals (void)
 332  static void
 333  check_for_thread_db (void)
 334  {
 335 -  td_err_e err;
 336    static int already_loaded;
 337
 338    /* First time through, report that libthread_db was successfuly
 339 @@ -644,19 +674,8 @@ check_for_thread_db (void)
 340
 341    if (!already_loaded)
 342      {
 343 -      Dl_info info;
 344 -      const char *library = NULL;
 345 -      if (dladdr ((*td_ta_new_p), &info) != 0)
 346 -       library = info.dli_fname;
 347 -
 348 -      /* Try dlinfo?  */
 349 -
 350 -      if (library == NULL)
 351 -       /* Paranoid - don't let a NULL path slip through.  */
 352 -       library = LIBTHREAD_DB_SO;
 353 -
 354        printf_unfiltered ("Using host libthread_db library \"%s\".\n",
 355 -                        library);
 356 +                        all_pointers->filename);
 357        already_loaded = 1;
 358      }
 359
 360 @@ -674,28 +693,34 @@ check_for_thread_db (void)
 361    proc_handle.pid = GET_PID (inferior_ptid);
 362
 363    /* Now attempt to open a connection to the thread library.  */
 364 -  err = td_ta_new_p (&proc_handle, &thread_agent);
 365 -  switch (err)
 366 +  for (current_pointers = all_pointers;
 367 +       current_pointers != NULL;
 368 +       current_pointers = current_pointers->next)
 369      {
 370 -    case TD_NOLIBTHREAD:
 371 -      /* No thread library was detected.  */
 372 -      break;
 373 -
 374 -    case TD_OK:
 375 -      printf_unfiltered ("[Thread debugging using libthread_db enabled]\n");
 376 +      td_err_e err;
 377 +      err = current_pointers->td_ta_new_p (&proc_handle, &thread_agent);
 378 +      switch (err)
 379 +       {
 380 +       case TD_NOLIBTHREAD:
 381 +         /* No thread library was detected.  */
 382 +         break;
 383
 384 -      /* The thread library was detected.  Activate the thread_db target.  */
 385 -      push_target (&thread_db_ops);
 386 -      using_thread_db = 1;
 387 +       case TD_OK:
 388 +         printf_unfiltered ("[Thread debugging using libthread_db enabled]\n");
 389
 390 -      enable_thread_event_reporting ();
 391 -      thread_db_find_new_threads ();
 392 -      break;
 393 +         /* The thread library was detected.  Activate the thread_db target.  */
 394 +         push_target (&thread_db_ops);
 395 +         using_thread_db = 1;
 396 +
 397 +         enable_thread_event_reporting ();
 398 +         thread_db_find_new_threads ();
 399 +         return;
 400
 401 -    default:
 402 -      warning ("Cannot initialize thread debugging library: %s",
 403 -              thread_db_err_str (err));
 404 -      break;
 405 +       default:
 406 +         warning ("Cannot initialize thread debugging library: %s",
 407 +                  thread_db_err_str (err));
 408 +         break;
 409 +       }
 410      }
 411  }
 412
 413 @@ -766,7 +791,7 @@ attach_thread (ptid_t ptid, const td_thr
 414  #endif
 415
 416    /* Enable thread event reporting for this thread.  */
 417 -  err = td_thr_event_enable_p (th_p, 1);
 418 +  err = current_pointers->td_thr_event_enable_p (th_p, 1);
 419    if (err != TD_OK)
 420      error ("Cannot enable thread event reporting for %s: %s",
 421            target_pid_to_str (ptid), thread_db_err_str (err));
 422 @@ -892,7 +917,7 @@ check_event (ptid_t ptid)
 423
 424    do
 425      {
 426 -      err = td_ta_event_getmsg_p (thread_agent, &msg);
 427 +      err = current_pointers->td_ta_event_getmsg_p (thread_agent, &msg);
 428        if (err != TD_OK)
 429         {
 430           if (err == TD_NOMSG)
 431 @@ -902,7 +927,7 @@ check_event (ptid_t ptid)
 432                  thread_db_err_str (err));
 433         }
 434
 435 -      err = td_thr_get_info_p (msg.th_p, &ti);
 436 +      err = current_pointers->td_thr_get_info_p (msg.th_p, &ti);
 437        if (err != TD_OK)
 438         error ("Cannot get thread info: %s", thread_db_err_str (err));
 439
 440 @@ -1015,12 +1040,14 @@ thread_db_fetch_registers (int regno)
 441    thread_info = find_thread_pid (inferior_ptid);
 442    thread_db_map_id2thr (thread_info, 1);
 443
 444 -  err = td_thr_getgregs_p (&thread_info->private->th, gregset);
 445 +  err = current_pointers->td_thr_getgregs_p (&thread_info->private->th,
 446 +                                            gregset);
 447    if (err != TD_OK)
 448      error ("Cannot fetch general-purpose registers for thread %ld: %s",
 449            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 450
 451 -  err = td_thr_getfpregs_p (&thread_info->private->th, &fpregset);
 452 +  err = current_pointers->td_thr_getfpregs_p (&thread_info->private->th,
 453 +                                             &fpregset);
 454    if (err != TD_OK)
 455      error ("Cannot get floating-point registers for thread %ld: %s",
 456            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 457 @@ -1062,11 +1089,13 @@ thread_db_store_registers (int regno)
 458    fill_gregset ((gdb_gregset_t *) gregset, -1);
 459    fill_fpregset (&fpregset, -1);
 460
 461 -  err = td_thr_setgregs_p (&thread_info->private->th, gregset);
 462 +  err = current_pointers->td_thr_setgregs_p (&thread_info->private->th,
 463 +                                            gregset);
 464    if (err != TD_OK)
 465      error ("Cannot store general-purpose registers for thread %ld: %s",
 466            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 467 -  err = td_thr_setfpregs_p (&thread_info->private->th, &fpregset);
 468 +  err = current_pointers->td_thr_setfpregs_p (&thread_info->private->th,
 469 +                                             &fpregset);
 470    if (err != TD_OK)
 471      error ("Cannot store floating-point registers  for thread %ld: %s",
 472            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 473 @@ -1136,15 +1165,14 @@ thread_db_thread_alive (ptid_t ptid)
 474        if (!thread_info->private->th_valid)
 475         return 0;
 476
 477 -      err = td_thr_validate_p (&thread_info->private->th);
 478 +      err = current_pointers->td_thr_validate_p (&thread_info->private->th);
 479        if (err != TD_OK)
 480         return 0;
 481
 482        if (!thread_info->private->ti_valid)
 483         {
 484 -         err =
 485 -           td_thr_get_info_p (&thread_info->private->th,
 486 -                              &thread_info->private->ti);
 487 +         err = current_pointers->td_thr_get_info_p
 488 +           (&thread_info->private->th, &thread_info->private->ti);
 489           if (err != TD_OK)
 490             return 0;
 491           thread_info->private->ti_valid = 1;
 492 @@ -1170,7 +1198,7 @@ find_new_threads_callback (const td_thrh
 493    td_err_e err;
 494    ptid_t ptid;
 495
 496 -  err = td_thr_get_info_p (th_p, &ti);
 497 +  err = current_pointers->td_thr_get_info_p (th_p, &ti);
 498    if (err != TD_OK)
 499      error ("find_new_threads_callback: cannot get thread info: %s",
 500            thread_db_err_str (err));
 501 @@ -1192,9 +1220,10 @@ thread_db_find_new_threads (void)
 502    td_err_e err;
 503
 504    /* Iterate over all user-space threads to discover new threads.  */
 505 -  err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback, NULL,
 506 -                         TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
 507 -                         TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 508 +  err = current_pointers->td_ta_thr_iter_p
 509 +    (thread_agent, find_new_threads_callback, NULL,
 510 +     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
 511 +     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 512    if (err != TD_OK)
 513      error ("Cannot find new threads: %s", thread_db_err_str (err));
 514  }
 515 @@ -1257,7 +1286,7 @@ thread_db_get_thread_local_address (ptid
 516        struct thread_info *thread_info;
 517
 518        /* glibc doesn't provide the needed interface.  */
 519 -      if (!td_thr_tls_get_addr_p)
 520 +      if (!current_pointers->td_thr_tls_get_addr_p)
 521         error ("Cannot find thread-local variables in this thread library.");
 522
 523        /* Get the address of the link map for this objfile.  */
 524 @@ -1279,8 +1308,8 @@ thread_db_get_thread_local_address (ptid
 525        thread_db_map_id2thr (thread_info, 1);
 526
 527        /* Finally, get the address of the variable.  */
 528 -      err = td_thr_tls_get_addr_p (&thread_info->private->th, (void *) lm,
 529 -                                  offset, &address);
 530 +      err = current_pointers->td_thr_tls_get_addr_p
 531 +       (&thread_info->private->th, (void *) lm, offset, &address);
 532
 533  #ifdef THREAD_DB_HAS_TD_NOTALLOC
 534        /* The memory hasn't been allocated, yet.  */
 535 @@ -1360,17 +1389,49 @@ init_thread_db_ops (void)
 536  void
 537  _initialize_thread_db (void)
 538  {
 539 +  struct thread_db_pointers *ptrs;
 540 +  const char *p;
 541 +
 542    /* Only initialize the module if we can load libthread_db.  */
 543 -  if (thread_db_load ())
 544 -    {
 545 -      init_thread_db_ops ();
 546 -      add_target (&thread_db_ops);
 547 +  ptrs = thread_db_load (LIBTHREAD_DB_SO);
 548 +  if (ptrs == NULL)
 549 +    return;
 550 +
 551 +  all_pointers = ptrs;
 552
 553 -      /* Add ourselves to objfile event chain.  */
 554 -      target_new_objfile_chain = deprecated_target_new_objfile_hook;
 555 -      deprecated_target_new_objfile_hook = thread_db_new_objfile;
 556 +  /* Some GNU/Linux systems have more than one binary-compatible copy
 557 +     of libthread_db.  If we can find a second one, load that too.
 558 +     The inferior may force the use of a different threading package
 559 +     than we expect.  Our guess for the location is somewhat hokey:
 560 +     strip out anything between /lib (or /lib64) and LIBTHREAD_DB_SO.
 561 +     If we loaded the NPTL libthread_db by default, this may find us
 562 +     the LinuxThreads copy.  */
 563 +  p = strrchr (ptrs->filename, '/');
 564 +  while (p != NULL && p > ptrs->filename)
 565 +    {
 566 +      const char *component;
 567
 568 -      /* Register ourselves for the new inferior observer.  */
 569 -      observer_attach_inferior_created (check_for_thread_db_observer);
 570 +      component = memrchr (ptrs->filename, '/', p - ptrs->filename);
 571 +      if (component != NULL && strncmp (component, "/lib", 4) == 0)
 572 +       {
 573 +         char *new_name = xmalloc (p - ptrs->filename + 2
 574 +                                   + strlen (LIBTHREAD_DB_SO));
 575 +         memcpy (new_name, ptrs->filename, p - ptrs->filename + 1);
 576 +         strcpy (new_name + (p - ptrs->filename) + 1, LIBTHREAD_DB_SO);
 577 +         ptrs->next = thread_db_load (new_name);
 578 +         xfree (new_name);
 579 +         break;
 580 +       }
 581 +      p = component;
 582      }
 583 +
 584 +  init_thread_db_ops ();
 585 +  add_target (&thread_db_ops);
 586 +
 587 +  /* Add ourselves to objfile event chain.  */
 588 +  target_new_objfile_chain = deprecated_target_new_objfile_hook;
 589 +  deprecated_target_new_objfile_hook = thread_db_new_objfile;
 590 +
 591 +  /* Register ourselves for the new inferior observer.  */
 592 +  observer_attach_inferior_created (check_for_thread_db_observer);
 593  }