#include "objfiles.h"
#include "target.h"
#include "regcache.h"
+#include "solib-svr4.h"
#ifndef LIBTHREAD_DB_SO
#define LIBTHREAD_DB_SO "libthread_db.so.1"
#endif
-/* If we're running on Linux, we must explicitly attach to any new threads. */
+/* If we're running on GNU/Linux, we must explicitly attach to any new
+ threads. */
/* FIXME: There is certainly some room for improvements:
- Cache LWP ids.
prgregset_t gregs);
static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th, int event);
+static td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
+ void *map_address,
+ size_t offset,
+ void **address);
+
/* Location of the thread creation event breakpoint. The code at this
location in the child process will be called by the pthread library
whenever a new thread is created. By setting a special breakpoint
/* Building process ids. */
-
#define GET_PID(ptid) ptid_get_pid (ptid)
#define GET_LWP(ptid) ptid_get_lwp (ptid)
#define GET_THREAD(ptid) ptid_get_tid (ptid)
#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
#define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
-
\f
struct private_thread_info
/* Cached LWP id. Must come first, see lin-lwp.c. */
lwpid_t lwpid;
};
-
\f
+
static char *
thread_db_err_str (td_err_e err)
{
err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
if (err != TD_OK)
- error ("Cannot find user-level thread for LWP %d: %s",
+ error ("Cannot find user-level thread for LWP %ld: %s",
GET_LWP (ptid), thread_db_err_str (err));
err = td_thr_get_info_p (&th, &ti);
if (err != TD_OK)
- error ("Cannot get thread info: %s", thread_db_err_str (err));
+ error ("thread_from_lwp: cannot get thread info: %s",
+ thread_db_err_str (err));
return BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
}
td_thrhandle_t th;
td_err_e err;
- if (! is_thread (ptid))
+ if (!is_thread (ptid))
return ptid;
err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
err = td_thr_get_info_p (&th, &ti);
if (err != TD_OK)
- error ("Cannot get thread info: %s", thread_db_err_str (err));
+ error ("lwp_from_thread: cannot get thread info: %s",
+ thread_db_err_str (err));
return BUILD_LWP (ti.ti_lid, GET_PID (ptid));
}
handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW);
if (handle == NULL)
- return 0;
+ {
+ fprintf_filtered (gdb_stderr, "\n\ndlopen failed on '%s' - %s\n",
+ LIBTHREAD_DB_SO, dlerror ());
+ fprintf_filtered (gdb_stderr,
+ "GDB will not be able to debug pthreads.\n\n");
+ return 0;
+ }
/* Initialize pointers to the dynamic library functions we will use.
Essential functions first. */
td_ta_set_event_p = dlsym (handle, "td_ta_set_event");
td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg");
td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable");
+ td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr");
return 1;
}
check_thread_signals (void)
{
#ifdef GET_THREAD_SIGNALS
- if (! thread_signals)
+ if (!thread_signals)
{
sigset_t mask;
int i;
{
td_err_e err;
- if (objfile == NULL)
+ /* Don't attempt to use thread_db on targets which can not run
+ (core files). */
+ if (objfile == NULL || !target_has_execution)
{
/* All symbols have been discarded. If the thread_db target is
active, deactivate it now. */
tp->private = xmalloc (sizeof (struct private_thread_info));
tp->private->lwpid = ti_p->ti_lid;
- if (ti_p->ti_state == TD_THR_UNKNOWN ||
- ti_p->ti_state == TD_THR_ZOMBIE)
- return;/* A zombie thread -- do not attach. */
+ if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
+ return; /* A zombie thread -- do not attach. */
- /* Under Linux, we have to attach to each and every thread. */
+ /* Under GNU/Linux, we have to attach to each and every thread. */
#ifdef ATTACH_LWP
ATTACH_LWP (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0);
#endif
err = td_thr_get_info_p (msg.th_p, &ti);
if (err != TD_OK)
- error ("Cannot get thread info: %s", thread_db_err_str (err));
+ error ("check_event: cannot get thread info: %s",
+ thread_db_err_str (err));
ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
/* We may already know about this thread, for instance when the
user has issued the `info threads' command before the SIGTRAP
for hitting the thread creation breakpoint was reported. */
- if (! in_thread_list (ptid))
+ if (!in_thread_list (ptid))
attach_thread (ptid, msg.th_p, &ti, 1);
return;
error ("Thread death event doesn't match breakpoint.");
#endif
- if (! in_thread_list (ptid))
+ if (!in_thread_list (ptid))
error ("Spurious thread death event.");
detach_thread (ptid, 1);
{
/* FIXME: This seems to be necessary to make sure breakpoints
are removed. */
- if (! target_thread_alive (inferior_ptid))
+ if (!target_thread_alive (inferior_ptid))
inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
else
inferior_ptid = lwp_from_thread (inferior_ptid);
gdb_prfpregset_t fpregset;
td_err_e err;
- if (! is_thread (inferior_ptid))
+ if (!is_thread (inferior_ptid))
{
/* Pass the request to the target beneath us. */
target_beneath->to_fetch_registers (regno);
gdb_prfpregset_t fpregset;
td_err_e err;
- if (! is_thread (inferior_ptid))
+ if (!is_thread (inferior_ptid))
{
/* Pass the request to the target beneath us. */
target_beneath->to_store_registers (regno);
{
char raw[MAX_REGISTER_RAW_SIZE];
- read_register_gen (regno, raw);
+ deprecated_read_register_gen (regno, raw);
thread_db_fetch_registers (-1);
supply_register (regno, raw);
}
static void
thread_db_create_inferior (char *exec_file, char *allargs, char **env)
{
- if (! keep_thread_db)
+ if (!keep_thread_db)
{
unpush_target (&thread_db_ops);
using_thread_db = 0;
/* ...and perform the remaining initialization steps. */
enable_thread_event_reporting ();
- thread_db_find_new_threads();
+ thread_db_find_new_threads ();
}
}
thread_db_thread_alive (ptid_t ptid)
{
td_thrhandle_t th;
- td_thrinfo_t ti;
- td_err_e err;
+ td_thrinfo_t ti;
+ td_err_e err;
if (is_thread (ptid))
{
if (err != TD_OK)
return 0;
- if (ti.ti_state == TD_THR_UNKNOWN ||
- ti.ti_state == TD_THR_ZOMBIE)
- return 0; /* A zombie thread. */
+ if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
+ return 0; /* A zombie thread. */
return 1;
}
err = td_thr_get_info_p (th_p, &ti);
if (err != TD_OK)
- error ("Cannot get thread info: %s", thread_db_err_str (err));
-
- if (ti.ti_state == TD_THR_UNKNOWN ||
- ti.ti_state == TD_THR_ZOMBIE)
+ error ("find_new_threads_callback: cannot get thread info: %s",
+ thread_db_err_str (err));
- return 0; /* A zombie -- ignore. */
+ if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
+ return 0; /* A zombie -- ignore. */
ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid));
- if (! in_thread_list (ptid))
+ if (!in_thread_list (ptid))
attach_thread (ptid, th_p, &ti, 1);
return 0;
err = td_thr_get_info_p (&th, &ti);
if (err != TD_OK)
- error ("Cannot get thread info for thread %ld: %s",
+ error ("thread_db_pid_to_str: cannot get thread info for %ld: %s",
(long) GET_THREAD (ptid), thread_db_err_str (err));
if (ti.ti_state == TD_THR_ACTIVE && ti.ti_lid != 0)
return normal_pid_to_str (ptid);
}
+/* Get the address of the thread local variable in OBJFILE which is
+ stored at OFFSET within the thread local storage for thread PTID. */
+
+static CORE_ADDR
+thread_db_get_thread_local_address (ptid_t ptid, struct objfile *objfile,
+ CORE_ADDR offset)
+{
+ if (is_thread (ptid))
+ {
+ int objfile_is_library = (objfile->flags & OBJF_SHARED);
+ td_err_e err;
+ td_thrhandle_t th;
+ void *address;
+ CORE_ADDR lm;
+
+ /* glibc doesn't provide the needed interface. */
+ if (! td_thr_tls_get_addr_p)
+ error ("Cannot find thread-local variables in this thread library.");
+
+ /* Get the address of the link map for this objfile. */
+ lm = svr4_fetch_objfile_link_map (objfile);
+
+ /* Whoops, we couldn't find one. Bail out. */
+ if (!lm)
+ {
+ if (objfile_is_library)
+ error ("Cannot find shared library `%s' link_map in dynamic"
+ " linker's module list", objfile->name);
+ else
+ error ("Cannot find executable file `%s' link_map in dynamic"
+ " linker's module list", objfile->name);
+ }
+
+ /* Get info about the thread. */
+ err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
+ if (err != TD_OK)
+ error ("Cannot find thread %ld: %s",
+ (long) GET_THREAD (ptid), thread_db_err_str (err));
+
+ /* Finally, get the address of the variable. */
+ err = td_thr_tls_get_addr_p (&th, (void *) lm, offset, &address);
+
+#ifdef THREAD_DB_HAS_TD_NOTALLOC
+ /* The memory hasn't been allocated, yet. */
+ if (err == TD_NOTALLOC)
+ {
+ /* Now, if libthread_db provided the initialization image's
+ address, we *could* try to build a non-lvalue value from
+ the initialization image. */
+ if (objfile_is_library)
+ error ("The inferior has not yet allocated storage for"
+ " thread-local variables in\n"
+ "the shared library `%s'\n"
+ "for the thread %ld",
+ objfile->name, (long) GET_THREAD (ptid));
+ else
+ error ("The inferior has not yet allocated storage for"
+ " thread-local variables in\n"
+ "the executable `%s'\n"
+ "for the thread %ld",
+ objfile->name, (long) GET_THREAD (ptid));
+ }
+#endif
+
+ /* Something else went wrong. */
+ if (err != TD_OK)
+ {
+ if (objfile_is_library)
+ error ("Cannot find thread-local storage for thread %ld, "
+ "shared library %s:\n%s",
+ (long) GET_THREAD (ptid),
+ objfile->name,
+ thread_db_err_str (err));
+ else
+ error ("Cannot find thread-local storage for thread %ld, "
+ "executable file %s:\n%s",
+ (long) GET_THREAD (ptid),
+ objfile->name,
+ thread_db_err_str (err));
+ }
+
+ /* Cast assuming host == target. Joy. */
+ return (CORE_ADDR) address;
+ }
+
+ if (target_beneath->to_get_thread_local_address)
+ return target_beneath->to_get_thread_local_address (ptid, objfile, offset);
+
+ error ("Cannot find thread-local values on this target.");
+}
+
static void
init_thread_db_ops (void)
{
thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
thread_db_ops.to_stratum = thread_stratum;
thread_db_ops.to_has_thread_control = tc_schedlock;
+ thread_db_ops.to_get_thread_local_address
+ = thread_db_get_thread_local_address;
thread_db_ops.to_magic = OPS_MAGIC;
}
projects / deliverable / binutils-gdb.git / blobdiff