X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Flinux-thread-db.c;h=536170e37207e00170ef604b7ebabc8d26e0e497;hb=e5cc6d1129fca9be54457c858449fdef17405fa7;hp=65d9fd51b89f93c7183fde7623b2cafb655db520;hpb=ed89d175425862691f715f2103d7f857826f5d6f;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/linux-thread-db.c b/gdb/linux-thread-db.c index 65d9fd51b8..536170e372 100644 --- a/gdb/linux-thread-db.c +++ b/gdb/linux-thread-db.c @@ -1,6 +1,7 @@ /* libthread_db assisted debugging support, generic parts. - Copyright 1999, 2000, 2001, 2003, 2004 Free Software Foundation, Inc. + Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005 + Free Software Foundation, Inc. This file is part of GDB. @@ -16,8 +17,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "defs.h" @@ -27,6 +28,7 @@ #include "gdb_thread_db.h" #include "bfd.h" +#include "exceptions.h" #include "gdbthread.h" #include "inferior.h" #include "symfile.h" @@ -34,6 +36,7 @@ #include "target.h" #include "regcache.h" #include "solib-svr4.h" +#include "gdbcore.h" #ifdef HAVE_GNU_LIBC_VERSION_H #include @@ -143,7 +146,6 @@ static void detach_thread (ptid_t ptid, int verbose); #define is_thread(ptid) (GET_THREAD (ptid) != 0) #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0) -#define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid) /* Use "struct private_thread_info" to cache thread state. This is @@ -263,11 +265,11 @@ thread_get_info_callback (const td_thrhandle_t *thp, void *infop) err = td_thr_get_info_p (thp, &ti); if (err != TD_OK) - error ("thread_get_info_callback: cannot get thread info: %s", + 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_ptid = ptid_build (GET_PID (inferior_ptid), ti.ti_lid, ti.ti_tid); thread_info = find_thread_pid (thread_ptid); /* In the case of a zombie thread, don't continue. We don't want to @@ -320,7 +322,7 @@ thread_db_map_id2thr (struct thread_info *thread_info, int fatal) if (err != TD_OK) { if (fatal) - error ("Cannot find thread %ld: %s", + error (_("Cannot find thread %ld: %s"), (long) GET_THREAD (thread_info->ptid), thread_db_err_str (err)); } @@ -342,7 +344,7 @@ thread_db_get_info (struct thread_info *thread_info) 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", + error (_("thread_db_get_info: cannot get thread info: %s"), thread_db_err_str (err)); thread_info->private->ti_valid = 1; @@ -366,7 +368,7 @@ thread_from_lwp (ptid_t ptid) err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th); if (err != TD_OK) - error ("Cannot find user-level thread for LWP %ld: %s", + error (_("Cannot find user-level thread for LWP %ld: %s"), GET_LWP (ptid), thread_db_err_str (err)); thread_info = NULL; @@ -385,22 +387,14 @@ thread_from_lwp (ptid_t ptid) gdb_assert (thread_info && thread_info->private->ti_valid); - return BUILD_THREAD (thread_info->private->ti.ti_tid, GET_PID (ptid)); + return ptid_build (GET_PID (ptid), GET_LWP (ptid), + thread_info->private->ti.ti_tid); } static ptid_t lwp_from_thread (ptid_t ptid) { - struct thread_info *thread_info; - ptid_t thread_ptid; - - if (!is_thread (ptid)) - return ptid; - - thread_info = find_thread_pid (ptid); - thread_db_get_info (thread_info); - - return BUILD_LWP (thread_info->private->ti.ti_lid, GET_PID (ptid)); + return BUILD_LWP (GET_LWP (ptid), GET_PID (ptid)); } @@ -415,7 +409,7 @@ 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 ()); + warning (_("Symbol \"%s\" not found in libthread_db: %s"), name, dlerror ()); return sym; } @@ -486,7 +480,7 @@ thread_db_load (void) err = td_init_p (); if (err != TD_OK) { - warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err)); + warning (_("Cannot initialize libthread_db: %s"), thread_db_err_str (err)); return 0; } @@ -512,9 +506,14 @@ enable_thread_event (td_thragent_t *thread_agent, int event, CORE_ADDR *bp) return err; /* Set up the breakpoint. */ - (*bp) = gdbarch_convert_from_func_ptr_addr (current_gdbarch, - (CORE_ADDR) notify.u.bptaddr, - ¤t_target); + gdb_assert (exec_bfd); + (*bp) = (gdbarch_convert_from_func_ptr_addr + (current_gdbarch, + /* Do proper sign extension for the target. */ + (bfd_get_sign_extend_vma (exec_bfd) > 0 + ? (CORE_ADDR) (intptr_t) notify.u.bptaddr + : (CORE_ADDR) (uintptr_t) notify.u.bptaddr), + ¤t_target)); create_thread_event_breakpoint ((*bp)); return TD_OK; @@ -554,7 +553,7 @@ enable_thread_event_reporting (void) err = td_ta_set_event_p (thread_agent, &events); if (err != TD_OK) { - warning ("Unable to set global thread event mask: %s", + warning (_("Unable to set global thread event mask: %s"), thread_db_err_str (err)); return; } @@ -568,7 +567,7 @@ enable_thread_event_reporting (void) 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", + warning (_("Unable to get location for thread creation breakpoint: %s"), thread_db_err_str (err)); return; } @@ -577,7 +576,7 @@ enable_thread_event_reporting (void) 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", + warning (_("Unable to get location for thread death breakpoint: %s"), thread_db_err_str (err)); return; } @@ -650,7 +649,7 @@ thread_db_new_objfile (struct objfile *objfile) 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", + printf_unfiltered (_("Using host libthread_db library \"%s\".\n"), library); dejavu = 1; } @@ -691,7 +690,7 @@ thread_db_new_objfile (struct objfile *objfile) break; case TD_OK: - printf_unfiltered ("[Thread debugging using libthread_db enabled]\n"); + printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n")); /* The thread library was detected. Activate the thread_db target. */ push_target (&thread_db_ops); @@ -702,7 +701,7 @@ thread_db_new_objfile (struct objfile *objfile) break; default: - warning ("Cannot initialize thread debugging library: %s", + warning (_("Cannot initialize thread debugging library: %s"), thread_db_err_str (err)); break; } @@ -752,7 +751,7 @@ attach_thread (ptid_t ptid, const td_thrhandle_t *th_p, memset (tp->private, 0, sizeof (struct private_thread_info)); if (verbose) - printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid)); + 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. */ @@ -765,7 +764,7 @@ attach_thread (ptid_t ptid, const td_thrhandle_t *th_p, /* 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", + error (_("Cannot enable thread event reporting for %s: %s"), target_pid_to_str (ptid), thread_db_err_str (err)); } @@ -792,7 +791,7 @@ detach_thread (ptid_t ptid, int verbose) struct thread_info *thread_info; if (verbose) - printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid)); + 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 @@ -895,15 +894,15 @@ check_event (ptid_t ptid) if (err == TD_NOMSG) return; - error ("Cannot get thread event message: %s", + 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)); + error (_("Cannot get thread info: %s"), thread_db_err_str (err)); - ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid)); + ptid = ptid_build (GET_PID (ptid), ti.ti_lid, ti.ti_tid); switch (msg.event) { @@ -917,14 +916,14 @@ check_event (ptid_t ptid) case TD_DEATH: if (!in_thread_list (ptid)) - error ("Spurious thread death event."); + error (_("Spurious thread death event.")); detach_thread (ptid, 1); break; default: - error ("Spurious thread event."); + error (_("Spurious thread event.")); } } while (loop); @@ -969,12 +968,13 @@ thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus) 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) +static LONGEST +thread_db_xfer_partial (struct target_ops *ops, enum target_object object, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, ULONGEST offset, LONGEST len) { struct cleanup *old_chain = save_inferior_ptid (); - int xfer; + LONGEST xfer; if (is_thread (inferior_ptid)) { @@ -986,9 +986,8 @@ thread_db_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, inferior_ptid = lwp_from_thread (inferior_ptid); } - xfer = - target_beneath->deprecated_xfer_memory (memaddr, myaddr, len, write, - attrib, target); + xfer = target_beneath->to_xfer_partial (ops, object, annex, + readbuf, writebuf, offset, len); do_cleanups (old_chain); return xfer; @@ -1014,12 +1013,12 @@ thread_db_fetch_registers (int regno) err = td_thr_getgregs_p (&thread_info->private->th, gregset); if (err != TD_OK) - error ("Cannot fetch general-purpose registers for thread %ld: %s", + 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 (&thread_info->private->th, &fpregset); if (err != TD_OK) - error ("Cannot get floating-point registers for thread %ld: %s", + error (_("Cannot get floating-point registers for thread %ld: %s"), (long) GET_THREAD (inferior_ptid), thread_db_err_str (err)); /* Note that we must call supply_gregset after calling the thread_db @@ -1061,11 +1060,11 @@ thread_db_store_registers (int regno) err = td_thr_setgregs_p (&thread_info->private->th, gregset); if (err != TD_OK) - error ("Cannot store general-purpose registers for thread %ld: %s", + 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 (&thread_info->private->th, &fpregset); if (err != TD_OK) - error ("Cannot store floating-point registers for thread %ld: %s", + error (_("Cannot store floating-point registers for thread %ld: %s"), (long) GET_THREAD (inferior_ptid), thread_db_err_str (err)); } @@ -1169,13 +1168,13 @@ find_new_threads_callback (const td_thrhandle_t *th_p, void *data) err = td_thr_get_info_p (th_p, &ti); if (err != TD_OK) - error ("find_new_threads_callback: cannot get thread info: %s", + 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. */ - ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid)); + ptid = ptid_build (GET_PID (inferior_ptid), ti.ti_lid, ti.ti_tid); if (!in_thread_list (ptid)) attach_thread (ptid, th_p, &ti, 1); @@ -1193,7 +1192,7 @@ thread_db_find_new_threads (void) TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY, TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS); if (err != TD_OK) - error ("Cannot find new threads: %s", thread_db_err_str (err)); + error (_("Cannot find new threads: %s"), thread_db_err_str (err)); } static char * @@ -1238,38 +1237,27 @@ thread_db_pid_to_str (ptid_t 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. */ +/* Get the address of the thread local variable in load module LM 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, +thread_db_get_thread_local_address (ptid_t ptid, + CORE_ADDR lm, CORE_ADDR offset) { if (is_thread (ptid)) { - int objfile_is_library = (objfile->flags & OBJF_SHARED); td_err_e err; 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."); + throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR, + _("No TLS library support")); - /* 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); - } + /* Caller should have verified that lm != 0. */ + gdb_assert (lm != 0); /* Get info about the thread. */ thread_info = find_thread_pid (ptid); @@ -1282,49 +1270,31 @@ thread_db_get_thread_local_address (ptid_t ptid, struct objfile *objfile, #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)); - } + throw_error (TLS_NOT_ALLOCATED_YET_ERROR, + _("TLS not allocated yet")); #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)); - } + throw_error (TLS_GENERIC_ERROR, + (("%s")), thread_db_err_str (err)); /* Cast assuming host == target. Joy. */ - return (CORE_ADDR) address; + /* Do proper sign extension for the target. */ + gdb_assert (exec_bfd); + return (bfd_get_sign_extend_vma (exec_bfd) > 0 + ? (CORE_ADDR) (intptr_t) address + : (CORE_ADDR) (uintptr_t) 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."); + return target_beneath->to_get_thread_local_address (ptid, lm, offset); + else + throw_error (TLS_GENERIC_ERROR, + _("TLS not supported on this target")); } static void @@ -1339,7 +1309,7 @@ init_thread_db_ops (void) thread_db_ops.to_wait = thread_db_wait; thread_db_ops.to_fetch_registers = thread_db_fetch_registers; thread_db_ops.to_store_registers = thread_db_store_registers; - thread_db_ops.deprecated_xfer_memory = thread_db_xfer_memory; + thread_db_ops.to_xfer_partial = thread_db_xfer_partial; 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;