/* libthread_db assisted debugging support, generic parts.
- Copyright 1999, 2000 Free Software Foundation, Inc.
+ Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdb_proc_service.h"
#include "gdb_thread_db.h"
+#include "bfd.h"
#include "gdbthread.h"
#include "inferior.h"
+#include "symfile.h"
+#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.
/* Non-zero if we're using this module's target vector. */
static int using_thread_db;
+/* Non-zero if we have to keep this module's target vector active
+ across re-runs. */
+static int keep_thread_db;
+
/* Non-zero if we have determined the signals used by the threads
library. */
static int thread_signals;
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
static CORE_ADDR td_death_bp_addr;
/* Prototypes for local functions. */
-static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
+static void thread_db_find_new_threads (void);
\f
/* Building process ids. */
-#ifndef TIDGET
-#define TIDGET(PID) (((PID) & 0x7fffffff) >> 16)
-#define PIDGET(PID) (((PID) & 0xffff))
-#define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
-#endif
-
-#define THREAD_FLAG 0x80000000
+#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 is_lwp(pid) (((pid) & THREAD_FLAG) == 0 && TIDGET (pid))
-#define is_thread(pid) ((pid) & THREAD_FLAG)
+#define is_lwp(ptid) (GET_LWP (ptid) != 0)
+#define is_thread(ptid) (GET_THREAD (ptid) != 0)
-#define GET_PID(pid) PIDGET (pid)
-#define GET_LWP(pid) TIDGET (pid)
-#define GET_THREAD(pid) TIDGET (pid)
-
-#define BUILD_LWP(tid, pid) MERGEPID (pid, tid)
-#define BUILD_THREAD(tid, pid) (MERGEPID (pid, tid) | THREAD_FLAG)
+#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
-/* Helper functions. */
-
-static void
-restore_inferior_pid (void *arg)
-{
- int *saved_pid_ptr = arg;
- inferior_pid = *saved_pid_ptr;
- xfree (arg);
-}
-
-static struct cleanup *
-save_inferior_pid (void)
-{
- int *saved_pid_ptr;
-
- saved_pid_ptr = xmalloc (sizeof (int));
- *saved_pid_ptr = inferior_pid;
- return make_cleanup (restore_inferior_pid, saved_pid_ptr);
-}
\f
static char *
/* Convert between user-level thread ids and LWP ids. */
-static int
-thread_from_lwp (int pid)
+static ptid_t
+thread_from_lwp (ptid_t ptid)
{
td_thrinfo_t ti;
td_thrhandle_t th;
td_err_e err;
- if (GET_LWP (pid) == 0)
- pid = BUILD_LWP (pid, pid);
+ if (GET_LWP (ptid) == 0)
+ ptid = BUILD_LWP (GET_PID (ptid), GET_PID (ptid));
- gdb_assert (is_lwp (pid));
+ gdb_assert (is_lwp (ptid));
- err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (pid), &th);
+ 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",
- GET_LWP (pid), thread_db_err_str (err));
+ 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 (pid));
+ return BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
}
-static int
-lwp_from_thread (int pid)
+static ptid_t
+lwp_from_thread (ptid_t ptid)
{
td_thrinfo_t ti;
td_thrhandle_t th;
td_err_e err;
- if (! is_thread (pid))
- return pid;
+ if (!is_thread (ptid))
+ return ptid;
- err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (pid), &th);
+ 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 (pid), thread_db_err_str (err));
+ (long) GET_THREAD (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 ("lwp_from_thread: cannot get thread info: %s",
+ thread_db_err_str (err));
- return BUILD_LWP (ti.ti_lid, GET_PID (pid));
+ return BUILD_LWP (ti.ti_lid, GET_PID (ptid));
}
\f
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;
}
err = td_ta_event_addr_p (thread_agent, TD_DEATH, ¬ify);
if (err != TD_OK)
{
- warning ("Unable to get location for thread creation breakpoint: %s",
+ warning ("Unable to get location for thread death breakpoint: %s",
thread_db_err_str (err));
return;
}
check_thread_signals (void)
{
#ifdef GET_THREAD_SIGNALS
- if (! thread_signals)
+ if (!thread_signals)
{
sigset_t mask;
int i;
sigemptyset (&thread_stop_set);
sigemptyset (&thread_print_set);
- for (i = 0; i < NSIG; i++)
+ for (i = 1; i < NSIG; i++)
{
if (sigismember (&mask, i))
{
{
int i;
- for (i = 0; i < NSIG; i++)
+ for (i = 1; i < NSIG; i++)
{
if (sigismember (&thread_stop_set, i))
signal_stop_update (target_signal_from_host (i), 1);
}
static void
-thread_db_push_target (void)
+thread_db_new_objfile (struct objfile *objfile)
{
- using_thread_db = 1;
-
- /* Push this target vector. */
- push_target (&thread_db_ops);
-
- enable_thread_event_reporting ();
-}
+ td_err_e err;
-static void
-thread_db_unpush_target (void)
-{
- /* Unpush this target vector. */
- unpush_target (&thread_db_ops);
+ /* 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. */
+ if (using_thread_db)
+ {
+ gdb_assert (proc_handle.pid == 0);
+ unpush_target (&thread_db_ops);
+ using_thread_db = 0;
+ }
- using_thread_db = 0;
-}
+ keep_thread_db = 0;
-static void
-thread_db_new_objfile (struct objfile *objfile)
-{
- td_err_e err;
+ goto quit;
+ }
if (using_thread_db)
/* Nothing to do. The thread library was already detected and the
target vector was already activated. */
goto quit;
- if (objfile == NULL)
- /* Un-interesting object file. */
- goto quit;
-
- /* Initialize the structure that identifies the child process. */
- proc_handle.pid = GET_PID (inferior_pid);
+ /* Initialize the structure that identifies the child process. Note
+ that at this point there is no guarantee that we actually have a
+ child process. */
+ proc_handle.pid = GET_PID (inferior_ptid);
- /* Now attempt to open a connection to the thread library running in
- the child process. */
+ /* Now attempt to open a connection to the thread library. */
err = td_ta_new_p (&proc_handle, &thread_agent);
switch (err)
{
case TD_NOLIBTHREAD:
- /* No thread library found in the child process, probably
- because the child process isn't running yet. */
+ /* No thread library was detected. */
break;
case TD_OK:
- /* The thread library was detected in the child; we go live now! */
- thread_db_push_target ();
-
- /* Find all user-space threads. */
- err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback,
- &inferior_pid, TD_THR_ANY_STATE,
- TD_THR_LOWEST_PRIORITY, TD_SIGNO_MASK,
- TD_THR_ANY_USER_FLAGS);
- if (err != TD_OK)
- error ("Finding new threads failed: %s", thread_db_err_str (err));
+ /* The thread library was detected. Activate the thread_db target. */
+ push_target (&thread_db_ops);
+ using_thread_db = 1;
+
+ /* If the thread library was detected in the main symbol file
+ itself, we assume that the program was statically linked
+ against the thread library and well have to keep this
+ module's target vector activated until forever... Well, at
+ least until all symbols have been discarded anyway (see
+ above). */
+ if (objfile == symfile_objfile)
+ {
+ gdb_assert (proc_handle.pid == 0);
+ keep_thread_db = 1;
+ }
+
+ /* We can only poke around if there actually is a child process.
+ If there is no child process alive, postpone the steps below
+ until one has been created. */
+ if (proc_handle.pid != 0)
+ {
+ enable_thread_event_reporting ();
+ thread_db_find_new_threads ();
+ }
break;
default:
}
static void
-attach_thread (int pid, const td_thrhandle_t *th_p,
+attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
const td_thrinfo_t *ti_p, int verbose)
{
struct thread_info *tp;
check_thread_signals ();
if (verbose)
- printf_unfiltered ("[New %s]\n", target_pid_to_str (pid));
+ printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid));
/* Add the thread to GDB's thread list. */
- tp = add_thread (pid);
+ tp = add_thread (ptid);
tp->private = xmalloc (sizeof (struct private_thread_info));
tp->private->lwpid = ti_p->ti_lid;
- /* Under Linux, we have to attach to each and every thread. */
+ if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
+ return; /* A zombie thread -- do not attach. */
+
+ /* Under GNU/Linux, we have to attach to each and every thread. */
#ifdef ATTACH_LWP
- if (ti_p->ti_lid != GET_PID (pid))
- ATTACH_LWP (BUILD_LWP (ti_p->ti_lid, GET_PID (pid)), 0);
+ ATTACH_LWP (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0);
#endif
/* Enable thread event reporting for this thread. */
err = td_thr_event_enable_p (th_p, 1);
if (err != TD_OK)
error ("Cannot enable thread event reporting for %s: %s",
- target_pid_to_str (pid), thread_db_err_str (err));
+ target_pid_to_str (ptid), thread_db_err_str (err));
+}
+
+static void
+thread_db_attach (char *args, int from_tty)
+{
+ target_beneath->to_attach (args, from_tty);
+
+ /* Destroy thread info; it's no longer valid. */
+ init_thread_list ();
+
+ /* The child process is now the actual multi-threaded
+ program. Snatch its process ID... */
+ proc_handle.pid = GET_PID (inferior_ptid);
+
+ /* ...and perform the remaining initialization steps. */
+ enable_thread_event_reporting ();
+ thread_db_find_new_threads();
}
static void
-detach_thread (int pid, int verbose)
+detach_thread (ptid_t ptid, int verbose)
{
if (verbose)
- printf_unfiltered ("[%s exited]\n", target_pid_to_str (pid));
+ printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid));
}
static void
thread_db_detach (char *args, int from_tty)
{
disable_thread_event_reporting ();
- thread_db_unpush_target ();
+
+ /* There's no need to save & restore inferior_ptid here, since the
+ inferior is supposed to be survive this function call. */
+ inferior_ptid = lwp_from_thread (inferior_ptid);
+
+ /* Forget about the child's process ID. We shouldn't need it
+ anymore. */
+ proc_handle.pid = 0;
target_beneath->to_detach (args, from_tty);
}
static void
-thread_db_resume (int pid, int step, enum target_signal signo)
+thread_db_resume (ptid_t ptid, int step, enum target_signal signo)
{
- struct cleanup *old_chain = save_inferior_pid ();
+ struct cleanup *old_chain = save_inferior_ptid ();
- if (pid == -1)
- inferior_pid = lwp_from_thread (inferior_pid);
- else if (is_thread (pid))
- pid = lwp_from_thread (pid);
+ if (GET_PID (ptid) == -1)
+ inferior_ptid = lwp_from_thread (inferior_ptid);
+ else if (is_thread (ptid))
+ ptid = lwp_from_thread (ptid);
- target_beneath->to_resume (pid, step, signo);
+ target_beneath->to_resume (ptid, step, signo);
do_cleanups (old_chain);
}
the event. */
static void
-check_event (int pid)
+check_event (ptid_t ptid)
{
td_event_msg_t msg;
td_thrinfo_t ti;
CORE_ADDR stop_pc;
/* Bail out early if we're not at a thread event breakpoint. */
- stop_pc = read_pc_pid (pid) - DECR_PC_AFTER_BREAK;
+ stop_pc = read_pc_pid (ptid) - DECR_PC_AFTER_BREAK;
if (stop_pc != td_create_bp_addr && stop_pc != td_death_bp_addr)
return;
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));
- pid = BUILD_THREAD (ti.ti_tid, GET_PID (pid));
+ ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
switch (msg.event)
{
error ("Thread creation event doesn't match breakpoint.");
#endif
- if (in_thread_list (pid))
- error ("Spurious thread creation event.");
-
- attach_thread (pid, msg.th_p, &ti, 1);
+ /* 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))
+ attach_thread (ptid, msg.th_p, &ti, 1);
return;
case TD_DEATH:
error ("Thread death event doesn't match breakpoint.");
#endif
- if (! in_thread_list (pid))
+ if (!in_thread_list (ptid))
error ("Spurious thread death event.");
- detach_thread (pid, 1);
+ detach_thread (ptid, 1);
return;
default:
}
}
-static int
-thread_db_wait (int pid, struct target_waitstatus *ourstatus)
+static ptid_t
+thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
{
- extern int trap_pid;
+ extern ptid_t trap_ptid;
+
+ if (GET_PID (ptid) != -1 && is_thread (ptid))
+ ptid = lwp_from_thread (ptid);
- if (pid != -1 && is_thread (pid))
- pid = lwp_from_thread (pid);
+ ptid = target_beneath->to_wait (ptid, ourstatus);
- pid = target_beneath->to_wait (pid, ourstatus);
+ if (proc_handle.pid == 0)
+ /* The current child process isn't the actual multi-threaded
+ program yet, so don't try to do any special thread-specific
+ post-processing and bail out early. */
+ return ptid;
if (ourstatus->kind == TARGET_WAITKIND_EXITED)
- return -1;
+ return pid_to_ptid (-1);
if (ourstatus->kind == TARGET_WAITKIND_STOPPED
&& ourstatus->value.sig == TARGET_SIGNAL_TRAP)
/* Check for a thread event. */
- check_event (pid);
+ check_event (ptid);
- if (trap_pid)
- trap_pid = thread_from_lwp (trap_pid);
+ if (!ptid_equal (trap_ptid, null_ptid))
+ trap_ptid = thread_from_lwp (trap_ptid);
- return thread_from_lwp (pid);
+ return thread_from_lwp (ptid);
}
static int
thread_db_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct mem_attrib *attrib,
struct target_ops *target)
{
- struct cleanup *old_chain = save_inferior_pid ();
+ struct cleanup *old_chain = save_inferior_ptid ();
int xfer;
- if (is_thread (inferior_pid))
+ if (is_thread (inferior_ptid))
{
/* FIXME: This seems to be necessary to make sure breakpoints
are removed. */
- if (! target_thread_alive (inferior_pid))
- inferior_pid = GET_PID (inferior_pid);
+ if (!target_thread_alive (inferior_ptid))
+ inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
else
- inferior_pid = lwp_from_thread (inferior_pid);
+ inferior_ptid = lwp_from_thread (inferior_ptid);
}
- xfer = target_beneath->to_xfer_memory (memaddr, myaddr, len, write, target);
+ xfer = target_beneath->to_xfer_memory (memaddr, myaddr, len, write, attrib, target);
do_cleanups (old_chain);
return xfer;
gdb_prfpregset_t fpregset;
td_err_e err;
- if (! is_thread (inferior_pid))
+ if (!is_thread (inferior_ptid))
{
/* Pass the request to the target beneath us. */
target_beneath->to_fetch_registers (regno);
return;
}
- err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_pid), &th);
+ err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
if (err != TD_OK)
error ("Cannot find thread %ld: %s",
- (long) GET_THREAD (inferior_pid), thread_db_err_str (err));
+ (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
err = td_thr_getgregs_p (&th, gregset);
if (err != TD_OK)
error ("Cannot fetch general-purpose registers for thread %ld: %s",
- (long) GET_THREAD (inferior_pid), thread_db_err_str (err));
+ (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
err = td_thr_getfpregs_p (&th, &fpregset);
if (err != TD_OK)
error ("Cannot get floating-point registers for thread %ld: %s",
- (long) GET_THREAD (inferior_pid), thread_db_err_str (err));
+ (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
/* Note that we must call supply_gregset after calling the thread_db
routines because the thread_db routines call ps_lgetgregs and
gdb_prfpregset_t fpregset;
td_err_e err;
- if (! is_thread (inferior_pid))
+ if (!is_thread (inferior_ptid))
{
/* Pass the request to the target beneath us. */
target_beneath->to_store_registers (regno);
return;
}
- err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_pid), &th);
+ err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
if (err != TD_OK)
error ("Cannot find thread %ld: %s",
- (long) GET_THREAD (inferior_pid), thread_db_err_str (err));
+ (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
if (regno != -1)
{
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);
}
err = td_thr_setgregs_p (&th, gregset);
if (err != TD_OK)
error ("Cannot store general-purpose registers for thread %ld: %s",
- (long) GET_THREAD (inferior_pid), thread_db_err_str (err));
+ (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
err = td_thr_setfpregs_p (&th, &fpregset);
if (err != TD_OK)
error ("Cannot store floating-point registers for thread %ld: %s",
- (long) GET_THREAD (inferior_pid), thread_db_err_str (err));
+ (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
}
static void
thread_db_kill (void)
{
+ /* There's no need to save & restore inferior_ptid here, since the
+ inferior isn't supposed to survive this function call. */
+ inferior_ptid = lwp_from_thread (inferior_ptid);
target_beneath->to_kill ();
}
static void
thread_db_create_inferior (char *exec_file, char *allargs, char **env)
{
- /* We never want to actually create the inferior! If this is ever
- called, it means we were on the target stack when the user said
- "run". But we don't want to be on the new inferior's target
- stack until the libthread_db connection is ready to be made. So
- we unpush ourselves from the stack, and then invoke
- find_default_create_inferior, which will invoke the appropriate
- process_stratum target to do the create. */
+ if (!keep_thread_db)
+ {
+ unpush_target (&thread_db_ops);
+ using_thread_db = 0;
+ }
+
+ target_beneath->to_create_inferior (exec_file, allargs, env);
+}
- thread_db_unpush_target ();
+static void
+thread_db_post_startup_inferior (ptid_t ptid)
+{
+ if (proc_handle.pid == 0)
+ {
+ /* The child process is now the actual multi-threaded
+ program. Snatch its process ID... */
+ proc_handle.pid = GET_PID (ptid);
- find_default_create_inferior (exec_file, allargs, env);
+ /* ...and perform the remaining initialization steps. */
+ enable_thread_event_reporting ();
+ thread_db_find_new_threads ();
+ }
}
static void
thread_db_mourn_inferior (void)
{
remove_thread_event_breakpoints ();
- thread_db_unpush_target ();
+
+ /* Forget about the child's process ID. We shouldn't need it
+ anymore. */
+ proc_handle.pid = 0;
target_beneath->to_mourn_inferior ();
}
static int
-thread_db_thread_alive (int pid)
+thread_db_thread_alive (ptid_t ptid)
{
- if (is_thread (pid))
- {
- td_thrhandle_t th;
- td_err_e err;
+ td_thrhandle_t th;
+ td_thrinfo_t ti;
+ td_err_e err;
- err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (pid), &th);
+ if (is_thread (ptid))
+ {
+ err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
if (err != TD_OK)
return 0;
if (err != TD_OK)
return 0;
+ err = td_thr_get_info_p (&th, &ti);
+ if (err != TD_OK)
+ return 0;
+
+ if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
+ return 0; /* A zombie thread. */
+
return 1;
}
if (target_beneath->to_thread_alive)
- return target_beneath->to_thread_alive (pid);
+ return target_beneath->to_thread_alive (ptid);
return 0;
}
{
td_thrinfo_t ti;
td_err_e err;
- int pid;
+ ptid_t ptid;
err = td_thr_get_info_p (th_p, &ti);
if (err != TD_OK)
- error ("Cannot get thread info: %s", thread_db_err_str (err));
+ error ("find_new_threads_callback: cannot get thread info: %s",
+ thread_db_err_str (err));
- pid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_pid));
+ if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
+ return 0; /* A zombie -- ignore. */
- if (! in_thread_list (pid))
- attach_thread (pid, th_p, &ti, 1);
+ ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid));
+
+ if (!in_thread_list (ptid))
+ attach_thread (ptid, th_p, &ti, 1);
return 0;
}
}
static char *
-thread_db_pid_to_str (int pid)
+thread_db_pid_to_str (ptid_t ptid)
{
- if (is_thread (pid))
+ if (is_thread (ptid))
{
static char buf[64];
td_thrhandle_t th;
td_thrinfo_t ti;
td_err_e err;
- err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (pid), &th);
+ 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 (pid), thread_db_err_str (err));
+ (long) GET_THREAD (ptid), thread_db_err_str (err));
err = td_thr_get_info_p (&th, &ti);
if (err != TD_OK)
- error ("Cannot get thread info for thread %ld: %s",
- (long) GET_THREAD (pid), thread_db_err_str (err));
+ 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 buf;
}
- if (target_beneath->to_pid_to_str (pid))
- return target_beneath->to_pid_to_str (pid);
+ if (target_beneath->to_pid_to_str (ptid))
+ return target_beneath->to_pid_to_str (ptid);
+
+ 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);
- return normal_pid_to_str (pid);
+ error ("Cannot find thread-local values on this target.");
}
static void
thread_db_ops.to_shortname = "multi-thread";
thread_db_ops.to_longname = "multi-threaded child process.";
thread_db_ops.to_doc = "Threads and pthreads support.";
+ thread_db_ops.to_attach = thread_db_attach;
thread_db_ops.to_detach = thread_db_detach;
thread_db_ops.to_resume = thread_db_resume;
thread_db_ops.to_wait = thread_db_wait;
thread_db_ops.to_xfer_memory = thread_db_xfer_memory;
thread_db_ops.to_kill = thread_db_kill;
thread_db_ops.to_create_inferior = thread_db_create_inferior;
+ thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior;
thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
thread_db_ops.to_thread_alive = thread_db_thread_alive;
thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
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