1 /* libthread_db assisted debugging support, generic parts.
3 Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_assert.h"
25 #include "gdb_proc_service.h"
26 #include "gdb_thread_db.h"
30 #include "exceptions.h"
32 #include "gdbthread.h"
39 #include "solib-svr4.h"
42 #include "linux-nat.h"
46 #ifdef HAVE_GNU_LIBC_VERSION_H
47 #include <gnu/libc-version.h>
50 /* GNU/Linux libthread_db support.
52 libthread_db is a library, provided along with libpthread.so, which
53 exposes the internals of the thread library to a debugger. It
54 allows GDB to find existing threads, new threads as they are
55 created, thread IDs (usually, the result of pthread_self), and
56 thread-local variables.
58 The libthread_db interface originates on Solaris, where it is
59 both more powerful and more complicated. This implementation
60 only works for LinuxThreads and NPTL, the two glibc threading
61 libraries. It assumes that each thread is permanently assigned
62 to a single light-weight process (LWP).
64 libthread_db-specific information is stored in the "private" field
65 of struct thread_info. When the field is NULL we do not yet have
66 information about the new thread; this could be temporary (created,
67 but the thread library's data structures do not reflect it yet)
68 or permanent (created using clone instead of pthread_create).
70 Process IDs managed by linux-thread-db.c match those used by
71 linux-nat.c: a common PID for all processes, an LWP ID for each
72 thread, and no TID. We save the TID in private. Keeping it out
73 of the ptid_t prevents thread IDs changing when libpthread is
74 loaded or unloaded. */
76 static char *libthread_db_search_path
;
78 /* If non-zero, print details of libthread_db processing. */
80 static int libthread_db_debug
;
83 show_libthread_db_debug (struct ui_file
*file
, int from_tty
,
84 struct cmd_list_element
*c
, const char *value
)
86 fprintf_filtered (file
, _("libthread-db debugging is %s.\n"), value
);
90 /* If we're running on GNU/Linux, we must explicitly attach to any new
93 /* This module's target vector. */
94 static struct target_ops thread_db_ops
;
96 /* Non-zero if we have determined the signals used by the threads
98 static int thread_signals
;
99 static sigset_t thread_stop_set
;
100 static sigset_t thread_print_set
;
102 struct thread_db_info
104 struct thread_db_info
*next
;
106 /* Process id this object refers to. */
109 /* Handle from dlopen for libthread_db.so. */
112 /* Structure that identifies the child process for the
113 <proc_service.h> interface. */
114 struct ps_prochandle proc_handle
;
116 /* Connection to the libthread_db library. */
117 td_thragent_t
*thread_agent
;
119 /* True if we need to apply the workaround for glibc/BZ5983. When
120 we catch a PTRACE_O_TRACEFORK, and go query the child's thread
121 list, nptl_db returns the parent's threads in addition to the new
122 (single) child thread. If this flag is set, we do extra work to
123 be able to ignore such stale entries. */
124 int need_stale_parent_threads_check
;
126 /* Location of the thread creation event breakpoint. The code at
127 this location in the child process will be called by the pthread
128 library whenever a new thread is created. By setting a special
129 breakpoint at this location, GDB can detect when a new thread is
130 created. We obtain this location via the td_ta_event_addr
132 CORE_ADDR td_create_bp_addr
;
134 /* Location of the thread death event breakpoint. */
135 CORE_ADDR td_death_bp_addr
;
137 /* Pointers to the libthread_db functions. */
139 td_err_e (*td_init_p
) (void);
141 td_err_e (*td_ta_new_p
) (struct ps_prochandle
* ps
,
143 td_err_e (*td_ta_map_id2thr_p
) (const td_thragent_t
*ta
, thread_t pt
,
144 td_thrhandle_t
*__th
);
145 td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
,
146 lwpid_t lwpid
, td_thrhandle_t
*th
);
147 td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
148 td_thr_iter_f
*callback
, void *cbdata_p
,
149 td_thr_state_e state
, int ti_pri
,
150 sigset_t
*ti_sigmask_p
,
151 unsigned int ti_user_flags
);
152 td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
153 td_event_e event
, td_notify_t
*ptr
);
154 td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
155 td_thr_events_t
*event
);
156 td_err_e (*td_ta_clear_event_p
) (const td_thragent_t
*ta
,
157 td_thr_events_t
*event
);
158 td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
159 td_event_msg_t
*msg
);
161 td_err_e (*td_thr_validate_p
) (const td_thrhandle_t
*th
);
162 td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
163 td_thrinfo_t
*infop
);
164 td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
,
167 td_err_e (*td_thr_tls_get_addr_p
) (const td_thrhandle_t
*th
,
168 psaddr_t map_address
,
169 size_t offset
, psaddr_t
*address
);
172 /* List of known processes using thread_db, and the required
174 struct thread_db_info
*thread_db_list
;
176 static void thread_db_find_new_threads_1 (ptid_t ptid
);
177 static void thread_db_find_new_threads_2 (ptid_t ptid
, int until_no_new
);
179 /* Add the current inferior to the list of processes using libpthread.
180 Return a pointer to the newly allocated object that was added to
181 THREAD_DB_LIST. HANDLE is the handle returned by dlopen'ing
184 static struct thread_db_info
*
185 add_thread_db_info (void *handle
)
187 struct thread_db_info
*info
;
189 info
= xcalloc (1, sizeof (*info
));
190 info
->pid
= ptid_get_pid (inferior_ptid
);
191 info
->handle
= handle
;
192 info
->need_stale_parent_threads_check
= 1;
194 info
->next
= thread_db_list
;
195 thread_db_list
= info
;
200 /* Return the thread_db_info object representing the bookkeeping
201 related to process PID, if any; NULL otherwise. */
203 static struct thread_db_info
*
204 get_thread_db_info (int pid
)
206 struct thread_db_info
*info
;
208 for (info
= thread_db_list
; info
; info
= info
->next
)
209 if (pid
== info
->pid
)
215 /* When PID has exited or has been detached, we no longer want to keep
216 track of it as using libpthread. Call this function to discard
217 thread_db related info related to PID. Note that this closes
218 LIBTHREAD_DB_SO's dlopen'ed handle. */
221 delete_thread_db_info (int pid
)
223 struct thread_db_info
*info
, *info_prev
;
227 for (info
= thread_db_list
; info
; info_prev
= info
, info
= info
->next
)
228 if (pid
== info
->pid
)
234 if (info
->handle
!= NULL
)
235 dlclose (info
->handle
);
238 info_prev
->next
= info
->next
;
240 thread_db_list
= info
->next
;
245 /* Prototypes for local functions. */
246 static int attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
247 const td_thrinfo_t
*ti_p
);
248 static void detach_thread (ptid_t ptid
);
251 /* Use "struct private_thread_info" to cache thread state. This is
252 a substantial optimization. */
254 struct private_thread_info
256 /* Flag set when we see a TD_DEATH event for this thread. */
257 unsigned int dying
:1;
259 /* Cached thread state. */
266 thread_db_err_str (td_err_e err
)
273 return "generic 'call succeeded'";
275 return "generic error";
277 return "no thread to satisfy query";
279 return "no sync handle to satisfy query";
281 return "no LWP to satisfy query";
283 return "invalid process handle";
285 return "invalid thread handle";
287 return "invalid synchronization handle";
289 return "invalid thread agent";
291 return "invalid key";
293 return "no event message for getmsg";
295 return "FPU register set not available";
297 return "application not linked with libthread";
299 return "requested event is not supported";
301 return "capability not available";
303 return "debugger service failed";
305 return "operation not applicable to";
307 return "no thread-specific data for this thread";
309 return "malloc failed";
311 return "only part of register set was written/read";
313 return "X register set not available for this thread";
314 #ifdef THREAD_DB_HAS_TD_NOTALLOC
316 return "thread has not yet allocated TLS for given module";
318 #ifdef THREAD_DB_HAS_TD_VERSION
320 return "versions of libpthread and libthread_db do not match";
322 #ifdef THREAD_DB_HAS_TD_NOTLS
324 return "there is no TLS segment in the given module";
327 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
332 /* Return 1 if any threads have been registered. There may be none if
333 the threading library is not fully initialized yet. */
336 have_threads_callback (struct thread_info
*thread
, void *args
)
338 int pid
= * (int *) args
;
340 if (ptid_get_pid (thread
->ptid
) != pid
)
343 return thread
->private != NULL
;
347 have_threads (ptid_t ptid
)
349 int pid
= ptid_get_pid (ptid
);
351 return iterate_over_threads (have_threads_callback
, &pid
) != NULL
;
354 struct thread_get_info_inout
356 struct thread_info
*thread_info
;
357 struct thread_db_info
*thread_db_info
;
360 /* A callback function for td_ta_thr_iter, which we use to map all
363 THP is a handle to the current thread; if INFOP is not NULL, the
364 struct thread_info associated with this thread is returned in
367 If the thread is a zombie, TD_THR_ZOMBIE is returned. Otherwise,
368 zero is returned to indicate success. */
371 thread_get_info_callback (const td_thrhandle_t
*thp
, void *argp
)
376 struct thread_get_info_inout
*inout
;
377 struct thread_db_info
*info
;
380 info
= inout
->thread_db_info
;
382 err
= info
->td_thr_get_info_p (thp
, &ti
);
384 error (_("thread_get_info_callback: cannot get thread info: %s"),
385 thread_db_err_str (err
));
387 /* Fill the cache. */
388 thread_ptid
= ptid_build (info
->pid
, ti
.ti_lid
, 0);
389 inout
->thread_info
= find_thread_ptid (thread_ptid
);
391 /* In the case of a zombie thread, don't continue. We don't want to
392 attach to it thinking it is a new thread. */
393 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
394 return TD_THR_ZOMBIE
;
396 if (inout
->thread_info
== NULL
)
398 /* New thread. Attach to it now (why wait?). */
399 if (!have_threads (thread_ptid
))
400 thread_db_find_new_threads_1 (thread_ptid
);
402 attach_thread (thread_ptid
, thp
, &ti
);
403 inout
->thread_info
= find_thread_ptid (thread_ptid
);
404 gdb_assert (inout
->thread_info
!= NULL
);
410 /* Convert between user-level thread ids and LWP ids. */
413 thread_from_lwp (ptid_t ptid
)
417 struct thread_db_info
*info
;
418 struct thread_get_info_inout io
= {0};
420 /* This ptid comes from linux-nat.c, which should always fill in the
422 gdb_assert (GET_LWP (ptid
) != 0);
424 info
= get_thread_db_info (GET_PID (ptid
));
426 /* Access an lwp we know is stopped. */
427 info
->proc_handle
.ptid
= ptid
;
428 err
= info
->td_ta_map_lwp2thr_p (info
->thread_agent
, GET_LWP (ptid
), &th
);
430 error (_("Cannot find user-level thread for LWP %ld: %s"),
431 GET_LWP (ptid
), thread_db_err_str (err
));
433 /* Fetch the thread info. If we get back TD_THR_ZOMBIE, then the
434 event thread has already died. If another gdb interface has called
435 thread_alive() previously, the thread won't be found on the thread list
436 anymore. In that case, we don't want to process this ptid anymore
437 to avoid the possibility of later treating it as a newly
438 discovered thread id that we should add to the list. Thus,
439 we return a -1 ptid which is also how the thread list marks a
441 io
.thread_db_info
= info
;
442 io
.thread_info
= NULL
;
443 if (thread_get_info_callback (&th
, &io
) == TD_THR_ZOMBIE
444 && io
.thread_info
== NULL
)
445 return minus_one_ptid
;
447 gdb_assert (ptid_get_tid (ptid
) == 0);
452 /* Attach to lwp PTID, doing whatever else is required to have this
453 LWP under the debugger's control --- e.g., enabling event
454 reporting. Returns true on success. */
456 thread_db_attach_lwp (ptid_t ptid
)
461 struct thread_db_info
*info
;
463 info
= get_thread_db_info (GET_PID (ptid
));
468 /* This ptid comes from linux-nat.c, which should always fill in the
470 gdb_assert (GET_LWP (ptid
) != 0);
472 /* Access an lwp we know is stopped. */
473 info
->proc_handle
.ptid
= ptid
;
475 /* If we have only looked at the first thread before libpthread was
476 initialized, we may not know its thread ID yet. Make sure we do
477 before we add another thread to the list. */
478 if (!have_threads (ptid
))
479 thread_db_find_new_threads_1 (ptid
);
481 err
= info
->td_ta_map_lwp2thr_p (info
->thread_agent
, GET_LWP (ptid
), &th
);
483 /* Cannot find user-level thread. */
486 err
= info
->td_thr_get_info_p (&th
, &ti
);
489 warning (_("Cannot get thread info: %s"), thread_db_err_str (err
));
493 attach_thread (ptid
, &th
, &ti
);
498 verbose_dlsym (void *handle
, const char *name
)
500 void *sym
= dlsym (handle
, name
);
502 warning (_("Symbol \"%s\" not found in libthread_db: %s"), name
, dlerror ());
507 enable_thread_event (int event
, CORE_ADDR
*bp
)
511 struct thread_db_info
*info
;
513 info
= get_thread_db_info (GET_PID (inferior_ptid
));
515 /* Access an lwp we know is stopped. */
516 info
->proc_handle
.ptid
= inferior_ptid
;
518 /* Get the breakpoint address for thread EVENT. */
519 err
= info
->td_ta_event_addr_p (info
->thread_agent
, event
, ¬ify
);
523 /* Set up the breakpoint. */
524 gdb_assert (exec_bfd
);
525 (*bp
) = (gdbarch_convert_from_func_ptr_addr
527 /* Do proper sign extension for the target. */
528 (bfd_get_sign_extend_vma (exec_bfd
) > 0
529 ? (CORE_ADDR
) (intptr_t) notify
.u
.bptaddr
530 : (CORE_ADDR
) (uintptr_t) notify
.u
.bptaddr
),
532 create_thread_event_breakpoint (target_gdbarch
, *bp
);
538 enable_thread_event_reporting (void)
540 td_thr_events_t events
;
542 #ifdef HAVE_GNU_LIBC_VERSION_H
543 const char *libc_version
;
544 int libc_major
, libc_minor
;
546 struct thread_db_info
*info
;
548 info
= get_thread_db_info (GET_PID (inferior_ptid
));
550 /* We cannot use the thread event reporting facility if these
551 functions aren't available. */
552 if (info
->td_ta_event_addr_p
== NULL
553 || info
->td_ta_set_event_p
== NULL
554 || info
->td_ta_event_getmsg_p
== NULL
555 || info
->td_thr_event_enable_p
== NULL
)
558 /* Set the process wide mask saying which events we're interested in. */
559 td_event_emptyset (&events
);
560 td_event_addset (&events
, TD_CREATE
);
562 #ifdef HAVE_GNU_LIBC_VERSION_H
563 /* The event reporting facility is broken for TD_DEATH events in
564 glibc 2.1.3, so don't enable it if we have glibc but a lower
566 libc_version
= gnu_get_libc_version ();
567 if (sscanf (libc_version
, "%d.%d", &libc_major
, &libc_minor
) == 2
568 && (libc_major
> 2 || (libc_major
== 2 && libc_minor
> 1)))
570 td_event_addset (&events
, TD_DEATH
);
572 err
= info
->td_ta_set_event_p (info
->thread_agent
, &events
);
575 warning (_("Unable to set global thread event mask: %s"),
576 thread_db_err_str (err
));
580 /* Delete previous thread event breakpoints, if any. */
581 remove_thread_event_breakpoints ();
582 info
->td_create_bp_addr
= 0;
583 info
->td_death_bp_addr
= 0;
585 /* Set up the thread creation event. */
586 err
= enable_thread_event (TD_CREATE
, &info
->td_create_bp_addr
);
589 warning (_("Unable to get location for thread creation breakpoint: %s"),
590 thread_db_err_str (err
));
594 /* Set up the thread death event. */
595 err
= enable_thread_event (TD_DEATH
, &info
->td_death_bp_addr
);
598 warning (_("Unable to get location for thread death breakpoint: %s"),
599 thread_db_err_str (err
));
604 /* Same as thread_db_find_new_threads_1, but silently ignore errors. */
607 thread_db_find_new_threads_silently (ptid_t ptid
)
609 volatile struct gdb_exception except
;
611 TRY_CATCH (except
, RETURN_MASK_ERROR
)
613 thread_db_find_new_threads_2 (ptid
, 1);
616 if (except
.reason
< 0 && libthread_db_debug
)
618 exception_fprintf (gdb_stderr
, except
,
619 "Warning: thread_db_find_new_threads_silently: ");
623 /* Lookup a library in which given symbol resides.
624 Note: this is looking in GDB process, not in the inferior.
625 Returns library name, or NULL. */
628 dladdr_to_soname (const void *addr
)
632 if (dladdr (addr
, &info
) != 0)
633 return info
.dli_fname
;
637 /* Attempt to initialize dlopen()ed libthread_db, described by HANDLE.
639 Failure could happen if libthread_db does not have symbols we expect,
640 or when it refuses to work with the current inferior (e.g. due to
641 version mismatch between libthread_db and libpthread). */
644 try_thread_db_load_1 (struct thread_db_info
*info
)
648 /* Initialize pointers to the dynamic library functions we will use.
649 Essential functions first. */
651 info
->td_init_p
= verbose_dlsym (info
->handle
, "td_init");
652 if (info
->td_init_p
== NULL
)
655 err
= info
->td_init_p ();
658 warning (_("Cannot initialize libthread_db: %s"), thread_db_err_str (err
));
662 info
->td_ta_new_p
= verbose_dlsym (info
->handle
, "td_ta_new");
663 if (info
->td_ta_new_p
== NULL
)
666 /* Initialize the structure that identifies the child process. */
667 info
->proc_handle
.ptid
= inferior_ptid
;
669 /* Now attempt to open a connection to the thread library. */
670 err
= info
->td_ta_new_p (&info
->proc_handle
, &info
->thread_agent
);
673 if (libthread_db_debug
)
674 printf_unfiltered (_("td_ta_new failed: %s\n"),
675 thread_db_err_str (err
));
680 #ifdef THREAD_DB_HAS_TD_VERSION
683 /* The errors above are not unexpected and silently ignored:
684 they just mean we haven't found correct version of
688 warning (_("td_ta_new failed: %s"), thread_db_err_str (err
));
693 info
->td_ta_map_id2thr_p
= verbose_dlsym (info
->handle
, "td_ta_map_id2thr");
694 if (info
->td_ta_map_id2thr_p
== NULL
)
697 info
->td_ta_map_lwp2thr_p
= verbose_dlsym (info
->handle
, "td_ta_map_lwp2thr");
698 if (info
->td_ta_map_lwp2thr_p
== NULL
)
701 info
->td_ta_thr_iter_p
= verbose_dlsym (info
->handle
, "td_ta_thr_iter");
702 if (info
->td_ta_thr_iter_p
== NULL
)
705 info
->td_thr_validate_p
= verbose_dlsym (info
->handle
, "td_thr_validate");
706 if (info
->td_thr_validate_p
== NULL
)
709 info
->td_thr_get_info_p
= verbose_dlsym (info
->handle
, "td_thr_get_info");
710 if (info
->td_thr_get_info_p
== NULL
)
713 /* These are not essential. */
714 info
->td_ta_event_addr_p
= dlsym (info
->handle
, "td_ta_event_addr");
715 info
->td_ta_set_event_p
= dlsym (info
->handle
, "td_ta_set_event");
716 info
->td_ta_clear_event_p
= dlsym (info
->handle
, "td_ta_clear_event");
717 info
->td_ta_event_getmsg_p
= dlsym (info
->handle
, "td_ta_event_getmsg");
718 info
->td_thr_event_enable_p
= dlsym (info
->handle
, "td_thr_event_enable");
719 info
->td_thr_tls_get_addr_p
= dlsym (info
->handle
, "td_thr_tls_get_addr");
721 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
723 if (libthread_db_debug
|| *libthread_db_search_path
)
727 library
= dladdr_to_soname (*info
->td_ta_new_p
);
729 library
= LIBTHREAD_DB_SO
;
731 printf_unfiltered (_("Using host libthread_db library \"%s\".\n"),
735 /* The thread library was detected. Activate the thread_db target
736 if this is the first process using it. */
737 if (thread_db_list
->next
== NULL
)
738 push_target (&thread_db_ops
);
740 enable_thread_event_reporting ();
742 /* There appears to be a bug in glibc-2.3.6: calls to td_thr_get_info fail
743 with TD_ERR for statically linked executables if td_thr_get_info is
744 called before glibc has initialized itself. Silently ignore such
745 errors, and let gdb enumerate threads again later. */
746 thread_db_find_new_threads_silently (inferior_ptid
);
751 /* Attempt to use LIBRARY as libthread_db. LIBRARY could be absolute,
752 relative, or just LIBTHREAD_DB. */
755 try_thread_db_load (const char *library
)
758 struct thread_db_info
*info
;
760 if (libthread_db_debug
)
761 printf_unfiltered (_("Trying host libthread_db library: %s.\n"),
763 handle
= dlopen (library
, RTLD_NOW
);
766 if (libthread_db_debug
)
767 printf_unfiltered (_("dlopen failed: %s.\n"), dlerror ());
771 if (libthread_db_debug
&& strchr (library
, '/') == NULL
)
775 td_init
= dlsym (handle
, "td_init");
778 const char *const libpath
= dladdr_to_soname (td_init
);
781 printf_unfiltered (_("Host %s resolved to: %s.\n"),
786 info
= add_thread_db_info (handle
);
788 if (try_thread_db_load_1 (info
))
791 /* This library "refused" to work on current inferior. */
792 delete_thread_db_info (GET_PID (inferior_ptid
));
797 /* Search libthread_db_search_path for libthread_db which "agrees"
798 to work on current inferior. */
801 thread_db_load_search (void)
804 const char *search_path
= libthread_db_search_path
;
809 const char *end
= strchr (search_path
, ':');
813 size_t len
= end
- search_path
;
815 if (len
+ 1 + strlen (LIBTHREAD_DB_SO
) + 1 > sizeof (path
))
817 char *cp
= xmalloc (len
+ 1);
819 memcpy (cp
, search_path
, len
);
821 warning (_("libthread_db_search_path component too long,"
822 " ignored: %s."), cp
);
824 search_path
+= len
+ 1;
827 memcpy (path
, search_path
, len
);
829 search_path
+= len
+ 1;
833 size_t len
= strlen (search_path
);
835 if (len
+ 1 + strlen (LIBTHREAD_DB_SO
) + 1 > sizeof (path
))
837 warning (_("libthread_db_search_path component too long,"
838 " ignored: %s."), search_path
);
841 memcpy (path
, search_path
, len
+ 1);
845 strcat (path
, LIBTHREAD_DB_SO
);
846 if (try_thread_db_load (path
))
853 rc
= try_thread_db_load (LIBTHREAD_DB_SO
);
857 /* Attempt to load and initialize libthread_db.
862 thread_db_load (void)
865 struct thread_db_info
*info
;
867 info
= get_thread_db_info (GET_PID (inferior_ptid
));
872 /* Don't attempt to use thread_db on targets which can not run
873 (executables not running yet, core files) for now. */
874 if (!target_has_execution
)
877 /* Don't attempt to use thread_db for remote targets. */
878 if (!target_can_run (¤t_target
))
881 if (thread_db_load_search ())
884 /* None of the libthread_db's on our search path, not the system default
885 ones worked. If the executable is dynamically linked against
886 libpthread, try loading libthread_db from the same directory. */
889 if (libpthread_name_p (obj
->name
))
891 char path
[PATH_MAX
], *cp
;
893 gdb_assert (strlen (obj
->name
) < sizeof (path
));
894 strcpy (path
, obj
->name
);
895 cp
= strrchr (path
, '/');
899 warning (_("Expected absolute pathname for libpthread in the"
900 " inferior, but got %s."), path
);
902 else if (cp
+ 1 + strlen (LIBTHREAD_DB_SO
) + 1 > path
+ sizeof (path
))
904 warning (_("Unexpected: path to libpthread in the inferior is"
905 " too long: %s"), path
);
909 strcpy (cp
+ 1, LIBTHREAD_DB_SO
);
910 if (try_thread_db_load (path
))
913 warning (_("Unable to find libthread_db matching inferior's thread"
914 " library, thread debugging will not be available."));
917 /* Either this executable isn't using libpthread at all, or it is
918 statically linked. Since we can't easily distinguish these two cases,
919 no warning is issued. */
924 disable_thread_event_reporting (struct thread_db_info
*info
)
926 if (info
->td_ta_clear_event_p
!= NULL
)
928 td_thr_events_t events
;
930 /* Set the process wide mask saying we aren't interested in any
932 td_event_fillset (&events
);
933 info
->td_ta_clear_event_p (info
->thread_agent
, &events
);
936 info
->td_create_bp_addr
= 0;
937 info
->td_death_bp_addr
= 0;
941 check_thread_signals (void)
948 lin_thread_get_thread_signals (&mask
);
949 sigemptyset (&thread_stop_set
);
950 sigemptyset (&thread_print_set
);
952 for (i
= 1; i
< NSIG
; i
++)
954 if (sigismember (&mask
, i
))
956 if (signal_stop_update (target_signal_from_host (i
), 0))
957 sigaddset (&thread_stop_set
, i
);
958 if (signal_print_update (target_signal_from_host (i
), 0))
959 sigaddset (&thread_print_set
, i
);
966 /* Check whether thread_db is usable. This function is called when
967 an inferior is created (or otherwise acquired, e.g. attached to)
968 and when new shared libraries are loaded into a running process. */
971 check_for_thread_db (void)
973 /* Do nothing if we couldn't load libthread_db.so.1. */
974 if (!thread_db_load ())
979 thread_db_new_objfile (struct objfile
*objfile
)
981 /* This observer must always be called with inferior_ptid set
985 check_for_thread_db ();
988 /* Attach to a new thread. This function is called when we receive a
989 TD_CREATE event or when we iterate over all threads and find one
990 that wasn't already in our list. Returns true on success. */
993 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
994 const td_thrinfo_t
*ti_p
)
996 struct private_thread_info
*private;
997 struct thread_info
*tp
= NULL
;
999 struct thread_db_info
*info
;
1001 /* If we're being called after a TD_CREATE event, we may already
1002 know about this thread. There are two ways this can happen. We
1003 may have iterated over all threads between the thread creation
1004 and the TD_CREATE event, for instance when the user has issued
1005 the `info threads' command before the SIGTRAP for hitting the
1006 thread creation breakpoint was reported. Alternatively, the
1007 thread may have exited and a new one been created with the same
1008 thread ID. In the first case we don't need to do anything; in
1009 the second case we should discard information about the dead
1010 thread and attach to the new one. */
1011 if (in_thread_list (ptid
))
1013 tp
= find_thread_ptid (ptid
);
1014 gdb_assert (tp
!= NULL
);
1016 /* If tp->private is NULL, then GDB is already attached to this
1017 thread, but we do not know anything about it. We can learn
1018 about it here. This can only happen if we have some other
1019 way besides libthread_db to notice new threads (i.e.
1020 PTRACE_EVENT_CLONE); assume the same mechanism notices thread
1021 exit, so this can not be a stale thread recreated with the
1023 if (tp
->private != NULL
)
1025 if (!tp
->private->dying
)
1028 delete_thread (ptid
);
1033 check_thread_signals ();
1035 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
1036 return 0; /* A zombie thread -- do not attach. */
1038 /* Under GNU/Linux, we have to attach to each and every thread. */
1040 && lin_lwp_attach_lwp (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
))) < 0)
1043 /* Construct the thread's private data. */
1044 private = xmalloc (sizeof (struct private_thread_info
));
1045 memset (private, 0, sizeof (struct private_thread_info
));
1047 /* A thread ID of zero may mean the thread library has not initialized
1048 yet. But we shouldn't even get here if that's the case. FIXME:
1049 if we change GDB to always have at least one thread in the thread
1050 list this will have to go somewhere else; maybe private == NULL
1051 until the thread_db target claims it. */
1052 gdb_assert (ti_p
->ti_tid
!= 0);
1053 private->th
= *th_p
;
1054 private->tid
= ti_p
->ti_tid
;
1056 /* Add the thread to GDB's thread list. */
1058 tp
= add_thread_with_info (ptid
, private);
1060 tp
->private = private;
1062 info
= get_thread_db_info (GET_PID (ptid
));
1064 /* Enable thread event reporting for this thread. */
1065 err
= info
->td_thr_event_enable_p (th_p
, 1);
1067 error (_("Cannot enable thread event reporting for %s: %s"),
1068 target_pid_to_str (ptid
), thread_db_err_str (err
));
1073 detach_thread (ptid_t ptid
)
1075 struct thread_info
*thread_info
;
1077 /* Don't delete the thread now, because it still reports as active
1078 until it has executed a few instructions after the event
1079 breakpoint - if we deleted it now, "info threads" would cause us
1080 to re-attach to it. Just mark it as having had a TD_DEATH
1081 event. This means that we won't delete it from our thread list
1082 until we notice that it's dead (via prune_threads), or until
1083 something re-uses its thread ID. We'll report the thread exit
1084 when the underlying LWP dies. */
1085 thread_info
= find_thread_ptid (ptid
);
1086 gdb_assert (thread_info
!= NULL
&& thread_info
->private != NULL
);
1087 thread_info
->private->dying
= 1;
1091 thread_db_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1093 struct target_ops
*target_beneath
= find_target_beneath (ops
);
1094 struct thread_db_info
*info
;
1096 info
= get_thread_db_info (GET_PID (inferior_ptid
));
1100 disable_thread_event_reporting (info
);
1102 /* Delete the old thread event breakpoints. Note that unlike
1103 when mourning, we can remove them here because there's still
1104 a live inferior to poke at. In any case, GDB will not try to
1105 insert anything in the inferior when removing a
1107 remove_thread_event_breakpoints ();
1109 delete_thread_db_info (GET_PID (inferior_ptid
));
1112 target_beneath
->to_detach (target_beneath
, args
, from_tty
);
1114 /* NOTE: From this point on, inferior_ptid is null_ptid. */
1116 /* If there are no more processes using libpthread, detach the
1117 thread_db target ops. */
1118 if (!thread_db_list
)
1119 unpush_target (&thread_db_ops
);
1122 /* Check if PID is currently stopped at the location of a thread event
1123 breakpoint location. If it is, read the event message and act upon
1127 check_event (ptid_t ptid
)
1129 struct regcache
*regcache
= get_thread_regcache (ptid
);
1130 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1136 struct thread_db_info
*info
;
1138 info
= get_thread_db_info (GET_PID (ptid
));
1140 /* Bail out early if we're not at a thread event breakpoint. */
1141 stop_pc
= regcache_read_pc (regcache
)
1142 - gdbarch_decr_pc_after_break (gdbarch
);
1143 if (stop_pc
!= info
->td_create_bp_addr
1144 && stop_pc
!= info
->td_death_bp_addr
)
1147 /* Access an lwp we know is stopped. */
1148 info
->proc_handle
.ptid
= ptid
;
1150 /* If we have only looked at the first thread before libpthread was
1151 initialized, we may not know its thread ID yet. Make sure we do
1152 before we add another thread to the list. */
1153 if (!have_threads (ptid
))
1154 thread_db_find_new_threads_1 (ptid
);
1156 /* If we are at a create breakpoint, we do not know what new lwp
1157 was created and cannot specifically locate the event message for it.
1158 We have to call td_ta_event_getmsg() to get
1159 the latest message. Since we have no way of correlating whether
1160 the event message we get back corresponds to our breakpoint, we must
1161 loop and read all event messages, processing them appropriately.
1162 This guarantees we will process the correct message before continuing
1163 from the breakpoint.
1165 Currently, death events are not enabled. If they are enabled,
1166 the death event can use the td_thr_event_getmsg() interface to
1167 get the message specifically for that lwp and avoid looping
1174 err
= info
->td_ta_event_getmsg_p (info
->thread_agent
, &msg
);
1177 if (err
== TD_NOMSG
)
1180 error (_("Cannot get thread event message: %s"),
1181 thread_db_err_str (err
));
1184 err
= info
->td_thr_get_info_p (msg
.th_p
, &ti
);
1186 error (_("Cannot get thread info: %s"), thread_db_err_str (err
));
1188 ptid
= ptid_build (GET_PID (ptid
), ti
.ti_lid
, 0);
1193 /* Call attach_thread whether or not we already know about a
1194 thread with this thread ID. */
1195 attach_thread (ptid
, msg
.th_p
, &ti
);
1201 if (!in_thread_list (ptid
))
1202 error (_("Spurious thread death event."));
1204 detach_thread (ptid
);
1209 error (_("Spurious thread event."));
1216 thread_db_wait (struct target_ops
*ops
,
1217 ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1220 struct thread_db_info
*info
;
1221 struct target_ops
*beneath
= find_target_beneath (ops
);
1223 ptid
= beneath
->to_wait (beneath
, ptid
, ourstatus
, options
);
1225 if (ourstatus
->kind
== TARGET_WAITKIND_IGNORE
)
1228 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
1229 || ourstatus
->kind
== TARGET_WAITKIND_SIGNALLED
)
1232 info
= get_thread_db_info (GET_PID (ptid
));
1234 /* If this process isn't using thread_db, we're done. */
1238 if (ourstatus
->kind
== TARGET_WAITKIND_EXECD
)
1240 /* New image, it may or may not end up using thread_db. Assume
1241 not unless we find otherwise. */
1242 delete_thread_db_info (GET_PID (ptid
));
1243 if (!thread_db_list
)
1244 unpush_target (&thread_db_ops
);
1246 /* Thread event breakpoints are deleted by
1247 update_breakpoints_after_exec. */
1252 /* If we do not know about the main thread yet, this would be a good time to
1254 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
&& !have_threads (ptid
))
1255 thread_db_find_new_threads_1 (ptid
);
1257 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
1258 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
1259 /* Check for a thread event. */
1262 if (have_threads (ptid
))
1264 /* Change ptids back into the higher level PID + TID format. If
1265 the thread is dead and no longer on the thread list, we will
1266 get back a dead ptid. This can occur if the thread death
1267 event gets postponed by other simultaneous events. In such a
1268 case, we want to just ignore the event and continue on. */
1270 ptid
= thread_from_lwp (ptid
);
1271 if (GET_PID (ptid
) == -1)
1272 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1279 thread_db_mourn_inferior (struct target_ops
*ops
)
1281 struct target_ops
*target_beneath
= find_target_beneath (ops
);
1283 delete_thread_db_info (GET_PID (inferior_ptid
));
1285 target_beneath
->to_mourn_inferior (target_beneath
);
1287 /* Delete the old thread event breakpoints. Do this after mourning
1288 the inferior, so that we don't try to uninsert them. */
1289 remove_thread_event_breakpoints ();
1291 /* Detach thread_db target ops. */
1292 if (!thread_db_list
)
1293 unpush_target (ops
);
1296 struct callback_data
1298 struct thread_db_info
*info
;
1303 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1308 struct thread_info
*tp
;
1309 struct callback_data
*cb_data
= data
;
1310 struct thread_db_info
*info
= cb_data
->info
;
1312 err
= info
->td_thr_get_info_p (th_p
, &ti
);
1314 error (_("find_new_threads_callback: cannot get thread info: %s"),
1315 thread_db_err_str (err
));
1317 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
1318 return 0; /* A zombie -- ignore. */
1322 /* A thread ID of zero means that this is the main thread, but
1323 glibc has not yet initialized thread-local storage and the
1324 pthread library. We do not know what the thread's TID will
1325 be yet. Just enable event reporting and otherwise ignore
1328 /* In that case, we're not stopped in a fork syscall and don't
1329 need this glibc bug workaround. */
1330 info
->need_stale_parent_threads_check
= 0;
1332 err
= info
->td_thr_event_enable_p (th_p
, 1);
1334 error (_("Cannot enable thread event reporting for LWP %d: %s"),
1335 (int) ti
.ti_lid
, thread_db_err_str (err
));
1340 /* Ignore stale parent threads, caused by glibc/BZ5983. This is a
1341 bit expensive, as it needs to open /proc/pid/status, so try to
1342 avoid doing the work if we know we don't have to. */
1343 if (info
->need_stale_parent_threads_check
)
1345 int tgid
= linux_proc_get_tgid (ti
.ti_lid
);
1347 if (tgid
!= -1 && tgid
!= info
->pid
)
1351 ptid
= ptid_build (info
->pid
, ti
.ti_lid
, 0);
1352 tp
= find_thread_ptid (ptid
);
1353 if (tp
== NULL
|| tp
->private == NULL
)
1355 if (attach_thread (ptid
, th_p
, &ti
))
1356 cb_data
->new_threads
+= 1;
1358 /* Problem attaching this thread; perhaps it exited before we
1360 This could mean that the thread list inside glibc itself is in
1361 inconsistent state, and libthread_db could go on looping forever
1362 (observed with glibc-2.3.6). To prevent that, terminate
1363 iteration: thread_db_find_new_threads_2 will retry. */
1370 /* Helper for thread_db_find_new_threads_2.
1371 Returns number of new threads found. */
1374 find_new_threads_once (struct thread_db_info
*info
, int iteration
,
1377 volatile struct gdb_exception except
;
1378 struct callback_data data
;
1379 td_err_e err
= TD_ERR
;
1382 data
.new_threads
= 0;
1384 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1386 /* Iterate over all user-space threads to discover new threads. */
1387 err
= info
->td_ta_thr_iter_p (info
->thread_agent
,
1388 find_new_threads_callback
,
1391 TD_THR_LOWEST_PRIORITY
,
1393 TD_THR_ANY_USER_FLAGS
);
1396 if (libthread_db_debug
)
1398 if (except
.reason
< 0)
1399 exception_fprintf (gdb_stderr
, except
,
1400 "Warning: find_new_threads_once: ");
1402 printf_filtered (_("Found %d new threads in iteration %d.\n"),
1403 data
.new_threads
, iteration
);
1409 return data
.new_threads
;
1412 /* Search for new threads, accessing memory through stopped thread
1413 PTID. If UNTIL_NO_NEW is true, repeat searching until several
1414 searches in a row do not discover any new threads. */
1417 thread_db_find_new_threads_2 (ptid_t ptid
, int until_no_new
)
1420 struct lwp_info
*lp
;
1421 struct thread_db_info
*info
;
1422 int pid
= ptid_get_pid (ptid
);
1425 /* In linux, we can only read memory through a stopped lwp. */
1427 if (lp
->stopped
&& ptid_get_pid (lp
->ptid
) == pid
)
1431 /* There is no stopped thread. Bail out. */
1434 info
= get_thread_db_info (GET_PID (ptid
));
1436 /* Access an lwp we know is stopped. */
1437 info
->proc_handle
.ptid
= ptid
;
1441 /* Require 4 successive iterations which do not find any new threads.
1442 The 4 is a heuristic: there is an inherent race here, and I have
1443 seen that 2 iterations in a row are not always sufficient to
1444 "capture" all threads. */
1445 for (i
= 0, loop
= 0; loop
< 4; ++i
, ++loop
)
1446 if (find_new_threads_once (info
, i
, NULL
) != 0)
1447 /* Found some new threads. Restart the loop from beginning. */
1452 find_new_threads_once (info
, 0, &err
);
1454 error (_("Cannot find new threads: %s"), thread_db_err_str (err
));
1459 thread_db_find_new_threads_1 (ptid_t ptid
)
1461 thread_db_find_new_threads_2 (ptid
, 0);
1465 update_thread_core (struct lwp_info
*info
, void *closure
)
1467 info
->core
= linux_nat_core_of_thread_1 (info
->ptid
);
1472 thread_db_find_new_threads (struct target_ops
*ops
)
1474 struct thread_db_info
*info
;
1476 info
= get_thread_db_info (GET_PID (inferior_ptid
));
1481 thread_db_find_new_threads_1 (inferior_ptid
);
1483 iterate_over_lwps (minus_one_ptid
/* iterate over all */,
1484 update_thread_core
, NULL
);
1488 thread_db_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1490 struct thread_info
*thread_info
= find_thread_ptid (ptid
);
1491 struct target_ops
*beneath
;
1493 if (thread_info
!= NULL
&& thread_info
->private != NULL
)
1495 static char buf
[64];
1498 tid
= thread_info
->private->tid
;
1499 snprintf (buf
, sizeof (buf
), "Thread 0x%lx (LWP %ld)",
1500 tid
, GET_LWP (ptid
));
1505 beneath
= find_target_beneath (ops
);
1506 if (beneath
->to_pid_to_str (beneath
, ptid
))
1507 return beneath
->to_pid_to_str (beneath
, ptid
);
1509 return normal_pid_to_str (ptid
);
1512 /* Return a string describing the state of the thread specified by
1516 thread_db_extra_thread_info (struct thread_info
*info
)
1518 if (info
->private == NULL
)
1521 if (info
->private->dying
)
1527 /* Get the address of the thread local variable in load module LM which
1528 is stored at OFFSET within the thread local storage for thread PTID. */
1531 thread_db_get_thread_local_address (struct target_ops
*ops
,
1536 struct thread_info
*thread_info
;
1537 struct target_ops
*beneath
;
1539 /* If we have not discovered any threads yet, check now. */
1540 if (!have_threads (ptid
))
1541 thread_db_find_new_threads_1 (ptid
);
1543 /* Find the matching thread. */
1544 thread_info
= find_thread_ptid (ptid
);
1546 if (thread_info
!= NULL
&& thread_info
->private != NULL
)
1550 struct thread_db_info
*info
;
1552 info
= get_thread_db_info (GET_PID (ptid
));
1554 /* glibc doesn't provide the needed interface. */
1555 if (!info
->td_thr_tls_get_addr_p
)
1556 throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR
,
1557 _("No TLS library support"));
1559 /* Caller should have verified that lm != 0. */
1560 gdb_assert (lm
!= 0);
1562 /* Finally, get the address of the variable. */
1563 /* Note the cast through uintptr_t: this interface only works if
1564 a target address fits in a psaddr_t, which is a host pointer.
1565 So a 32-bit debugger can not access 64-bit TLS through this. */
1566 err
= info
->td_thr_tls_get_addr_p (&thread_info
->private->th
,
1567 (psaddr_t
)(uintptr_t) lm
,
1570 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1571 /* The memory hasn't been allocated, yet. */
1572 if (err
== TD_NOTALLOC
)
1573 /* Now, if libthread_db provided the initialization image's
1574 address, we *could* try to build a non-lvalue value from
1575 the initialization image. */
1576 throw_error (TLS_NOT_ALLOCATED_YET_ERROR
,
1577 _("TLS not allocated yet"));
1580 /* Something else went wrong. */
1582 throw_error (TLS_GENERIC_ERROR
,
1583 (("%s")), thread_db_err_str (err
));
1585 /* Cast assuming host == target. Joy. */
1586 /* Do proper sign extension for the target. */
1587 gdb_assert (exec_bfd
);
1588 return (bfd_get_sign_extend_vma (exec_bfd
) > 0
1589 ? (CORE_ADDR
) (intptr_t) address
1590 : (CORE_ADDR
) (uintptr_t) address
);
1593 beneath
= find_target_beneath (ops
);
1594 if (beneath
->to_get_thread_local_address
)
1595 return beneath
->to_get_thread_local_address (beneath
, ptid
, lm
, offset
);
1597 throw_error (TLS_GENERIC_ERROR
,
1598 _("TLS not supported on this target"));
1601 /* Callback routine used to find a thread based on the TID part of
1605 thread_db_find_thread_from_tid (struct thread_info
*thread
, void *data
)
1607 long *tid
= (long *) data
;
1609 if (thread
->private->tid
== *tid
)
1615 /* Implement the to_get_ada_task_ptid target method for this target. */
1618 thread_db_get_ada_task_ptid (long lwp
, long thread
)
1620 struct thread_info
*thread_info
;
1622 thread_db_find_new_threads_1 (inferior_ptid
);
1623 thread_info
= iterate_over_threads (thread_db_find_thread_from_tid
, &thread
);
1625 gdb_assert (thread_info
!= NULL
);
1627 return (thread_info
->ptid
);
1631 thread_db_resume (struct target_ops
*ops
,
1632 ptid_t ptid
, int step
, enum target_signal signo
)
1634 struct target_ops
*beneath
= find_target_beneath (ops
);
1635 struct thread_db_info
*info
;
1637 if (ptid_equal (ptid
, minus_one_ptid
))
1638 info
= get_thread_db_info (GET_PID (inferior_ptid
));
1640 info
= get_thread_db_info (GET_PID (ptid
));
1642 /* This workaround is only needed for child fork lwps stopped in a
1643 PTRACE_O_TRACEFORK event. When the inferior is resumed, the
1644 workaround can be disabled. */
1646 info
->need_stale_parent_threads_check
= 0;
1648 beneath
->to_resume (beneath
, ptid
, step
, signo
);
1652 init_thread_db_ops (void)
1654 thread_db_ops
.to_shortname
= "multi-thread";
1655 thread_db_ops
.to_longname
= "multi-threaded child process.";
1656 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1657 thread_db_ops
.to_detach
= thread_db_detach
;
1658 thread_db_ops
.to_wait
= thread_db_wait
;
1659 thread_db_ops
.to_resume
= thread_db_resume
;
1660 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1661 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1662 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1663 thread_db_ops
.to_stratum
= thread_stratum
;
1664 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1665 thread_db_ops
.to_get_thread_local_address
1666 = thread_db_get_thread_local_address
;
1667 thread_db_ops
.to_extra_thread_info
= thread_db_extra_thread_info
;
1668 thread_db_ops
.to_get_ada_task_ptid
= thread_db_get_ada_task_ptid
;
1669 thread_db_ops
.to_magic
= OPS_MAGIC
;
1672 /* Provide a prototype to silence -Wmissing-prototypes. */
1673 extern initialize_file_ftype _initialize_thread_db
;
1676 _initialize_thread_db (void)
1678 init_thread_db_ops ();
1679 add_target (&thread_db_ops
);
1681 /* Defer loading of libthread_db.so until inferior is running.
1682 This allows gdb to load correct libthread_db for a given
1683 executable -- there could be mutiple versions of glibc,
1684 compiled with LinuxThreads or NPTL, and until there is
1685 a running inferior, we can't tell which libthread_db is
1686 the correct one to load. */
1688 libthread_db_search_path
= xstrdup (LIBTHREAD_DB_SEARCH_PATH
);
1690 add_setshow_optional_filename_cmd ("libthread-db-search-path",
1692 &libthread_db_search_path
, _("\
1693 Set search path for libthread_db."), _("\
1694 Show the current search path or libthread_db."), _("\
1695 This path is used to search for libthread_db to be loaded into \
1699 &setlist
, &showlist
);
1701 add_setshow_zinteger_cmd ("libthread-db", class_maintenance
,
1702 &libthread_db_debug
, _("\
1703 Set libthread-db debugging."), _("\
1704 Show libthread-db debugging."), _("\
1705 When non-zero, libthread-db debugging is enabled."),
1707 show_libthread_db_debug
,
1708 &setdebuglist
, &showdebuglist
);
1710 /* Add ourselves to objfile event chain. */
1711 observer_attach_new_objfile (thread_db_new_objfile
);