/* libthread_db assisted debugging support, generic parts.
- Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ Copyright 1999, 2000, 2001, 2003, 2004 Free Software Foundation, Inc.
This file is part of GDB.
#include "regcache.h"
#include "solib-svr4.h"
+#ifdef HAVE_GNU_LIBC_VERSION_H
+#include <gnu/libc-version.h>
+#endif
+
#ifndef LIBTHREAD_DB_SO
#define LIBTHREAD_DB_SO "libthread_db.so.1"
#endif
static struct target_ops *target_beneath;
/* Pointer to the next function on the objfile event chain. */
-static void (*target_new_objfile_chain) (struct objfile *objfile);
+static void (*target_new_objfile_chain) (struct objfile * objfile);
/* 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;
static td_err_e (*td_init_p) (void);
-static td_err_e (*td_ta_new_p) (struct ps_prochandle *ps, td_thragent_t **ta);
+static td_err_e (*td_ta_new_p) (struct ps_prochandle * ps,
+ td_thragent_t **ta);
static td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
td_thrhandle_t *__th);
-static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta, lwpid_t lwpid,
- td_thrhandle_t *th);
+static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta,
+ lwpid_t lwpid, td_thrhandle_t *th);
static td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
- td_thr_iter_f *callback,
- void *cbdata_p, td_thr_state_e state,
- int ti_pri, sigset_t *ti_sigmask_p,
+ td_thr_iter_f *callback, void *cbdata_p,
+ td_thr_state_e state, int ti_pri,
+ sigset_t *ti_sigmask_p,
unsigned int ti_user_flags);
static td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
td_event_e event, td_notify_t *ptr);
const gdb_prfpregset_t *fpregs);
static td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th,
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_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);
+ 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
/* Prototypes for local functions. */
static void thread_db_find_new_threads (void);
+static void attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
+ const td_thrinfo_t *ti_p, int verbose);
+static void detach_thread (ptid_t ptid, int verbose);
\f
/* Building process ids. */
#define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
\f
+/* Use "struct private_thread_info" to cache thread state. This is
+ a substantial optimization. */
+
struct private_thread_info
{
- /* Cached LWP id. Must come first, see lin-lwp.c. */
- lwpid_t lwpid;
+ /* Flag set when we see a TD_DEATH event for this thread. */
+ unsigned int dying:1;
+
+ /* Cached thread state. */
+ unsigned int th_valid:1;
+ unsigned int ti_valid:1;
+
+ td_thrhandle_t th;
+ td_thrinfo_t ti;
};
\f
}
}
\f
+/* A callback function for td_ta_thr_iter, which we use to map all
+ threads to LWPs.
+
+ THP is a handle to the current thread; if INFOP is not NULL, the
+ struct thread_info associated with this thread is returned in
+ *INFOP.
+
+ If the thread is a zombie, TD_THR_ZOMBIE is returned. Otherwise,
+ zero is returned to indicate success. */
+
+static int
+thread_get_info_callback (const td_thrhandle_t *thp, void *infop)
+{
+ td_thrinfo_t ti;
+ td_err_e err;
+ struct thread_info *thread_info;
+ ptid_t thread_ptid;
+
+ err = td_thr_get_info_p (thp, &ti);
+ if (err != TD_OK)
+ error ("thread_get_info_callback: cannot get thread info: %s",
+ thread_db_err_str (err));
+
+ /* Fill the cache. */
+ thread_ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid));
+ thread_info = find_thread_pid (thread_ptid);
+
+ /* In the case of a zombie thread, don't continue. We don't want to
+ attach to it thinking it is a new thread. */
+ if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
+ {
+ if (infop != NULL)
+ *(struct thread_info **) infop = thread_info;
+ if (thread_info != NULL)
+ {
+ memcpy (&thread_info->private->th, thp, sizeof (*thp));
+ thread_info->private->th_valid = 1;
+ memcpy (&thread_info->private->ti, &ti, sizeof (ti));
+ thread_info->private->ti_valid = 1;
+ }
+ return TD_THR_ZOMBIE;
+ }
+
+ if (thread_info == NULL)
+ {
+ /* New thread. Attach to it now (why wait?). */
+ attach_thread (thread_ptid, thp, &ti, 1);
+ thread_info = find_thread_pid (thread_ptid);
+ gdb_assert (thread_info != NULL);
+ }
+
+ memcpy (&thread_info->private->th, thp, sizeof (*thp));
+ thread_info->private->th_valid = 1;
+ memcpy (&thread_info->private->ti, &ti, sizeof (ti));
+ thread_info->private->ti_valid = 1;
+
+ if (infop != NULL)
+ *(struct thread_info **) infop = thread_info;
+
+ return 0;
+}
+
+/* Accessor functions for the thread_db information, with caching. */
+
+static void
+thread_db_map_id2thr (struct thread_info *thread_info, int fatal)
+{
+ td_err_e err;
+
+ if (thread_info->private->th_valid)
+ return;
+
+ err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (thread_info->ptid),
+ &thread_info->private->th);
+ if (err != TD_OK)
+ {
+ if (fatal)
+ error ("Cannot find thread %ld: %s",
+ (long) GET_THREAD (thread_info->ptid),
+ thread_db_err_str (err));
+ }
+ else
+ thread_info->private->th_valid = 1;
+}
+
+static td_thrinfo_t *
+thread_db_get_info (struct thread_info *thread_info)
+{
+ td_err_e err;
+
+ if (thread_info->private->ti_valid)
+ return &thread_info->private->ti;
+
+ if (!thread_info->private->th_valid)
+ thread_db_map_id2thr (thread_info, 1);
+ err =
+ td_thr_get_info_p (&thread_info->private->th, &thread_info->private->ti);
+ if (err != TD_OK)
+ error ("thread_db_get_info: cannot get thread info: %s",
+ thread_db_err_str (err));
+
+ thread_info->private->ti_valid = 1;
+ return &thread_info->private->ti;
+}
+\f
/* Convert between user-level thread ids and LWP ids. */
static ptid_t
thread_from_lwp (ptid_t ptid)
{
- td_thrinfo_t ti;
td_thrhandle_t th;
td_err_e err;
+ struct thread_info *thread_info;
+ ptid_t thread_ptid;
if (GET_LWP (ptid) == 0)
ptid = BUILD_LWP (GET_PID (ptid), GET_PID (ptid));
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));
+ thread_info = NULL;
+
+ /* Fetch the thread info. If we get back TD_THR_ZOMBIE, then the
+ event thread has already died. If another gdb interface has called
+ thread_alive() previously, the thread won't be found on the thread list
+ anymore. In that case, we don't want to process this ptid anymore
+ to avoid the possibility of later treating it as a newly
+ discovered thread id that we should add to the list. Thus,
+ we return a -1 ptid which is also how the thread list marks a
+ dead thread. */
+ if (thread_get_info_callback (&th, &thread_info) == TD_THR_ZOMBIE
+ && thread_info == NULL)
+ return pid_to_ptid (-1);
+
+ gdb_assert (thread_info && thread_info->private->ti_valid);
- return BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
+ return BUILD_THREAD (thread_info->private->ti.ti_tid, GET_PID (ptid));
}
static ptid_t
lwp_from_thread (ptid_t ptid)
{
- td_thrinfo_t ti;
- td_thrhandle_t th;
- td_err_e err;
+ struct thread_info *thread_info;
+ ptid_t thread_ptid;
if (!is_thread (ptid))
return ptid;
- 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));
+ thread_info = find_thread_pid (ptid);
+ thread_db_get_info (thread_info);
- err = td_thr_get_info_p (&th, &ti);
- if (err != TD_OK)
- error ("Cannot get thread info: %s", thread_db_err_str (err));
-
- return BUILD_LWP (ti.ti_lid, GET_PID (ptid));
+ return BUILD_LWP (thread_info->private->ti.ti_lid, GET_PID (ptid));
}
\f
target_beneath = target;
}
+static void *
+verbose_dlsym (void *handle, const char *name)
+{
+ void *sym = dlsym (handle, name);
+ if (sym == NULL)
+ warning ("Symbol \"%s\" not found in libthread_db: %s", name, dlerror ());
+ return sym;
+}
+
static int
thread_db_load (void)
{
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_init_p = dlsym (handle, "td_init");
+ td_init_p = verbose_dlsym (handle, "td_init");
if (td_init_p == NULL)
return 0;
- td_ta_new_p = dlsym (handle, "td_ta_new");
+ td_ta_new_p = verbose_dlsym (handle, "td_ta_new");
if (td_ta_new_p == NULL)
return 0;
- td_ta_map_id2thr_p = dlsym (handle, "td_ta_map_id2thr");
+ td_ta_map_id2thr_p = verbose_dlsym (handle, "td_ta_map_id2thr");
if (td_ta_map_id2thr_p == NULL)
return 0;
- td_ta_map_lwp2thr_p = dlsym (handle, "td_ta_map_lwp2thr");
+ td_ta_map_lwp2thr_p = verbose_dlsym (handle, "td_ta_map_lwp2thr");
if (td_ta_map_lwp2thr_p == NULL)
return 0;
- td_ta_thr_iter_p = dlsym (handle, "td_ta_thr_iter");
+ td_ta_thr_iter_p = verbose_dlsym (handle, "td_ta_thr_iter");
if (td_ta_thr_iter_p == NULL)
return 0;
- td_thr_validate_p = dlsym (handle, "td_thr_validate");
+ td_thr_validate_p = verbose_dlsym (handle, "td_thr_validate");
if (td_thr_validate_p == NULL)
return 0;
- td_thr_get_info_p = dlsym (handle, "td_thr_get_info");
+ td_thr_get_info_p = verbose_dlsym (handle, "td_thr_get_info");
if (td_thr_get_info_p == NULL)
return 0;
- td_thr_getfpregs_p = dlsym (handle, "td_thr_getfpregs");
+ td_thr_getfpregs_p = verbose_dlsym (handle, "td_thr_getfpregs");
if (td_thr_getfpregs_p == NULL)
return 0;
- td_thr_getgregs_p = dlsym (handle, "td_thr_getgregs");
+ td_thr_getgregs_p = verbose_dlsym (handle, "td_thr_getgregs");
if (td_thr_getgregs_p == NULL)
return 0;
- td_thr_setfpregs_p = dlsym (handle, "td_thr_setfpregs");
+ td_thr_setfpregs_p = verbose_dlsym (handle, "td_thr_setfpregs");
if (td_thr_setfpregs_p == NULL)
return 0;
- td_thr_setgregs_p = dlsym (handle, "td_thr_setgregs");
+ td_thr_setgregs_p = verbose_dlsym (handle, "td_thr_setgregs");
if (td_thr_setgregs_p == NULL)
return 0;
return 1;
}
+static td_err_e
+enable_thread_event (td_thragent_t *thread_agent, int event, CORE_ADDR *bp)
+{
+ td_notify_t notify;
+ td_err_e err;
+
+ /* Get the breakpoint address for thread EVENT. */
+ err = td_ta_event_addr_p (thread_agent, event, ¬ify);
+ if (err != TD_OK)
+ return err;
+
+ /* Set up the breakpoint. */
+ (*bp) = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+ (CORE_ADDR) notify.u.bptaddr,
+ ¤t_target);
+ create_thread_event_breakpoint ((*bp));
+
+ return TD_OK;
+}
+
static void
enable_thread_event_reporting (void)
{
td_thr_events_t events;
td_notify_t notify;
td_err_e err;
+#ifdef HAVE_GNU_LIBC_VERSION_H
+ const char *libc_version;
+ int libc_major, libc_minor;
+#endif
/* We cannot use the thread event reporting facility if these
functions aren't available. */
/* Set the process wide mask saying which events we're interested in. */
td_event_emptyset (&events);
td_event_addset (&events, TD_CREATE);
-#if 0
+
+#ifdef HAVE_GNU_LIBC_VERSION_H
/* FIXME: kettenis/2000-04-23: The event reporting facility is
broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
now. */
- td_event_addset (&events, TD_DEATH);
+ libc_version = gnu_get_libc_version ();
+ if (sscanf (libc_version, "%d.%d", &libc_major, &libc_minor) == 2
+ && (libc_major > 2 || (libc_major == 2 && libc_minor > 1)))
#endif
+ td_event_addset (&events, TD_DEATH);
err = td_ta_set_event_p (thread_agent, &events);
if (err != TD_OK)
/* Delete previous thread event breakpoints, if any. */
remove_thread_event_breakpoints ();
+ td_create_bp_addr = 0;
+ td_death_bp_addr = 0;
- /* Get address for thread creation breakpoint. */
- err = td_ta_event_addr_p (thread_agent, TD_CREATE, ¬ify);
+ /* Set up the thread creation event. */
+ err = enable_thread_event (thread_agent, TD_CREATE, &td_create_bp_addr);
if (err != TD_OK)
{
warning ("Unable to get location for thread creation breakpoint: %s",
return;
}
- /* Set up the breakpoint. */
- td_create_bp_addr = (CORE_ADDR) notify.u.bptaddr;
- create_thread_event_breakpoint (td_create_bp_addr);
-
- /* Get address for thread death breakpoint. */
- err = td_ta_event_addr_p (thread_agent, TD_DEATH, ¬ify);
+ /* Set up the thread death event. */
+ err = enable_thread_event (thread_agent, TD_DEATH, &td_death_bp_addr);
if (err != TD_OK)
{
warning ("Unable to get location for thread death breakpoint: %s",
thread_db_err_str (err));
return;
}
-
- /* Set up the breakpoint. */
- td_death_bp_addr = (CORE_ADDR) notify.u.bptaddr;
- create_thread_event_breakpoint (td_death_bp_addr);
}
static void
#endif
}
-static void
-disable_thread_signals (void)
-{
-#ifdef GET_THREAD_SIGNALS
- if (thread_signals)
- {
- int i;
-
- for (i = 1; i < NSIG; i++)
- {
- if (sigismember (&thread_stop_set, i))
- signal_stop_update (target_signal_from_host (i), 1);
- if (sigismember (&thread_print_set, i))
- signal_print_update (target_signal_from_host (i), 1);
- }
-
- thread_signals = 0;
- }
-#endif
-}
-
static void
thread_db_new_objfile (struct objfile *objfile)
{
td_err_e err;
+ /* First time through, report that libthread_db was successfuly
+ loaded. Can't print this in in thread_db_load as, at that stage,
+ the interpreter and it's console haven't started. The real
+ problem here is that libthread_db is loaded too early - it should
+ only be loaded when there is a program to debug. */
+ {
+ static int dejavu;
+ if (!dejavu)
+ {
+ Dl_info info;
+ const char *library = NULL;
+ /* Try dladdr. */
+ if (dladdr ((*td_ta_new_p), &info) != 0)
+ library = info.dli_fname;
+ /* Try dlinfo? */
+ if (library == NULL)
+ /* Paranoid - don't let a NULL path slip through. */
+ library = LIBTHREAD_DB_SO;
+ printf_unfiltered ("Using host libthread_db library \"%s\".\n",
+ library);
+ dejavu = 1;
+ }
+ }
+
/* Don't attempt to use thread_db on targets which can not run
(core files). */
if (objfile == NULL || !target_has_execution)
using_thread_db = 0;
}
- keep_thread_db = 0;
-
goto quit;
}
break;
case TD_OK:
+ printf_unfiltered ("[Thread debugging using libthread_db enabled]\n");
+
/* 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. */
break;
}
- quit:
+quit:
if (target_new_objfile_chain)
target_new_objfile_chain (objfile);
}
+/* Attach to a new thread. This function is called when we receive a
+ TD_CREATE event or when we iterate over all threads and find one
+ that wasn't already in our list. */
+
static void
attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
const td_thrinfo_t *ti_p, int verbose)
struct thread_info *tp;
td_err_e err;
- check_thread_signals ();
+ /* If we're being called after a TD_CREATE event, we may already
+ know about this thread. There are two ways this can happen. We
+ may have iterated over all threads between the thread creation
+ and the TD_CREATE event, for instance when the user has issued
+ the `info threads' command before the SIGTRAP for hitting the
+ thread creation breakpoint was reported. Alternatively, the
+ thread may have exited and a new one been created with the same
+ thread ID. In the first case we don't need to do anything; in
+ the second case we should discard information about the dead
+ thread and attach to the new one. */
+ if (in_thread_list (ptid))
+ {
+ tp = find_thread_pid (ptid);
+ gdb_assert (tp != NULL);
- if (verbose)
- printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid));
+ if (!tp->private->dying)
+ return;
+
+ delete_thread (ptid);
+ }
+
+ check_thread_signals ();
/* Add the thread to GDB's thread list. */
tp = add_thread (ptid);
tp->private = xmalloc (sizeof (struct private_thread_info));
- tp->private->lwpid = ti_p->ti_lid;
+ memset (tp->private, 0, sizeof (struct private_thread_info));
+
+ if (verbose)
+ printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid));
if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
return; /* A zombie thread -- do not attach. */
/* ...and perform the remaining initialization steps. */
enable_thread_event_reporting ();
- thread_db_find_new_threads();
+ thread_db_find_new_threads ();
}
static void
detach_thread (ptid_t ptid, int verbose)
{
+ struct thread_info *thread_info;
+
if (verbose)
printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid));
+
+ /* Don't delete the thread now, because it still reports as active
+ until it has executed a few instructions after the event
+ breakpoint - if we deleted it now, "info threads" would cause us
+ to re-attach to it. Just mark it as having had a TD_DEATH
+ event. This means that we won't delete it from our thread list
+ until we notice that it's dead (via prune_threads), or until
+ something re-uses its thread ID. */
+ thread_info = find_thread_pid (ptid);
+ gdb_assert (thread_info != NULL);
+ thread_info->private->dying = 1;
}
static void
target_beneath->to_detach (args, from_tty);
}
+static int
+clear_lwpid_callback (struct thread_info *thread, void *dummy)
+{
+ /* If we know that our thread implementation is 1-to-1, we could save
+ a certain amount of information; it's not clear how much, so we
+ are always conservative. */
+
+ thread->private->th_valid = 0;
+ thread->private->ti_valid = 0;
+
+ return 0;
+}
+
static void
thread_db_resume (ptid_t ptid, int step, enum target_signal signo)
{
else if (is_thread (ptid))
ptid = lwp_from_thread (ptid);
+ /* Clear cached data which may not be valid after the resume. */
+ iterate_over_threads (clear_lwpid_callback, NULL);
+
target_beneath->to_resume (ptid, step, signo);
do_cleanups (old_chain);
td_thrinfo_t ti;
td_err_e err;
CORE_ADDR stop_pc;
+ int loop = 0;
/* Bail out early if we're not at a thread event breakpoint. */
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_ta_event_getmsg_p (thread_agent, &msg);
- if (err != TD_OK)
+ /* If we are at a create breakpoint, we do not know what new lwp
+ was created and cannot specifically locate the event message for it.
+ We have to call td_ta_event_getmsg() to get
+ the latest message. Since we have no way of correlating whether
+ the event message we get back corresponds to our breakpoint, we must
+ loop and read all event messages, processing them appropriately.
+ This guarantees we will process the correct message before continuing
+ from the breakpoint.
+
+ Currently, death events are not enabled. If they are enabled,
+ the death event can use the td_thr_event_getmsg() interface to
+ get the message specifically for that lwp and avoid looping
+ below. */
+
+ loop = 1;
+
+ do
{
- if (err == TD_NOMSG)
- return;
+ err = td_ta_event_getmsg_p (thread_agent, &msg);
+ if (err != TD_OK)
+ {
+ if (err == TD_NOMSG)
+ return;
- error ("Cannot get thread event message: %s", thread_db_err_str (err));
- }
+ error ("Cannot get thread event message: %s",
+ thread_db_err_str (err));
+ }
- 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));
+ 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));
- ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
+ ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
- switch (msg.event)
- {
- case TD_CREATE:
-#if 0
- /* FIXME: kettenis/2000-08-26: Since we use td_ta_event_getmsg,
- there is no guarantee that the breakpoint will match the
- event. Should we use td_thr_event_getmsg instead? */
-
- if (stop_pc != td_create_bp_addr)
- error ("Thread creation event doesn't match breakpoint.");
-#endif
+ switch (msg.event)
+ {
+ case TD_CREATE:
+ /* Call attach_thread whether or not we already know about a
+ thread with this thread ID. */
+ attach_thread (ptid, 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;
+ break;
- case TD_DEATH:
-#if 0
- /* FIXME: See TD_CREATE. */
+ case TD_DEATH:
- if (stop_pc != td_death_bp_addr)
- error ("Thread death event doesn't match breakpoint.");
-#endif
+ if (!in_thread_list (ptid))
+ error ("Spurious thread death event.");
- if (!in_thread_list (ptid))
- error ("Spurious thread death event.");
+ detach_thread (ptid, 1);
- detach_thread (ptid, 1);
- return;
+ break;
- default:
- error ("Spurious thread event.");
+ default:
+ error ("Spurious thread event.");
+ }
}
+ while (loop);
}
static ptid_t
if (!ptid_equal (trap_ptid, null_ptid))
trap_ptid = thread_from_lwp (trap_ptid);
- return thread_from_lwp (ptid);
+ /* Change the ptid back into the higher level PID + TID format.
+ If the thread is dead and no longer on the thread list, we will
+ get back a dead ptid. This can occur if the thread death event
+ gets postponed by other simultaneous events. In such a case,
+ we want to just ignore the event and continue on. */
+ ptid = thread_from_lwp (ptid);
+ if (GET_PID (ptid) == -1)
+ ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+
+ return 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 mem_attrib *attrib, struct target_ops *target)
{
struct cleanup *old_chain = save_inferior_ptid ();
int xfer;
inferior_ptid = lwp_from_thread (inferior_ptid);
}
- xfer = target_beneath->to_xfer_memory (memaddr, myaddr, len, write, attrib, target);
+ xfer =
+ target_beneath->to_xfer_memory (memaddr, myaddr, len, write, attrib,
+ target);
do_cleanups (old_chain);
return xfer;
static void
thread_db_fetch_registers (int regno)
{
- td_thrhandle_t th;
+ struct thread_info *thread_info;
prgregset_t gregset;
gdb_prfpregset_t fpregset;
td_err_e err;
return;
}
- 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_ptid), thread_db_err_str (err));
+ thread_info = find_thread_pid (inferior_ptid);
+ thread_db_map_id2thr (thread_info, 1);
- err = td_thr_getgregs_p (&th, gregset);
+ err = td_thr_getgregs_p (&thread_info->private->th, gregset);
if (err != TD_OK)
error ("Cannot fetch general-purpose registers for thread %ld: %s",
(long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
- err = td_thr_getfpregs_p (&th, &fpregset);
+ err = td_thr_getfpregs_p (&thread_info->private->th, &fpregset);
if (err != TD_OK)
error ("Cannot get floating-point registers for thread %ld: %s",
(long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
static void
thread_db_store_registers (int regno)
{
- td_thrhandle_t th;
prgregset_t gregset;
gdb_prfpregset_t fpregset;
td_err_e err;
+ struct thread_info *thread_info;
if (!is_thread (inferior_ptid))
{
return;
}
- 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_ptid), thread_db_err_str (err));
+ thread_info = find_thread_pid (inferior_ptid);
+ thread_db_map_id2thr (thread_info, 1);
if (regno != -1)
{
- char raw[MAX_REGISTER_RAW_SIZE];
+ char raw[MAX_REGISTER_SIZE];
deprecated_read_register_gen (regno, raw);
thread_db_fetch_registers (-1);
- supply_register (regno, raw);
+ regcache_raw_supply (current_regcache, regno, raw);
}
fill_gregset ((gdb_gregset_t *) gregset, -1);
fill_fpregset (&fpregset, -1);
- err = td_thr_setgregs_p (&th, gregset);
+ err = td_thr_setgregs_p (&thread_info->private->th, gregset);
if (err != TD_OK)
error ("Cannot store general-purpose registers for thread %ld: %s",
(long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
- err = td_thr_setfpregs_p (&th, &fpregset);
+ err = td_thr_setfpregs_p (&thread_info->private->th, &fpregset);
if (err != TD_OK)
error ("Cannot store floating-point registers for thread %ld: %s",
(long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
}
static void
-thread_db_create_inferior (char *exec_file, char *allargs, char **env)
+thread_db_create_inferior (char *exec_file, char *allargs, char **env,
+ int from_tty)
{
- if (!keep_thread_db)
- {
- unpush_target (&thread_db_ops);
- using_thread_db = 0;
- }
-
- target_beneath->to_create_inferior (exec_file, allargs, env);
+ unpush_target (&thread_db_ops);
+ using_thread_db = 0;
+ target_beneath->to_create_inferior (exec_file, allargs, env, from_tty);
}
static void
proc_handle.pid = 0;
target_beneath->to_mourn_inferior ();
+
+ /* Detach thread_db target ops. */
+ unpush_target (&thread_db_ops);
+ using_thread_db = 0;
}
static int
thread_db_thread_alive (ptid_t ptid)
{
td_thrhandle_t th;
- td_thrinfo_t ti;
td_err_e err;
if (is_thread (ptid))
{
- err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
- if (err != TD_OK)
- return 0;
+ struct thread_info *thread_info;
+ thread_info = find_thread_pid (ptid);
- err = td_thr_validate_p (&th);
- if (err != TD_OK)
+ thread_db_map_id2thr (thread_info, 0);
+ if (!thread_info->private->th_valid)
return 0;
- err = td_thr_get_info_p (&th, &ti);
+ err = td_thr_validate_p (&thread_info->private->th);
if (err != TD_OK)
return 0;
- if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
+ if (!thread_info->private->ti_valid)
+ {
+ err =
+ td_thr_get_info_p (&thread_info->private->th,
+ &thread_info->private->ti);
+ if (err != TD_OK)
+ return 0;
+ thread_info->private->ti_valid = 1;
+ }
+
+ if (thread_info->private->ti.ti_state == TD_THR_UNKNOWN
+ || thread_info->private->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));
+ error ("find_new_threads_callback: cannot get thread info: %s",
+ thread_db_err_str (err));
if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
return 0; /* A zombie -- ignore. */
if (is_thread (ptid))
{
static char buf[64];
- td_thrhandle_t th;
- td_thrinfo_t ti;
+ td_thrinfo_t *ti_p;
td_err_e err;
+ struct thread_info *thread_info;
- 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));
+ thread_info = find_thread_pid (ptid);
+ thread_db_map_id2thr (thread_info, 0);
+ if (!thread_info->private->th_valid)
+ {
+ snprintf (buf, sizeof (buf), "Thread %ld (Missing)",
+ GET_THREAD (ptid));
+ return buf;
+ }
- err = td_thr_get_info_p (&th, &ti);
- if (err != TD_OK)
- error ("Cannot get thread info for thread %ld: %s",
- (long) GET_THREAD (ptid), thread_db_err_str (err));
+ ti_p = thread_db_get_info (thread_info);
- if (ti.ti_state == TD_THR_ACTIVE && ti.ti_lid != 0)
+ if (ti_p->ti_state == TD_THR_ACTIVE && ti_p->ti_lid != 0)
{
snprintf (buf, sizeof (buf), "Thread %ld (LWP %d)",
- (long) ti.ti_tid, ti.ti_lid);
+ (long) ti_p->ti_tid, ti_p->ti_lid);
}
else
{
snprintf (buf, sizeof (buf), "Thread %ld (%s)",
- (long) ti.ti_tid, thread_db_state_str (ti.ti_state));
+ (long) ti_p->ti_tid,
+ thread_db_state_str (ti_p->ti_state));
}
return buf;
static CORE_ADDR
thread_db_get_thread_local_address (ptid_t ptid, struct objfile *objfile,
- CORE_ADDR offset)
+ 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;
+ struct thread_info *thread_info;
/* glibc doesn't provide the needed interface. */
- if (! td_thr_tls_get_addr_p)
- error ("Cannot find thread-local variables in this thread library.");
+ 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"
+ {
+ 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"
+ 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));
-
+ thread_info = find_thread_pid (ptid);
+ thread_db_map_id2thr (thread_info, 1);
+
/* Finally, get the address of the variable. */
- err = td_thr_tls_get_addr_p (&th, (void *) lm, offset, &address);
+ err = td_thr_tls_get_addr_p (&thread_info->private->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",
+ {
+ /* 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",
+ 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
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));
+ 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));
+ objfile->name, thread_db_err_str (err));
}
/* Cast assuming host == target. Joy. */
}
if (target_beneath->to_get_thread_local_address)
- return target_beneath->to_get_thread_local_address (ptid, objfile, offset);
+ return target_beneath->to_get_thread_local_address (ptid, objfile,
+ offset);
error ("Cannot find thread-local values on this target.");
}
add_target (&thread_db_ops);
/* Add ourselves to objfile event chain. */
- target_new_objfile_chain = target_new_objfile_hook;
- target_new_objfile_hook = thread_db_new_objfile;
+ target_new_objfile_chain = deprecated_target_new_objfile_hook;
+ deprecated_target_new_objfile_hook = thread_db_new_objfile;
}
}