convert to_get_thread_local_address to use target delegation
[platform/upstream/binutils.git] / gdb / linux-thread-db.c
1 /* libthread_db assisted debugging support, generic parts.
2
3    Copyright (C) 1999-2014 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21
22 #include "gdb_assert.h"
23 #include <dlfcn.h>
24 #include "gdb_proc_service.h"
25 #include "nat/gdb_thread_db.h"
26 #include "gdb_vecs.h"
27 #include "bfd.h"
28 #include "command.h"
29 #include "exceptions.h"
30 #include "gdbcmd.h"
31 #include "gdbthread.h"
32 #include "inferior.h"
33 #include "infrun.h"
34 #include "symfile.h"
35 #include "objfiles.h"
36 #include "target.h"
37 #include "regcache.h"
38 #include "solib.h"
39 #include "solib-svr4.h"
40 #include "gdbcore.h"
41 #include "observer.h"
42 #include "linux-nat.h"
43 #include "nat/linux-procfs.h"
44 #include "nat/linux-osdata.h"
45 #include "auto-load.h"
46 #include "cli/cli-utils.h"
47
48 #include <signal.h>
49 #include <ctype.h>
50
51 /* GNU/Linux libthread_db support.
52
53    libthread_db is a library, provided along with libpthread.so, which
54    exposes the internals of the thread library to a debugger.  It
55    allows GDB to find existing threads, new threads as they are
56    created, thread IDs (usually, the result of pthread_self), and
57    thread-local variables.
58
59    The libthread_db interface originates on Solaris, where it is
60    both more powerful and more complicated.  This implementation
61    only works for LinuxThreads and NPTL, the two glibc threading
62    libraries.  It assumes that each thread is permanently assigned
63    to a single light-weight process (LWP).
64
65    libthread_db-specific information is stored in the "private" field
66    of struct thread_info.  When the field is NULL we do not yet have
67    information about the new thread; this could be temporary (created,
68    but the thread library's data structures do not reflect it yet)
69    or permanent (created using clone instead of pthread_create).
70
71    Process IDs managed by linux-thread-db.c match those used by
72    linux-nat.c: a common PID for all processes, an LWP ID for each
73    thread, and no TID.  We save the TID in private.  Keeping it out
74    of the ptid_t prevents thread IDs changing when libpthread is
75    loaded or unloaded.  */
76
77 static char *libthread_db_search_path;
78
79 /* Set to non-zero if thread_db auto-loading is enabled
80    by the "set auto-load libthread-db" command.  */
81 static int auto_load_thread_db = 1;
82
83 /* "show" command for the auto_load_thread_db configuration variable.  */
84
85 static void
86 show_auto_load_thread_db (struct ui_file *file, int from_tty,
87                           struct cmd_list_element *c, const char *value)
88 {
89   fprintf_filtered (file, _("Auto-loading of inferior specific libthread_db "
90                             "is %s.\n"),
91                     value);
92 }
93
94 static void
95 set_libthread_db_search_path (char *ignored, int from_tty,
96                               struct cmd_list_element *c)
97 {
98   if (*libthread_db_search_path == '\0')
99     {
100       xfree (libthread_db_search_path);
101       libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
102     }
103 }
104
105 /* If non-zero, print details of libthread_db processing.  */
106
107 static unsigned int libthread_db_debug;
108
109 static void
110 show_libthread_db_debug (struct ui_file *file, int from_tty,
111                          struct cmd_list_element *c, const char *value)
112 {
113   fprintf_filtered (file, _("libthread-db debugging is %s.\n"), value);
114 }
115
116 /* If we're running on GNU/Linux, we must explicitly attach to any new
117    threads.  */
118
119 /* This module's target vector.  */
120 static struct target_ops thread_db_ops;
121
122 /* Non-zero if we have determined the signals used by the threads
123    library.  */
124 static int thread_signals;
125 static sigset_t thread_stop_set;
126 static sigset_t thread_print_set;
127
128 struct thread_db_info
129 {
130   struct thread_db_info *next;
131
132   /* Process id this object refers to.  */
133   int pid;
134
135   /* Handle from dlopen for libthread_db.so.  */
136   void *handle;
137
138   /* Absolute pathname from gdb_realpath to disk file used for dlopen-ing
139      HANDLE.  It may be NULL for system library.  */
140   char *filename;
141
142   /* Structure that identifies the child process for the
143      <proc_service.h> interface.  */
144   struct ps_prochandle proc_handle;
145
146   /* Connection to the libthread_db library.  */
147   td_thragent_t *thread_agent;
148
149   /* True if we need to apply the workaround for glibc/BZ5983.  When
150      we catch a PTRACE_O_TRACEFORK, and go query the child's thread
151      list, nptl_db returns the parent's threads in addition to the new
152      (single) child thread.  If this flag is set, we do extra work to
153      be able to ignore such stale entries.  */
154   int need_stale_parent_threads_check;
155
156   /* Location of the thread creation event breakpoint.  The code at
157      this location in the child process will be called by the pthread
158      library whenever a new thread is created.  By setting a special
159      breakpoint at this location, GDB can detect when a new thread is
160      created.  We obtain this location via the td_ta_event_addr
161      call.  */
162   CORE_ADDR td_create_bp_addr;
163
164   /* Location of the thread death event breakpoint.  */
165   CORE_ADDR td_death_bp_addr;
166
167   /* Pointers to the libthread_db functions.  */
168
169   td_err_e (*td_init_p) (void);
170
171   td_err_e (*td_ta_new_p) (struct ps_prochandle * ps,
172                                 td_thragent_t **ta);
173   td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
174                                   td_thrhandle_t *__th);
175   td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta,
176                                    lwpid_t lwpid, td_thrhandle_t *th);
177   td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
178                                 td_thr_iter_f *callback, void *cbdata_p,
179                                 td_thr_state_e state, int ti_pri,
180                                 sigset_t *ti_sigmask_p,
181                                 unsigned int ti_user_flags);
182   td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
183                                   td_event_e event, td_notify_t *ptr);
184   td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
185                                  td_thr_events_t *event);
186   td_err_e (*td_ta_clear_event_p) (const td_thragent_t *ta,
187                                    td_thr_events_t *event);
188   td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
189                                     td_event_msg_t *msg);
190
191   td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
192   td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
193                                  td_thrinfo_t *infop);
194   td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th,
195                                      int event);
196
197   td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
198                                      psaddr_t map_address,
199                                      size_t offset, psaddr_t *address);
200   td_err_e (*td_thr_tlsbase_p) (const td_thrhandle_t *th,
201                                 unsigned long int modid,
202                                 psaddr_t *base);
203 };
204
205 /* List of known processes using thread_db, and the required
206    bookkeeping.  */
207 struct thread_db_info *thread_db_list;
208
209 static void thread_db_find_new_threads_1 (ptid_t ptid);
210 static void thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new);
211
212 /* Add the current inferior to the list of processes using libpthread.
213    Return a pointer to the newly allocated object that was added to
214    THREAD_DB_LIST.  HANDLE is the handle returned by dlopen'ing
215    LIBTHREAD_DB_SO.  */
216
217 static struct thread_db_info *
218 add_thread_db_info (void *handle)
219 {
220   struct thread_db_info *info;
221
222   info = xcalloc (1, sizeof (*info));
223   info->pid = ptid_get_pid (inferior_ptid);
224   info->handle = handle;
225
226   /* The workaround works by reading from /proc/pid/status, so it is
227      disabled for core files.  */
228   if (target_has_execution)
229     info->need_stale_parent_threads_check = 1;
230
231   info->next = thread_db_list;
232   thread_db_list = info;
233
234   return info;
235 }
236
237 /* Return the thread_db_info object representing the bookkeeping
238    related to process PID, if any; NULL otherwise.  */
239
240 static struct thread_db_info *
241 get_thread_db_info (int pid)
242 {
243   struct thread_db_info *info;
244
245   for (info = thread_db_list; info; info = info->next)
246     if (pid == info->pid)
247       return info;
248
249   return NULL;
250 }
251
252 /* When PID has exited or has been detached, we no longer want to keep
253    track of it as using libpthread.  Call this function to discard
254    thread_db related info related to PID.  Note that this closes
255    LIBTHREAD_DB_SO's dlopen'ed handle.  */
256
257 static void
258 delete_thread_db_info (int pid)
259 {
260   struct thread_db_info *info, *info_prev;
261
262   info_prev = NULL;
263
264   for (info = thread_db_list; info; info_prev = info, info = info->next)
265     if (pid == info->pid)
266       break;
267
268   if (info == NULL)
269     return;
270
271   if (info->handle != NULL)
272     dlclose (info->handle);
273
274   xfree (info->filename);
275
276   if (info_prev)
277     info_prev->next = info->next;
278   else
279     thread_db_list = info->next;
280
281   xfree (info);
282 }
283
284 /* Prototypes for local functions.  */
285 static int attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
286                           const td_thrinfo_t *ti_p);
287 static void detach_thread (ptid_t ptid);
288 \f
289
290 /* Use "struct private_thread_info" to cache thread state.  This is
291    a substantial optimization.  */
292
293 struct private_thread_info
294 {
295   /* Flag set when we see a TD_DEATH event for this thread.  */
296   unsigned int dying:1;
297
298   /* Cached thread state.  */
299   td_thrhandle_t th;
300   thread_t tid;
301 };
302 \f
303
304 static char *
305 thread_db_err_str (td_err_e err)
306 {
307   static char buf[64];
308
309   switch (err)
310     {
311     case TD_OK:
312       return "generic 'call succeeded'";
313     case TD_ERR:
314       return "generic error";
315     case TD_NOTHR:
316       return "no thread to satisfy query";
317     case TD_NOSV:
318       return "no sync handle to satisfy query";
319     case TD_NOLWP:
320       return "no LWP to satisfy query";
321     case TD_BADPH:
322       return "invalid process handle";
323     case TD_BADTH:
324       return "invalid thread handle";
325     case TD_BADSH:
326       return "invalid synchronization handle";
327     case TD_BADTA:
328       return "invalid thread agent";
329     case TD_BADKEY:
330       return "invalid key";
331     case TD_NOMSG:
332       return "no event message for getmsg";
333     case TD_NOFPREGS:
334       return "FPU register set not available";
335     case TD_NOLIBTHREAD:
336       return "application not linked with libthread";
337     case TD_NOEVENT:
338       return "requested event is not supported";
339     case TD_NOCAPAB:
340       return "capability not available";
341     case TD_DBERR:
342       return "debugger service failed";
343     case TD_NOAPLIC:
344       return "operation not applicable to";
345     case TD_NOTSD:
346       return "no thread-specific data for this thread";
347     case TD_MALLOC:
348       return "malloc failed";
349     case TD_PARTIALREG:
350       return "only part of register set was written/read";
351     case TD_NOXREGS:
352       return "X register set not available for this thread";
353 #ifdef THREAD_DB_HAS_TD_NOTALLOC
354     case TD_NOTALLOC:
355       return "thread has not yet allocated TLS for given module";
356 #endif
357 #ifdef THREAD_DB_HAS_TD_VERSION
358     case TD_VERSION:
359       return "versions of libpthread and libthread_db do not match";
360 #endif
361 #ifdef THREAD_DB_HAS_TD_NOTLS
362     case TD_NOTLS:
363       return "there is no TLS segment in the given module";
364 #endif
365     default:
366       snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
367       return buf;
368     }
369 }
370 \f
371 /* Return 1 if any threads have been registered.  There may be none if
372    the threading library is not fully initialized yet.  */
373
374 static int
375 have_threads_callback (struct thread_info *thread, void *args)
376 {
377   int pid = * (int *) args;
378
379   if (ptid_get_pid (thread->ptid) != pid)
380     return 0;
381
382   return thread->private != NULL;
383 }
384
385 static int
386 have_threads (ptid_t ptid)
387 {
388   int pid = ptid_get_pid (ptid);
389
390   return iterate_over_threads (have_threads_callback, &pid) != NULL;
391 }
392
393 struct thread_get_info_inout
394 {
395   struct thread_info *thread_info;
396   struct thread_db_info *thread_db_info;
397 };
398
399 /* A callback function for td_ta_thr_iter, which we use to map all
400    threads to LWPs.
401
402    THP is a handle to the current thread; if INFOP is not NULL, the
403    struct thread_info associated with this thread is returned in
404    *INFOP.
405
406    If the thread is a zombie, TD_THR_ZOMBIE is returned.  Otherwise,
407    zero is returned to indicate success.  */
408
409 static int
410 thread_get_info_callback (const td_thrhandle_t *thp, void *argp)
411 {
412   td_thrinfo_t ti;
413   td_err_e err;
414   ptid_t thread_ptid;
415   struct thread_get_info_inout *inout;
416   struct thread_db_info *info;
417
418   inout = argp;
419   info = inout->thread_db_info;
420
421   err = info->td_thr_get_info_p (thp, &ti);
422   if (err != TD_OK)
423     error (_("thread_get_info_callback: cannot get thread info: %s"),
424            thread_db_err_str (err));
425
426   /* Fill the cache.  */
427   thread_ptid = ptid_build (info->pid, ti.ti_lid, 0);
428   inout->thread_info = find_thread_ptid (thread_ptid);
429
430   if (inout->thread_info == NULL)
431     {
432       /* New thread.  Attach to it now (why wait?).  */
433       if (!have_threads (thread_ptid))
434         thread_db_find_new_threads_1 (thread_ptid);
435       else
436         attach_thread (thread_ptid, thp, &ti);
437       inout->thread_info = find_thread_ptid (thread_ptid);
438       gdb_assert (inout->thread_info != NULL);
439     }
440
441   return 0;
442 }
443 \f
444 /* Fetch the user-level thread id of PTID.  */
445
446 static void
447 thread_from_lwp (ptid_t ptid)
448 {
449   td_thrhandle_t th;
450   td_err_e err;
451   struct thread_db_info *info;
452   struct thread_get_info_inout io = {0};
453
454   /* Just in case td_ta_map_lwp2thr doesn't initialize it completely.  */
455   th.th_unique = 0;
456
457   /* This ptid comes from linux-nat.c, which should always fill in the
458      LWP.  */
459   gdb_assert (ptid_get_lwp (ptid) != 0);
460
461   info = get_thread_db_info (ptid_get_pid (ptid));
462
463   /* Access an lwp we know is stopped.  */
464   info->proc_handle.ptid = ptid;
465   err = info->td_ta_map_lwp2thr_p (info->thread_agent, ptid_get_lwp (ptid),
466                                    &th);
467   if (err != TD_OK)
468     error (_("Cannot find user-level thread for LWP %ld: %s"),
469            ptid_get_lwp (ptid), thread_db_err_str (err));
470
471   /* Long-winded way of fetching the thread info.  */
472   io.thread_db_info = info;
473   io.thread_info = NULL;
474   thread_get_info_callback (&th, &io);
475 }
476 \f
477
478 /* Attach to lwp PTID, doing whatever else is required to have this
479    LWP under the debugger's control --- e.g., enabling event
480    reporting.  Returns true on success.  */
481 int
482 thread_db_attach_lwp (ptid_t ptid)
483 {
484   td_thrhandle_t th;
485   td_thrinfo_t ti;
486   td_err_e err;
487   struct thread_db_info *info;
488
489   info = get_thread_db_info (ptid_get_pid (ptid));
490
491   if (info == NULL)
492     return 0;
493
494   /* This ptid comes from linux-nat.c, which should always fill in the
495      LWP.  */
496   gdb_assert (ptid_get_lwp (ptid) != 0);
497
498   /* Access an lwp we know is stopped.  */
499   info->proc_handle.ptid = ptid;
500
501   /* If we have only looked at the first thread before libpthread was
502      initialized, we may not know its thread ID yet.  Make sure we do
503      before we add another thread to the list.  */
504   if (!have_threads (ptid))
505     thread_db_find_new_threads_1 (ptid);
506
507   err = info->td_ta_map_lwp2thr_p (info->thread_agent, ptid_get_lwp (ptid),
508                                    &th);
509   if (err != TD_OK)
510     /* Cannot find user-level thread.  */
511     return 0;
512
513   err = info->td_thr_get_info_p (&th, &ti);
514   if (err != TD_OK)
515     {
516       warning (_("Cannot get thread info: %s"), thread_db_err_str (err));
517       return 0;
518     }
519
520   attach_thread (ptid, &th, &ti);
521   return 1;
522 }
523
524 static void *
525 verbose_dlsym (void *handle, const char *name)
526 {
527   void *sym = dlsym (handle, name);
528   if (sym == NULL)
529     warning (_("Symbol \"%s\" not found in libthread_db: %s"),
530              name, dlerror ());
531   return sym;
532 }
533
534 static td_err_e
535 enable_thread_event (int event, CORE_ADDR *bp)
536 {
537   td_notify_t notify;
538   td_err_e err;
539   struct thread_db_info *info;
540
541   info = get_thread_db_info (ptid_get_pid (inferior_ptid));
542
543   /* Access an lwp we know is stopped.  */
544   info->proc_handle.ptid = inferior_ptid;
545
546   /* Get the breakpoint address for thread EVENT.  */
547   err = info->td_ta_event_addr_p (info->thread_agent, event, &notify);
548   if (err != TD_OK)
549     return err;
550
551   /* Set up the breakpoint.  */
552   gdb_assert (exec_bfd);
553   (*bp) = (gdbarch_convert_from_func_ptr_addr
554            (target_gdbarch (),
555             /* Do proper sign extension for the target.  */
556             (bfd_get_sign_extend_vma (exec_bfd) > 0
557              ? (CORE_ADDR) (intptr_t) notify.u.bptaddr
558              : (CORE_ADDR) (uintptr_t) notify.u.bptaddr),
559             &current_target));
560   create_thread_event_breakpoint (target_gdbarch (), *bp);
561
562   return TD_OK;
563 }
564
565 /* Verify inferior's '\0'-terminated symbol VER_SYMBOL starts with "%d.%d" and
566    return 1 if this version is lower (and not equal) to
567    VER_MAJOR_MIN.VER_MINOR_MIN.  Return 0 in all other cases.  */
568
569 static int
570 inferior_has_bug (const char *ver_symbol, int ver_major_min, int ver_minor_min)
571 {
572   struct bound_minimal_symbol version_msym;
573   CORE_ADDR version_addr;
574   char *version;
575   int err, got, retval = 0;
576
577   version_msym = lookup_minimal_symbol (ver_symbol, NULL, NULL);
578   if (version_msym.minsym == NULL)
579     return 0;
580
581   version_addr = BMSYMBOL_VALUE_ADDRESS (version_msym);
582   got = target_read_string (version_addr, &version, 32, &err);
583   if (err == 0 && memchr (version, 0, got) == &version[got -1])
584     {
585       int major, minor;
586
587       retval = (sscanf (version, "%d.%d", &major, &minor) == 2
588                 && (major < ver_major_min
589                     || (major == ver_major_min && minor < ver_minor_min)));
590     }
591   xfree (version);
592
593   return retval;
594 }
595
596 static void
597 enable_thread_event_reporting (void)
598 {
599   td_thr_events_t events;
600   td_err_e err;
601   struct thread_db_info *info;
602
603   info = get_thread_db_info (ptid_get_pid (inferior_ptid));
604
605   /* We cannot use the thread event reporting facility if these
606      functions aren't available.  */
607   if (info->td_ta_event_addr_p == NULL
608       || info->td_ta_set_event_p == NULL
609       || info->td_ta_event_getmsg_p == NULL
610       || info->td_thr_event_enable_p == NULL)
611     return;
612
613   /* Set the process wide mask saying which events we're interested in.  */
614   td_event_emptyset (&events);
615   td_event_addset (&events, TD_CREATE);
616
617   /* There is a bug fixed between linuxthreads 2.1.3 and 2.2 by
618        commit 2e4581e4fba917f1779cd0a010a45698586c190a
619        * manager.c (pthread_exited): Correctly report event as TD_REAP
620        instead of TD_DEATH.  Fix comments.
621      where event reporting facility is broken for TD_DEATH events,
622      so don't enable it if we have glibc but a lower version.  */
623   if (!inferior_has_bug ("__linuxthreads_version", 2, 2))
624     td_event_addset (&events, TD_DEATH);
625
626   err = info->td_ta_set_event_p (info->thread_agent, &events);
627   if (err != TD_OK)
628     {
629       warning (_("Unable to set global thread event mask: %s"),
630                thread_db_err_str (err));
631       return;
632     }
633
634   /* Delete previous thread event breakpoints, if any.  */
635   remove_thread_event_breakpoints ();
636   info->td_create_bp_addr = 0;
637   info->td_death_bp_addr = 0;
638
639   /* Set up the thread creation event.  */
640   err = enable_thread_event (TD_CREATE, &info->td_create_bp_addr);
641   if (err != TD_OK)
642     {
643       warning (_("Unable to get location for thread creation breakpoint: %s"),
644                thread_db_err_str (err));
645       return;
646     }
647
648   /* Set up the thread death event.  */
649   err = enable_thread_event (TD_DEATH, &info->td_death_bp_addr);
650   if (err != TD_OK)
651     {
652       warning (_("Unable to get location for thread death breakpoint: %s"),
653                thread_db_err_str (err));
654       return;
655     }
656 }
657
658 /* Similar as thread_db_find_new_threads_1, but try to silently ignore errors
659    if appropriate.
660
661    Return 1 if the caller should abort libthread_db initialization.  Return 0
662    otherwise.  */
663
664 static int
665 thread_db_find_new_threads_silently (ptid_t ptid)
666 {
667   volatile struct gdb_exception except;
668
669   TRY_CATCH (except, RETURN_MASK_ERROR)
670     {
671       thread_db_find_new_threads_2 (ptid, 1);
672     }
673
674   if (except.reason < 0)
675     {
676       if (libthread_db_debug)
677         exception_fprintf (gdb_stderr, except,
678                            "Warning: thread_db_find_new_threads_silently: ");
679
680       /* There is a bug fixed between nptl 2.6.1 and 2.7 by
681            commit 7d9d8bd18906fdd17364f372b160d7ab896ce909
682          where calls to td_thr_get_info fail with TD_ERR for statically linked
683          executables if td_thr_get_info is called before glibc has initialized
684          itself.
685          
686          If the nptl bug is NOT present in the inferior and still thread_db
687          reports an error return 1.  It means the inferior has corrupted thread
688          list and GDB should fall back only to LWPs.
689
690          If the nptl bug is present in the inferior return 0 to silently ignore
691          such errors, and let gdb enumerate threads again later.  In such case
692          GDB cannot properly display LWPs if the inferior thread list is
693          corrupted.  For core files it does not apply, no 'later enumeration'
694          is possible.  */
695
696       if (!target_has_execution || !inferior_has_bug ("nptl_version", 2, 7))
697         {
698           exception_fprintf (gdb_stderr, except,
699                              _("Warning: couldn't activate thread debugging "
700                                "using libthread_db: "));
701           return 1;
702         }
703     }
704   return 0;
705 }
706
707 /* Lookup a library in which given symbol resides.
708    Note: this is looking in GDB process, not in the inferior.
709    Returns library name, or NULL.  */
710
711 static const char *
712 dladdr_to_soname (const void *addr)
713 {
714   Dl_info info;
715
716   if (dladdr (addr, &info) != 0)
717     return info.dli_fname;
718   return NULL;
719 }
720
721 /* Attempt to initialize dlopen()ed libthread_db, described by INFO.
722    Return 1 on success.
723    Failure could happen if libthread_db does not have symbols we expect,
724    or when it refuses to work with the current inferior (e.g. due to
725    version mismatch between libthread_db and libpthread).  */
726
727 static int
728 try_thread_db_load_1 (struct thread_db_info *info)
729 {
730   td_err_e err;
731
732   /* Initialize pointers to the dynamic library functions we will use.
733      Essential functions first.  */
734
735   info->td_init_p = verbose_dlsym (info->handle, "td_init");
736   if (info->td_init_p == NULL)
737     return 0;
738
739   err = info->td_init_p ();
740   if (err != TD_OK)
741     {
742       warning (_("Cannot initialize libthread_db: %s"),
743                thread_db_err_str (err));
744       return 0;
745     }
746
747   info->td_ta_new_p = verbose_dlsym (info->handle, "td_ta_new");
748   if (info->td_ta_new_p == NULL)
749     return 0;
750
751   /* Initialize the structure that identifies the child process.  */
752   info->proc_handle.ptid = inferior_ptid;
753
754   /* Now attempt to open a connection to the thread library.  */
755   err = info->td_ta_new_p (&info->proc_handle, &info->thread_agent);
756   if (err != TD_OK)
757     {
758       if (libthread_db_debug)
759         printf_unfiltered (_("td_ta_new failed: %s\n"),
760                            thread_db_err_str (err));
761       else
762         switch (err)
763           {
764             case TD_NOLIBTHREAD:
765 #ifdef THREAD_DB_HAS_TD_VERSION
766             case TD_VERSION:
767 #endif
768               /* The errors above are not unexpected and silently ignored:
769                  they just mean we haven't found correct version of
770                  libthread_db yet.  */
771               break;
772             default:
773               warning (_("td_ta_new failed: %s"), thread_db_err_str (err));
774           }
775       return 0;
776     }
777
778   info->td_ta_map_id2thr_p = verbose_dlsym (info->handle, "td_ta_map_id2thr");
779   if (info->td_ta_map_id2thr_p == NULL)
780     return 0;
781
782   info->td_ta_map_lwp2thr_p = verbose_dlsym (info->handle,
783                                              "td_ta_map_lwp2thr");
784   if (info->td_ta_map_lwp2thr_p == NULL)
785     return 0;
786
787   info->td_ta_thr_iter_p = verbose_dlsym (info->handle, "td_ta_thr_iter");
788   if (info->td_ta_thr_iter_p == NULL)
789     return 0;
790
791   info->td_thr_validate_p = verbose_dlsym (info->handle, "td_thr_validate");
792   if (info->td_thr_validate_p == NULL)
793     return 0;
794
795   info->td_thr_get_info_p = verbose_dlsym (info->handle, "td_thr_get_info");
796   if (info->td_thr_get_info_p == NULL)
797     return 0;
798
799   /* These are not essential.  */
800   info->td_ta_event_addr_p = dlsym (info->handle, "td_ta_event_addr");
801   info->td_ta_set_event_p = dlsym (info->handle, "td_ta_set_event");
802   info->td_ta_clear_event_p = dlsym (info->handle, "td_ta_clear_event");
803   info->td_ta_event_getmsg_p = dlsym (info->handle, "td_ta_event_getmsg");
804   info->td_thr_event_enable_p = dlsym (info->handle, "td_thr_event_enable");
805   info->td_thr_tls_get_addr_p = dlsym (info->handle, "td_thr_tls_get_addr");
806   info->td_thr_tlsbase_p = dlsym (info->handle, "td_thr_tlsbase");
807
808   if (thread_db_find_new_threads_silently (inferior_ptid) != 0)
809     {
810       /* Even if libthread_db initializes, if the thread list is
811          corrupted, we'd not manage to list any threads.  Better reject this
812          thread_db, and fall back to at least listing LWPs.  */
813       return 0;
814     }
815
816   printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
817
818   if (libthread_db_debug || *libthread_db_search_path)
819     {
820       const char *library;
821
822       library = dladdr_to_soname (*info->td_ta_new_p);
823       if (library == NULL)
824         library = LIBTHREAD_DB_SO;
825
826       printf_unfiltered (_("Using host libthread_db library \"%s\".\n"),
827                          library);
828     }
829
830   /* The thread library was detected.  Activate the thread_db target
831      if this is the first process using it.  */
832   if (thread_db_list->next == NULL)
833     push_target (&thread_db_ops);
834
835   /* Enable event reporting, but not when debugging a core file.  */
836   if (target_has_execution)
837     enable_thread_event_reporting ();
838
839   return 1;
840 }
841
842 /* Attempt to use LIBRARY as libthread_db.  LIBRARY could be absolute,
843    relative, or just LIBTHREAD_DB.  */
844
845 static int
846 try_thread_db_load (const char *library, int check_auto_load_safe)
847 {
848   void *handle;
849   struct thread_db_info *info;
850
851   if (libthread_db_debug)
852     printf_unfiltered (_("Trying host libthread_db library: %s.\n"),
853                        library);
854
855   if (check_auto_load_safe)
856     {
857       if (access (library, R_OK) != 0)
858         {
859           /* Do not print warnings by file_is_auto_load_safe if the library does
860              not exist at this place.  */
861           if (libthread_db_debug)
862             printf_unfiltered (_("open failed: %s.\n"), safe_strerror (errno));
863           return 0;
864         }
865
866       if (!file_is_auto_load_safe (library, _("auto-load: Loading libthread-db "
867                                               "library \"%s\" from explicit "
868                                               "directory.\n"),
869                                    library))
870         return 0;
871     }
872
873   handle = dlopen (library, RTLD_NOW);
874   if (handle == NULL)
875     {
876       if (libthread_db_debug)
877         printf_unfiltered (_("dlopen failed: %s.\n"), dlerror ());
878       return 0;
879     }
880
881   if (libthread_db_debug && strchr (library, '/') == NULL)
882     {
883       void *td_init;
884
885       td_init = dlsym (handle, "td_init");
886       if (td_init != NULL)
887         {
888           const char *const libpath = dladdr_to_soname (td_init);
889
890           if (libpath != NULL)
891             printf_unfiltered (_("Host %s resolved to: %s.\n"),
892                                library, libpath);
893         }
894     }
895
896   info = add_thread_db_info (handle);
897
898   /* Do not save system library name, that one is always trusted.  */
899   if (strchr (library, '/') != NULL)
900     info->filename = gdb_realpath (library);
901
902   if (try_thread_db_load_1 (info))
903     return 1;
904
905   /* This library "refused" to work on current inferior.  */
906   delete_thread_db_info (ptid_get_pid (inferior_ptid));
907   return 0;
908 }
909
910 /* Subroutine of try_thread_db_load_from_pdir to simplify it.
911    Try loading libthread_db in directory(OBJ)/SUBDIR.
912    SUBDIR may be NULL.  It may also be something like "../lib64".
913    The result is true for success.  */
914
915 static int
916 try_thread_db_load_from_pdir_1 (struct objfile *obj, const char *subdir)
917 {
918   struct cleanup *cleanup;
919   char *path, *cp;
920   int result;
921   const char *obj_name = objfile_name (obj);
922
923   if (obj_name[0] != '/')
924     {
925       warning (_("Expected absolute pathname for libpthread in the"
926                  " inferior, but got %s."), obj_name);
927       return 0;
928     }
929
930   path = xmalloc (strlen (obj_name) + (subdir ? strlen (subdir) + 1 : 0)
931                   + 1 + strlen (LIBTHREAD_DB_SO) + 1);
932   cleanup = make_cleanup (xfree, path);
933
934   strcpy (path, obj_name);
935   cp = strrchr (path, '/');
936   /* This should at minimum hit the first character.  */
937   gdb_assert (cp != NULL);
938   cp[1] = '\0';
939   if (subdir != NULL)
940     {
941       strcat (cp, subdir);
942       strcat (cp, "/");
943     }
944   strcat (cp, LIBTHREAD_DB_SO);
945
946   result = try_thread_db_load (path, 1);
947
948   do_cleanups (cleanup);
949   return result;
950 }
951
952 /* Handle $pdir in libthread-db-search-path.
953    Look for libthread_db in directory(libpthread)/SUBDIR.
954    SUBDIR may be NULL.  It may also be something like "../lib64".
955    The result is true for success.  */
956
957 static int
958 try_thread_db_load_from_pdir (const char *subdir)
959 {
960   struct objfile *obj;
961
962   if (!auto_load_thread_db)
963     return 0;
964
965   ALL_OBJFILES (obj)
966     if (libpthread_name_p (objfile_name (obj)))
967       {
968         if (try_thread_db_load_from_pdir_1 (obj, subdir))
969           return 1;
970
971         /* We may have found the separate-debug-info version of
972            libpthread, and it may live in a directory without a matching
973            libthread_db.  */
974         if (obj->separate_debug_objfile_backlink != NULL)
975           return try_thread_db_load_from_pdir_1 (obj->separate_debug_objfile_backlink,
976                                                  subdir);
977
978         return 0;
979       }
980
981   return 0;
982 }
983
984 /* Handle $sdir in libthread-db-search-path.
985    Look for libthread_db in the system dirs, or wherever a plain
986    dlopen(file_without_path) will look.
987    The result is true for success.  */
988
989 static int
990 try_thread_db_load_from_sdir (void)
991 {
992   return try_thread_db_load (LIBTHREAD_DB_SO, 0);
993 }
994
995 /* Try to load libthread_db from directory DIR of length DIR_LEN.
996    The result is true for success.  */
997
998 static int
999 try_thread_db_load_from_dir (const char *dir, size_t dir_len)
1000 {
1001   struct cleanup *cleanup;
1002   char *path;
1003   int result;
1004
1005   if (!auto_load_thread_db)
1006     return 0;
1007
1008   path = xmalloc (dir_len + 1 + strlen (LIBTHREAD_DB_SO) + 1);
1009   cleanup = make_cleanup (xfree, path);
1010
1011   memcpy (path, dir, dir_len);
1012   path[dir_len] = '/';
1013   strcpy (path + dir_len + 1, LIBTHREAD_DB_SO);
1014
1015   result = try_thread_db_load (path, 1);
1016
1017   do_cleanups (cleanup);
1018   return result;
1019 }
1020
1021 /* Search libthread_db_search_path for libthread_db which "agrees"
1022    to work on current inferior.
1023    The result is true for success.  */
1024
1025 static int
1026 thread_db_load_search (void)
1027 {
1028   VEC (char_ptr) *dir_vec;
1029   struct cleanup *cleanups;
1030   char *this_dir;
1031   int i, rc = 0;
1032
1033   dir_vec = dirnames_to_char_ptr_vec (libthread_db_search_path);
1034   cleanups = make_cleanup_free_char_ptr_vec (dir_vec);
1035
1036   for (i = 0; VEC_iterate (char_ptr, dir_vec, i, this_dir); ++i)
1037     {
1038       const int pdir_len = sizeof ("$pdir") - 1;
1039       size_t this_dir_len;
1040
1041       this_dir_len = strlen (this_dir);
1042
1043       if (strncmp (this_dir, "$pdir", pdir_len) == 0
1044           && (this_dir[pdir_len] == '\0'
1045               || this_dir[pdir_len] == '/'))
1046         {
1047           char *subdir = NULL;
1048           struct cleanup *free_subdir_cleanup
1049             = make_cleanup (null_cleanup, NULL);
1050
1051           if (this_dir[pdir_len] == '/')
1052             {
1053               subdir = xmalloc (strlen (this_dir));
1054               make_cleanup (xfree, subdir);
1055               strcpy (subdir, this_dir + pdir_len + 1);
1056             }
1057           rc = try_thread_db_load_from_pdir (subdir);
1058           do_cleanups (free_subdir_cleanup);
1059           if (rc)
1060             break;
1061         }
1062       else if (strcmp (this_dir, "$sdir") == 0)
1063         {
1064           if (try_thread_db_load_from_sdir ())
1065             {
1066               rc = 1;
1067               break;
1068             }
1069         }
1070       else
1071         {
1072           if (try_thread_db_load_from_dir (this_dir, this_dir_len))
1073             {
1074               rc = 1;
1075               break;
1076             }
1077         }
1078     }
1079
1080   do_cleanups (cleanups);
1081   if (libthread_db_debug)
1082     printf_unfiltered (_("thread_db_load_search returning %d\n"), rc);
1083   return rc;
1084 }
1085
1086 /* Return non-zero if the inferior has a libpthread.  */
1087
1088 static int
1089 has_libpthread (void)
1090 {
1091   struct objfile *obj;
1092
1093   ALL_OBJFILES (obj)
1094     if (libpthread_name_p (objfile_name (obj)))
1095       return 1;
1096
1097   return 0;
1098 }
1099
1100 /* Attempt to load and initialize libthread_db.
1101    Return 1 on success.  */
1102
1103 static int
1104 thread_db_load (void)
1105 {
1106   struct thread_db_info *info;
1107
1108   info = get_thread_db_info (ptid_get_pid (inferior_ptid));
1109
1110   if (info != NULL)
1111     return 1;
1112
1113   /* Don't attempt to use thread_db on executables not running
1114      yet.  */
1115   if (!target_has_registers)
1116     return 0;
1117
1118   /* Don't attempt to use thread_db for remote targets.  */
1119   if (!(target_can_run (&current_target) || core_bfd))
1120     return 0;
1121
1122   if (thread_db_load_search ())
1123     return 1;
1124
1125   /* We couldn't find a libthread_db.
1126      If the inferior has a libpthread warn the user.  */
1127   if (has_libpthread ())
1128     {
1129       warning (_("Unable to find libthread_db matching inferior's thread"
1130                  " library, thread debugging will not be available."));
1131       return 0;
1132     }
1133
1134   /* Either this executable isn't using libpthread at all, or it is
1135      statically linked.  Since we can't easily distinguish these two cases,
1136      no warning is issued.  */
1137   return 0;
1138 }
1139
1140 static void
1141 disable_thread_event_reporting (struct thread_db_info *info)
1142 {
1143   if (info->td_ta_clear_event_p != NULL)
1144     {
1145       td_thr_events_t events;
1146
1147       /* Set the process wide mask saying we aren't interested in any
1148          events anymore.  */
1149       td_event_fillset (&events);
1150       info->td_ta_clear_event_p (info->thread_agent, &events);
1151     }
1152
1153   info->td_create_bp_addr = 0;
1154   info->td_death_bp_addr = 0;
1155 }
1156
1157 static void
1158 check_thread_signals (void)
1159 {
1160   if (!thread_signals)
1161     {
1162       sigset_t mask;
1163       int i;
1164
1165       lin_thread_get_thread_signals (&mask);
1166       sigemptyset (&thread_stop_set);
1167       sigemptyset (&thread_print_set);
1168
1169       for (i = 1; i < NSIG; i++)
1170         {
1171           if (sigismember (&mask, i))
1172             {
1173               if (signal_stop_update (gdb_signal_from_host (i), 0))
1174                 sigaddset (&thread_stop_set, i);
1175               if (signal_print_update (gdb_signal_from_host (i), 0))
1176                 sigaddset (&thread_print_set, i);
1177               thread_signals = 1;
1178             }
1179         }
1180     }
1181 }
1182
1183 /* Check whether thread_db is usable.  This function is called when
1184    an inferior is created (or otherwise acquired, e.g. attached to)
1185    and when new shared libraries are loaded into a running process.  */
1186
1187 void
1188 check_for_thread_db (void)
1189 {
1190   /* Do nothing if we couldn't load libthread_db.so.1.  */
1191   if (!thread_db_load ())
1192     return;
1193 }
1194
1195 /* This function is called via the new_objfile observer.  */
1196
1197 static void
1198 thread_db_new_objfile (struct objfile *objfile)
1199 {
1200   /* This observer must always be called with inferior_ptid set
1201      correctly.  */
1202
1203   if (objfile != NULL
1204       /* libpthread with separate debug info has its debug info file already
1205          loaded (and notified without successful thread_db initialization)
1206          the time observer_notify_new_objfile is called for the library itself.
1207          Static executables have their separate debug info loaded already
1208          before the inferior has started.  */
1209       && objfile->separate_debug_objfile_backlink == NULL
1210       /* Only check for thread_db if we loaded libpthread,
1211          or if this is the main symbol file.
1212          We need to check OBJF_MAINLINE to handle the case of debugging
1213          a statically linked executable AND the symbol file is specified AFTER
1214          the exec file is loaded (e.g., gdb -c core ; file foo).
1215          For dynamically linked executables, libpthread can be near the end
1216          of the list of shared libraries to load, and in an app of several
1217          thousand shared libraries, this can otherwise be painful.  */
1218       && ((objfile->flags & OBJF_MAINLINE) != 0
1219           || libpthread_name_p (objfile_name (objfile))))
1220     check_for_thread_db ();
1221 }
1222
1223 /* This function is called via the inferior_created observer.
1224    This handles the case of debugging statically linked executables.  */
1225
1226 static void
1227 thread_db_inferior_created (struct target_ops *target, int from_tty)
1228 {
1229   check_for_thread_db ();
1230 }
1231
1232 /* Attach to a new thread.  This function is called when we receive a
1233    TD_CREATE event or when we iterate over all threads and find one
1234    that wasn't already in our list.  Returns true on success.  */
1235
1236 static int
1237 attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
1238                const td_thrinfo_t *ti_p)
1239 {
1240   struct private_thread_info *private;
1241   struct thread_info *tp;
1242   td_err_e err;
1243   struct thread_db_info *info;
1244
1245   /* If we're being called after a TD_CREATE event, we may already
1246      know about this thread.  There are two ways this can happen.  We
1247      may have iterated over all threads between the thread creation
1248      and the TD_CREATE event, for instance when the user has issued
1249      the `info threads' command before the SIGTRAP for hitting the
1250      thread creation breakpoint was reported.  Alternatively, the
1251      thread may have exited and a new one been created with the same
1252      thread ID.  In the first case we don't need to do anything; in
1253      the second case we should discard information about the dead
1254      thread and attach to the new one.  */
1255   tp = find_thread_ptid (ptid);
1256   if (tp != NULL)
1257     {
1258       /* If tp->private is NULL, then GDB is already attached to this
1259          thread, but we do not know anything about it.  We can learn
1260          about it here.  This can only happen if we have some other
1261          way besides libthread_db to notice new threads (i.e.
1262          PTRACE_EVENT_CLONE); assume the same mechanism notices thread
1263          exit, so this can not be a stale thread recreated with the
1264          same ID.  */
1265       if (tp->private != NULL)
1266         {
1267           if (!tp->private->dying)
1268             return 0;
1269
1270           delete_thread (ptid);
1271           tp = NULL;
1272         }
1273     }
1274
1275   if (target_has_execution)
1276     check_thread_signals ();
1277
1278   /* Under GNU/Linux, we have to attach to each and every thread.  */
1279   if (target_has_execution
1280       && tp == NULL)
1281     {
1282       int res;
1283
1284       res = lin_lwp_attach_lwp (ptid_build (ptid_get_pid (ptid),
1285                                             ti_p->ti_lid, 0));
1286       if (res < 0)
1287         {
1288           /* Error, stop iterating.  */
1289           return 0;
1290         }
1291       else if (res > 0)
1292         {
1293           /* Pretend this thread doesn't exist yet, and keep
1294              iterating.  */
1295           return 1;
1296         }
1297
1298       /* Otherwise, we sucessfully attached to the thread.  */
1299     }
1300
1301   /* Construct the thread's private data.  */
1302   private = xmalloc (sizeof (struct private_thread_info));
1303   memset (private, 0, sizeof (struct private_thread_info));
1304
1305   /* A thread ID of zero may mean the thread library has not initialized
1306      yet.  But we shouldn't even get here if that's the case.  FIXME:
1307      if we change GDB to always have at least one thread in the thread
1308      list this will have to go somewhere else; maybe private == NULL
1309      until the thread_db target claims it.  */
1310   gdb_assert (ti_p->ti_tid != 0);
1311   private->th = *th_p;
1312   private->tid = ti_p->ti_tid;
1313   if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
1314     private->dying = 1;
1315
1316   /* Add the thread to GDB's thread list.  */
1317   if (tp == NULL)
1318     add_thread_with_info (ptid, private);
1319   else
1320     tp->private = private;
1321
1322   info = get_thread_db_info (ptid_get_pid (ptid));
1323
1324   /* Enable thread event reporting for this thread, except when
1325      debugging a core file.  */
1326   if (target_has_execution)
1327     {
1328       err = info->td_thr_event_enable_p (th_p, 1);
1329       if (err != TD_OK)
1330         error (_("Cannot enable thread event reporting for %s: %s"),
1331                target_pid_to_str (ptid), thread_db_err_str (err));
1332     }
1333
1334   return 1;
1335 }
1336
1337 static void
1338 detach_thread (ptid_t ptid)
1339 {
1340   struct thread_info *thread_info;
1341
1342   /* Don't delete the thread now, because it still reports as active
1343      until it has executed a few instructions after the event
1344      breakpoint - if we deleted it now, "info threads" would cause us
1345      to re-attach to it.  Just mark it as having had a TD_DEATH
1346      event.  This means that we won't delete it from our thread list
1347      until we notice that it's dead (via prune_threads), or until
1348      something re-uses its thread ID.  We'll report the thread exit
1349      when the underlying LWP dies.  */
1350   thread_info = find_thread_ptid (ptid);
1351   gdb_assert (thread_info != NULL && thread_info->private != NULL);
1352   thread_info->private->dying = 1;
1353 }
1354
1355 static void
1356 thread_db_detach (struct target_ops *ops, const char *args, int from_tty)
1357 {
1358   struct target_ops *target_beneath = find_target_beneath (ops);
1359   struct thread_db_info *info;
1360
1361   info = get_thread_db_info (ptid_get_pid (inferior_ptid));
1362
1363   if (info)
1364     {
1365       if (target_has_execution)
1366         {
1367           disable_thread_event_reporting (info);
1368
1369           /* Delete the old thread event breakpoints.  Note that
1370              unlike when mourning, we can remove them here because
1371              there's still a live inferior to poke at.  In any case,
1372              GDB will not try to insert anything in the inferior when
1373              removing a breakpoint.  */
1374           remove_thread_event_breakpoints ();
1375         }
1376
1377       delete_thread_db_info (ptid_get_pid (inferior_ptid));
1378     }
1379
1380   target_beneath->to_detach (target_beneath, args, from_tty);
1381
1382   /* NOTE: From this point on, inferior_ptid is null_ptid.  */
1383
1384   /* If there are no more processes using libpthread, detach the
1385      thread_db target ops.  */
1386   if (!thread_db_list)
1387     unpush_target (&thread_db_ops);
1388 }
1389
1390 /* Check if PID is currently stopped at the location of a thread event
1391    breakpoint location.  If it is, read the event message and act upon
1392    the event.  */
1393
1394 static void
1395 check_event (ptid_t ptid)
1396 {
1397   struct regcache *regcache = get_thread_regcache (ptid);
1398   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1399   td_event_msg_t msg;
1400   td_thrinfo_t ti;
1401   td_err_e err;
1402   CORE_ADDR stop_pc;
1403   int loop = 0;
1404   struct thread_db_info *info;
1405
1406   info = get_thread_db_info (ptid_get_pid (ptid));
1407
1408   /* Bail out early if we're not at a thread event breakpoint.  */
1409   stop_pc = regcache_read_pc (regcache)
1410             - target_decr_pc_after_break (gdbarch);
1411   if (stop_pc != info->td_create_bp_addr
1412       && stop_pc != info->td_death_bp_addr)
1413     return;
1414
1415   /* Access an lwp we know is stopped.  */
1416   info->proc_handle.ptid = ptid;
1417
1418   /* If we have only looked at the first thread before libpthread was
1419      initialized, we may not know its thread ID yet.  Make sure we do
1420      before we add another thread to the list.  */
1421   if (!have_threads (ptid))
1422     thread_db_find_new_threads_1 (ptid);
1423
1424   /* If we are at a create breakpoint, we do not know what new lwp
1425      was created and cannot specifically locate the event message for it.
1426      We have to call td_ta_event_getmsg() to get
1427      the latest message.  Since we have no way of correlating whether
1428      the event message we get back corresponds to our breakpoint, we must
1429      loop and read all event messages, processing them appropriately.
1430      This guarantees we will process the correct message before continuing
1431      from the breakpoint.
1432
1433      Currently, death events are not enabled.  If they are enabled,
1434      the death event can use the td_thr_event_getmsg() interface to
1435      get the message specifically for that lwp and avoid looping
1436      below.  */
1437
1438   loop = 1;
1439
1440   do
1441     {
1442       err = info->td_ta_event_getmsg_p (info->thread_agent, &msg);
1443       if (err != TD_OK)
1444         {
1445           if (err == TD_NOMSG)
1446             return;
1447
1448           error (_("Cannot get thread event message: %s"),
1449                  thread_db_err_str (err));
1450         }
1451
1452       err = info->td_thr_get_info_p (msg.th_p, &ti);
1453       if (err != TD_OK)
1454         error (_("Cannot get thread info: %s"), thread_db_err_str (err));
1455
1456       ptid = ptid_build (ptid_get_pid (ptid), ti.ti_lid, 0);
1457
1458       switch (msg.event)
1459         {
1460         case TD_CREATE:
1461           /* Call attach_thread whether or not we already know about a
1462              thread with this thread ID.  */
1463           attach_thread (ptid, msg.th_p, &ti);
1464
1465           break;
1466
1467         case TD_DEATH:
1468
1469           if (!in_thread_list (ptid))
1470             error (_("Spurious thread death event."));
1471
1472           detach_thread (ptid);
1473
1474           break;
1475
1476         default:
1477           error (_("Spurious thread event."));
1478         }
1479     }
1480   while (loop);
1481 }
1482
1483 static ptid_t
1484 thread_db_wait (struct target_ops *ops,
1485                 ptid_t ptid, struct target_waitstatus *ourstatus,
1486                 int options)
1487 {
1488   struct thread_db_info *info;
1489   struct target_ops *beneath = find_target_beneath (ops);
1490
1491   ptid = beneath->to_wait (beneath, ptid, ourstatus, options);
1492
1493   if (ourstatus->kind == TARGET_WAITKIND_IGNORE)
1494     return ptid;
1495
1496   if (ourstatus->kind == TARGET_WAITKIND_EXITED
1497       || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
1498     return ptid;
1499
1500   info = get_thread_db_info (ptid_get_pid (ptid));
1501
1502   /* If this process isn't using thread_db, we're done.  */
1503   if (info == NULL)
1504     return ptid;
1505
1506   if (ourstatus->kind == TARGET_WAITKIND_EXECD)
1507     {
1508       /* New image, it may or may not end up using thread_db.  Assume
1509          not unless we find otherwise.  */
1510       delete_thread_db_info (ptid_get_pid (ptid));
1511       if (!thread_db_list)
1512         unpush_target (&thread_db_ops);
1513
1514       /* Thread event breakpoints are deleted by
1515          update_breakpoints_after_exec.  */
1516
1517       return ptid;
1518     }
1519
1520   /* If we do not know about the main thread yet, this would be a good time to
1521      find it.  */
1522   if (ourstatus->kind == TARGET_WAITKIND_STOPPED && !have_threads (ptid))
1523     thread_db_find_new_threads_1 (ptid);
1524
1525   if (ourstatus->kind == TARGET_WAITKIND_STOPPED
1526       && ourstatus->value.sig == GDB_SIGNAL_TRAP)
1527     /* Check for a thread event.  */
1528     check_event (ptid);
1529
1530   if (have_threads (ptid))
1531     {
1532       /* Fill in the thread's user-level thread id.  */
1533       thread_from_lwp (ptid);
1534     }
1535
1536   return ptid;
1537 }
1538
1539 static void
1540 thread_db_mourn_inferior (struct target_ops *ops)
1541 {
1542   struct target_ops *target_beneath = find_target_beneath (ops);
1543
1544   delete_thread_db_info (ptid_get_pid (inferior_ptid));
1545
1546   target_beneath->to_mourn_inferior (target_beneath);
1547
1548   /* Delete the old thread event breakpoints.  Do this after mourning
1549      the inferior, so that we don't try to uninsert them.  */
1550   remove_thread_event_breakpoints ();
1551
1552   /* Detach thread_db target ops.  */
1553   if (!thread_db_list)
1554     unpush_target (ops);
1555 }
1556
1557 struct callback_data
1558 {
1559   struct thread_db_info *info;
1560   int new_threads;
1561 };
1562
1563 static int
1564 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
1565 {
1566   td_thrinfo_t ti;
1567   td_err_e err;
1568   ptid_t ptid;
1569   struct thread_info *tp;
1570   struct callback_data *cb_data = data;
1571   struct thread_db_info *info = cb_data->info;
1572
1573   err = info->td_thr_get_info_p (th_p, &ti);
1574   if (err != TD_OK)
1575     error (_("find_new_threads_callback: cannot get thread info: %s"),
1576            thread_db_err_str (err));
1577
1578   if (ti.ti_tid == 0)
1579     {
1580       /* A thread ID of zero means that this is the main thread, but
1581          glibc has not yet initialized thread-local storage and the
1582          pthread library.  We do not know what the thread's TID will
1583          be yet.  Just enable event reporting and otherwise ignore
1584          it.  */
1585
1586       /* In that case, we're not stopped in a fork syscall and don't
1587          need this glibc bug workaround.  */
1588       info->need_stale_parent_threads_check = 0;
1589
1590       if (target_has_execution)
1591         {
1592           err = info->td_thr_event_enable_p (th_p, 1);
1593           if (err != TD_OK)
1594             error (_("Cannot enable thread event reporting for LWP %d: %s"),
1595                    (int) ti.ti_lid, thread_db_err_str (err));
1596         }
1597
1598       return 0;
1599     }
1600
1601   /* Ignore stale parent threads, caused by glibc/BZ5983.  This is a
1602      bit expensive, as it needs to open /proc/pid/status, so try to
1603      avoid doing the work if we know we don't have to.  */
1604   if (info->need_stale_parent_threads_check)
1605     {
1606       int tgid = linux_proc_get_tgid (ti.ti_lid);
1607
1608       if (tgid != -1 && tgid != info->pid)
1609         return 0;
1610     }
1611
1612   ptid = ptid_build (info->pid, ti.ti_lid, 0);
1613   tp = find_thread_ptid (ptid);
1614   if (tp == NULL || tp->private == NULL)
1615     {
1616       if (attach_thread (ptid, th_p, &ti))
1617         cb_data->new_threads += 1;
1618       else
1619         /* Problem attaching this thread; perhaps it exited before we
1620            could attach it?
1621            This could mean that the thread list inside glibc itself is in
1622            inconsistent state, and libthread_db could go on looping forever
1623            (observed with glibc-2.3.6).  To prevent that, terminate
1624            iteration: thread_db_find_new_threads_2 will retry.  */
1625         return 1;
1626     }
1627
1628   return 0;
1629 }
1630
1631 /* Helper for thread_db_find_new_threads_2.
1632    Returns number of new threads found.  */
1633
1634 static int
1635 find_new_threads_once (struct thread_db_info *info, int iteration,
1636                        td_err_e *errp)
1637 {
1638   volatile struct gdb_exception except;
1639   struct callback_data data;
1640   td_err_e err = TD_ERR;
1641
1642   data.info = info;
1643   data.new_threads = 0;
1644
1645   TRY_CATCH (except, RETURN_MASK_ERROR)
1646     {
1647       /* Iterate over all user-space threads to discover new threads.  */
1648       err = info->td_ta_thr_iter_p (info->thread_agent,
1649                                     find_new_threads_callback,
1650                                     &data,
1651                                     TD_THR_ANY_STATE,
1652                                     TD_THR_LOWEST_PRIORITY,
1653                                     TD_SIGNO_MASK,
1654                                     TD_THR_ANY_USER_FLAGS);
1655     }
1656
1657   if (libthread_db_debug)
1658     {
1659       if (except.reason < 0)
1660         exception_fprintf (gdb_stderr, except,
1661                            "Warning: find_new_threads_once: ");
1662
1663       printf_filtered (_("Found %d new threads in iteration %d.\n"),
1664                        data.new_threads, iteration);
1665     }
1666
1667   if (errp != NULL)
1668     *errp = err;
1669
1670   return data.new_threads;
1671 }
1672
1673 /* Search for new threads, accessing memory through stopped thread
1674    PTID.  If UNTIL_NO_NEW is true, repeat searching until several
1675    searches in a row do not discover any new threads.  */
1676
1677 static void
1678 thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new)
1679 {
1680   td_err_e err = TD_OK;
1681   struct thread_db_info *info;
1682   int i, loop;
1683
1684   info = get_thread_db_info (ptid_get_pid (ptid));
1685
1686   /* Access an lwp we know is stopped.  */
1687   info->proc_handle.ptid = ptid;
1688
1689   if (until_no_new)
1690     {
1691       /* Require 4 successive iterations which do not find any new threads.
1692          The 4 is a heuristic: there is an inherent race here, and I have
1693          seen that 2 iterations in a row are not always sufficient to
1694          "capture" all threads.  */
1695       for (i = 0, loop = 0; loop < 4 && err == TD_OK; ++i, ++loop)
1696         if (find_new_threads_once (info, i, &err) != 0)
1697           {
1698             /* Found some new threads.  Restart the loop from beginning.  */
1699             loop = -1;
1700           }
1701     }
1702   else
1703     find_new_threads_once (info, 0, &err);
1704
1705   if (err != TD_OK)
1706     error (_("Cannot find new threads: %s"), thread_db_err_str (err));
1707 }
1708
1709 static void
1710 thread_db_find_new_threads_1 (ptid_t ptid)
1711 {
1712   thread_db_find_new_threads_2 (ptid, 0);
1713 }
1714
1715 static int
1716 update_thread_core (struct lwp_info *info, void *closure)
1717 {
1718   info->core = linux_common_core_of_thread (info->ptid);
1719   return 0;
1720 }
1721
1722 static void
1723 thread_db_find_new_threads (struct target_ops *ops)
1724 {
1725   struct thread_db_info *info;
1726   struct inferior *inf;
1727
1728   ALL_INFERIORS (inf)
1729     {
1730       struct thread_info *thread;
1731
1732       if (inf->pid == 0)
1733         continue;
1734
1735       info = get_thread_db_info (inf->pid);
1736       if (info == NULL)
1737         continue;
1738
1739       thread = any_live_thread_of_process (inf->pid);
1740       if (thread == NULL || thread->executing)
1741         continue;
1742
1743       thread_db_find_new_threads_1 (thread->ptid);
1744     }
1745
1746   if (target_has_execution)
1747     iterate_over_lwps (minus_one_ptid /* iterate over all */,
1748                        update_thread_core, NULL);
1749 }
1750
1751 static char *
1752 thread_db_pid_to_str (struct target_ops *ops, ptid_t ptid)
1753 {
1754   struct thread_info *thread_info = find_thread_ptid (ptid);
1755   struct target_ops *beneath;
1756
1757   if (thread_info != NULL && thread_info->private != NULL)
1758     {
1759       static char buf[64];
1760       thread_t tid;
1761
1762       tid = thread_info->private->tid;
1763       snprintf (buf, sizeof (buf), "Thread 0x%lx (LWP %ld)",
1764                 tid, ptid_get_lwp (ptid));
1765
1766       return buf;
1767     }
1768
1769   beneath = find_target_beneath (ops);
1770   if (beneath->to_pid_to_str (beneath, ptid))
1771     return beneath->to_pid_to_str (beneath, ptid);
1772
1773   return normal_pid_to_str (ptid);
1774 }
1775
1776 /* Return a string describing the state of the thread specified by
1777    INFO.  */
1778
1779 static char *
1780 thread_db_extra_thread_info (struct target_ops *self,
1781                              struct thread_info *info)
1782 {
1783   if (info->private == NULL)
1784     return NULL;
1785
1786   if (info->private->dying)
1787     return "Exiting";
1788
1789   return NULL;
1790 }
1791
1792 /* Get the address of the thread local variable in load module LM which
1793    is stored at OFFSET within the thread local storage for thread PTID.  */
1794
1795 static CORE_ADDR
1796 thread_db_get_thread_local_address (struct target_ops *ops,
1797                                     ptid_t ptid,
1798                                     CORE_ADDR lm,
1799                                     CORE_ADDR offset)
1800 {
1801   struct thread_info *thread_info;
1802   struct target_ops *beneath;
1803
1804   /* If we have not discovered any threads yet, check now.  */
1805   if (!have_threads (ptid))
1806     thread_db_find_new_threads_1 (ptid);
1807
1808   /* Find the matching thread.  */
1809   thread_info = find_thread_ptid (ptid);
1810
1811   if (thread_info != NULL && thread_info->private != NULL)
1812     {
1813       td_err_e err;
1814       psaddr_t address;
1815       struct thread_db_info *info;
1816
1817       info = get_thread_db_info (ptid_get_pid (ptid));
1818
1819       /* Finally, get the address of the variable.  */
1820       if (lm != 0)
1821         {
1822           /* glibc doesn't provide the needed interface.  */
1823           if (!info->td_thr_tls_get_addr_p)
1824             throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR,
1825                          _("No TLS library support"));
1826
1827           /* Note the cast through uintptr_t: this interface only works if
1828              a target address fits in a psaddr_t, which is a host pointer.
1829              So a 32-bit debugger can not access 64-bit TLS through this.  */
1830           err = info->td_thr_tls_get_addr_p (&thread_info->private->th,
1831                                              (psaddr_t)(uintptr_t) lm,
1832                                              offset, &address);
1833         }
1834       else
1835         {
1836           /* If glibc doesn't provide the needed interface throw an error
1837              that LM is zero - normally cases it should not be.  */
1838           if (!info->td_thr_tlsbase_p)
1839             throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
1840                          _("TLS load module not found"));
1841
1842           /* This code path handles the case of -static -pthread executables:
1843              https://sourceware.org/ml/libc-help/2014-03/msg00024.html
1844              For older GNU libc r_debug.r_map is NULL.  For GNU libc after
1845              PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL.
1846              The constant number 1 depends on GNU __libc_setup_tls
1847              initialization of l_tls_modid to 1.  */
1848           err = info->td_thr_tlsbase_p (&thread_info->private->th,
1849                                         1, &address);
1850           address = (char *) address + offset;
1851         }
1852
1853 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1854       /* The memory hasn't been allocated, yet.  */
1855       if (err == TD_NOTALLOC)
1856           /* Now, if libthread_db provided the initialization image's
1857              address, we *could* try to build a non-lvalue value from
1858              the initialization image.  */
1859         throw_error (TLS_NOT_ALLOCATED_YET_ERROR,
1860                      _("TLS not allocated yet"));
1861 #endif
1862
1863       /* Something else went wrong.  */
1864       if (err != TD_OK)
1865         throw_error (TLS_GENERIC_ERROR,
1866                      (("%s")), thread_db_err_str (err));
1867
1868       /* Cast assuming host == target.  Joy.  */
1869       /* Do proper sign extension for the target.  */
1870       gdb_assert (exec_bfd);
1871       return (bfd_get_sign_extend_vma (exec_bfd) > 0
1872               ? (CORE_ADDR) (intptr_t) address
1873               : (CORE_ADDR) (uintptr_t) address);
1874     }
1875
1876   beneath = find_target_beneath (ops);
1877   return beneath->to_get_thread_local_address (beneath, ptid, lm, offset);
1878 }
1879
1880 /* Callback routine used to find a thread based on the TID part of
1881    its PTID.  */
1882
1883 static int
1884 thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
1885 {
1886   long *tid = (long *) data;
1887
1888   if (thread->private->tid == *tid)
1889     return 1;
1890
1891   return 0;
1892 }
1893
1894 /* Implement the to_get_ada_task_ptid target method for this target.  */
1895
1896 static ptid_t
1897 thread_db_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
1898 {
1899   struct thread_info *thread_info;
1900
1901   thread_db_find_new_threads_1 (inferior_ptid);
1902   thread_info = iterate_over_threads (thread_db_find_thread_from_tid, &thread);
1903
1904   gdb_assert (thread_info != NULL);
1905
1906   return (thread_info->ptid);
1907 }
1908
1909 static void
1910 thread_db_resume (struct target_ops *ops,
1911                   ptid_t ptid, int step, enum gdb_signal signo)
1912 {
1913   struct target_ops *beneath = find_target_beneath (ops);
1914   struct thread_db_info *info;
1915
1916   if (ptid_equal (ptid, minus_one_ptid))
1917     info = get_thread_db_info (ptid_get_pid (inferior_ptid));
1918   else
1919     info = get_thread_db_info (ptid_get_pid (ptid));
1920
1921   /* This workaround is only needed for child fork lwps stopped in a
1922      PTRACE_O_TRACEFORK event.  When the inferior is resumed, the
1923      workaround can be disabled.  */
1924   if (info)
1925     info->need_stale_parent_threads_check = 0;
1926
1927   beneath->to_resume (beneath, ptid, step, signo);
1928 }
1929
1930 /* qsort helper function for info_auto_load_libthread_db, sort the
1931    thread_db_info pointers primarily by their FILENAME and secondarily by their
1932    PID, both in ascending order.  */
1933
1934 static int
1935 info_auto_load_libthread_db_compare (const void *ap, const void *bp)
1936 {
1937   struct thread_db_info *a = *(struct thread_db_info **) ap;
1938   struct thread_db_info *b = *(struct thread_db_info **) bp;
1939   int retval;
1940
1941   retval = strcmp (a->filename, b->filename);
1942   if (retval)
1943     return retval;
1944
1945   return (a->pid > b->pid) - (a->pid - b->pid);
1946 }
1947
1948 /* Implement 'info auto-load libthread-db'.  */
1949
1950 static void
1951 info_auto_load_libthread_db (char *args, int from_tty)
1952 {
1953   struct ui_out *uiout = current_uiout;
1954   const char *cs = args ? args : "";
1955   struct thread_db_info *info, **array;
1956   unsigned info_count, unique_filenames;
1957   size_t max_filename_len, max_pids_len, pids_len;
1958   struct cleanup *back_to;
1959   char *pids;
1960   int i;
1961
1962   cs = skip_spaces_const (cs);
1963   if (*cs)
1964     error (_("'info auto-load libthread-db' does not accept any parameters"));
1965
1966   info_count = 0;
1967   for (info = thread_db_list; info; info = info->next)
1968     if (info->filename != NULL)
1969       info_count++;
1970
1971   array = xmalloc (sizeof (*array) * info_count);
1972   back_to = make_cleanup (xfree, array);
1973
1974   info_count = 0;
1975   for (info = thread_db_list; info; info = info->next)
1976     if (info->filename != NULL)
1977       array[info_count++] = info;
1978
1979   /* Sort ARRAY by filenames and PIDs.  */
1980
1981   qsort (array, info_count, sizeof (*array),
1982          info_auto_load_libthread_db_compare);
1983
1984   /* Calculate the number of unique filenames (rows) and the maximum string
1985      length of PIDs list for the unique filenames (columns).  */
1986
1987   unique_filenames = 0;
1988   max_filename_len = 0;
1989   max_pids_len = 0;
1990   pids_len = 0;
1991   for (i = 0; i < info_count; i++)
1992     {
1993       int pid = array[i]->pid;
1994       size_t this_pid_len;
1995
1996       for (this_pid_len = 0; pid != 0; pid /= 10)
1997         this_pid_len++;
1998
1999       if (i == 0 || strcmp (array[i - 1]->filename, array[i]->filename) != 0)
2000         {
2001           unique_filenames++;
2002           max_filename_len = max (max_filename_len,
2003                                   strlen (array[i]->filename));
2004
2005           if (i > 0)
2006             {
2007               pids_len -= strlen (", ");
2008               max_pids_len = max (max_pids_len, pids_len);
2009             }
2010           pids_len = 0;
2011         }
2012       pids_len += this_pid_len + strlen (", ");
2013     }
2014   if (i)
2015     {
2016       pids_len -= strlen (", ");
2017       max_pids_len = max (max_pids_len, pids_len);
2018     }
2019
2020   /* Table header shifted right by preceding "libthread-db:  " would not match
2021      its columns.  */
2022   if (info_count > 0 && args == auto_load_info_scripts_pattern_nl)
2023     ui_out_text (uiout, "\n");
2024
2025   make_cleanup_ui_out_table_begin_end (uiout, 2, unique_filenames,
2026                                        "LinuxThreadDbTable");
2027
2028   ui_out_table_header (uiout, max_filename_len, ui_left, "filename",
2029                        "Filename");
2030   ui_out_table_header (uiout, pids_len, ui_left, "PIDs", "Pids");
2031   ui_out_table_body (uiout);
2032
2033   pids = xmalloc (max_pids_len + 1);
2034   make_cleanup (xfree, pids);
2035
2036   /* Note I is incremented inside the cycle, not at its end.  */
2037   for (i = 0; i < info_count;)
2038     {
2039       struct cleanup *chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2040       char *pids_end;
2041
2042       info = array[i];
2043       ui_out_field_string (uiout, "filename", info->filename);
2044       pids_end = pids;
2045
2046       while (i < info_count && strcmp (info->filename, array[i]->filename) == 0)
2047         {
2048           if (pids_end != pids)
2049             {
2050               *pids_end++ = ',';
2051               *pids_end++ = ' ';
2052             }
2053           pids_end += xsnprintf (pids_end, &pids[max_pids_len + 1] - pids_end,
2054                                  "%u", array[i]->pid);
2055           gdb_assert (pids_end < &pids[max_pids_len + 1]);
2056
2057           i++;
2058         }
2059       *pids_end = '\0';
2060
2061       ui_out_field_string (uiout, "pids", pids);
2062
2063       ui_out_text (uiout, "\n");
2064       do_cleanups (chain);
2065     }
2066
2067   do_cleanups (back_to);
2068
2069   if (info_count == 0)
2070     ui_out_message (uiout, 0, _("No auto-loaded libthread-db.\n"));
2071 }
2072
2073 static void
2074 init_thread_db_ops (void)
2075 {
2076   thread_db_ops.to_shortname = "multi-thread";
2077   thread_db_ops.to_longname = "multi-threaded child process.";
2078   thread_db_ops.to_doc = "Threads and pthreads support.";
2079   thread_db_ops.to_detach = thread_db_detach;
2080   thread_db_ops.to_wait = thread_db_wait;
2081   thread_db_ops.to_resume = thread_db_resume;
2082   thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
2083   thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
2084   thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
2085   thread_db_ops.to_stratum = thread_stratum;
2086   thread_db_ops.to_has_thread_control = tc_schedlock;
2087   thread_db_ops.to_get_thread_local_address
2088     = thread_db_get_thread_local_address;
2089   thread_db_ops.to_extra_thread_info = thread_db_extra_thread_info;
2090   thread_db_ops.to_get_ada_task_ptid = thread_db_get_ada_task_ptid;
2091   thread_db_ops.to_magic = OPS_MAGIC;
2092
2093   complete_target_initialization (&thread_db_ops);
2094 }
2095
2096 /* Provide a prototype to silence -Wmissing-prototypes.  */
2097 extern initialize_file_ftype _initialize_thread_db;
2098
2099 void
2100 _initialize_thread_db (void)
2101 {
2102   init_thread_db_ops ();
2103
2104   /* Defer loading of libthread_db.so until inferior is running.
2105      This allows gdb to load correct libthread_db for a given
2106      executable -- there could be mutiple versions of glibc,
2107      compiled with LinuxThreads or NPTL, and until there is
2108      a running inferior, we can't tell which libthread_db is
2109      the correct one to load.  */
2110
2111   libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
2112
2113   add_setshow_optional_filename_cmd ("libthread-db-search-path",
2114                                      class_support,
2115                                      &libthread_db_search_path, _("\
2116 Set search path for libthread_db."), _("\
2117 Show the current search path or libthread_db."), _("\
2118 This path is used to search for libthread_db to be loaded into \
2119 gdb itself.\n\
2120 Its value is a colon (':') separate list of directories to search.\n\
2121 Setting the search path to an empty list resets it to its default value."),
2122                             set_libthread_db_search_path,
2123                             NULL,
2124                             &setlist, &showlist);
2125
2126   add_setshow_zuinteger_cmd ("libthread-db", class_maintenance,
2127                              &libthread_db_debug, _("\
2128 Set libthread-db debugging."), _("\
2129 Show libthread-db debugging."), _("\
2130 When non-zero, libthread-db debugging is enabled."),
2131                              NULL,
2132                              show_libthread_db_debug,
2133                              &setdebuglist, &showdebuglist);
2134
2135   add_setshow_boolean_cmd ("libthread-db", class_support,
2136                            &auto_load_thread_db, _("\
2137 Enable or disable auto-loading of inferior specific libthread_db."), _("\
2138 Show whether auto-loading inferior specific libthread_db is enabled."), _("\
2139 If enabled, libthread_db will be searched in 'set libthread-db-search-path'\n\
2140 locations to load libthread_db compatible with the inferior.\n\
2141 Standard system libthread_db still gets loaded even with this option off.\n\
2142 This options has security implications for untrusted inferiors."),
2143                            NULL, show_auto_load_thread_db,
2144                            auto_load_set_cmdlist_get (),
2145                            auto_load_show_cmdlist_get ());
2146
2147   add_cmd ("libthread-db", class_info, info_auto_load_libthread_db,
2148            _("Print the list of loaded inferior specific libthread_db.\n\
2149 Usage: info auto-load libthread-db"),
2150            auto_load_info_cmdlist_get ());
2151
2152   /* Add ourselves to objfile event chain.  */
2153   observer_attach_new_objfile (thread_db_new_objfile);
2154
2155   /* Add ourselves to inferior_created event chain.
2156      This is needed to handle debugging statically linked programs where
2157      the new_objfile observer won't get called for libpthread.  */
2158   observer_attach_inferior_created (thread_db_inferior_created);
2159 }