Add code to support statically linked binary and .core file of threaded

program.

1 files changed, 367 insertions, 177 deletions

diff --git a/gnu/usr.bin/gdb/libgdb/fbsd-threads.c b/gnu/usr.bin/gdb/libgdb/fbsd-threads.c
index c2e6c5f..765700a 100644
--- a/gnu/usr.bin/gdb/libgdb/fbsd-threads.c
+++ b/gnu/usr.bin/gdb/libgdb/fbsd-threads.c
@@ -19,25 +19,28 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#include "defs.h"
-
-#include "gdb_assert.h"
 #include <dlfcn.h>
+#include <sys/types.h>
+#include <sys/ptrace.h>
+
 #include "proc_service.h"
 #include "thread_db.h"
 
+#include "defs.h"
 #include "bfd.h"
+#include "elf-bfd.h"
+#include "gdb_assert.h"
+#include "gdbcore.h"
 #include "gdbthread.h"
 #include "inferior.h"
+#include "objfiles.h"
+#include "regcache.h"
 #include "symfile.h"
 #include "symtab.h"
-#include "objfiles.h"
 #include "target.h"
-#include "regcache.h"
 #include "gdbcmd.h"
 #include "solib-svr4.h"
 
-#include <sys/ptrace.h>
 
 #define LIBTHREAD_DB_SO "libthread_db.so"
 
@@ -46,18 +49,29 @@ struct ps_prochandle
   pid_t pid;
 };
 
+extern int child_suppress_run;
+
 extern struct target_ops child_ops;
 
 /* This module's target vector.  */
-static struct target_ops thread_db_ops;
+static struct target_ops fbsd_thread_ops;
+static struct target_ops fbsd_core_ops;
+
+/* Saved copy of orignal core_ops. */
+static struct target_ops orig_core_ops;
+extern struct target_ops core_ops;
 
-static struct target_ops base_ops;
- 
 /* Pointer to the next function on the objfile event chain.  */
 static void (*target_new_objfile_chain) (struct objfile *objfile);
 
+/* Non-zero if there is a thread module */
+static int fbsd_thread_present;
+
 /* Non-zero if we're using this module's target vector.  */
-static int using_thread_db;
+static int fbsd_thread_active;
+
+/* Non-zero if core_open is called */
+static int fbsd_thread_core = 0;
 
 /* Non-zero if we have to keep this module's target vector active
    across re-runs.  */
@@ -78,6 +92,7 @@ static ptid_t last_single_step_thread;
 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_delete_p) (td_thragent_t *);
 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,
@@ -93,7 +108,6 @@ static td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
 				      td_thr_events_t *event);
 static td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
 					 td_event_msg_t *msg);
-static td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
 static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
 				      td_thrinfo_t *infop);
 static td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th,
@@ -222,24 +236,46 @@ thread_from_lwp (ptid_t ptid)
  
   gdb_assert (IS_LWP (ptid));
 
-  err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
-  if (err == TD_OK)
+  if (fbsd_thread_active)
     {
-      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_THREAD (ti.ti_tid, GET_PID (ptid));
+      err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
+      if (err == TD_OK)
+        {
+          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_THREAD (ti.ti_tid, GET_PID (ptid));
+        }
     }
 
   /* the LWP is not mapped to user thread */  
   return BUILD_LWP (GET_LWP (ptid), GET_PID (ptid));
 }
 
+static void
+fbsd_core_get_first_lwp (bfd *abfd, asection *asect, void *obj)
+{
+  if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
+    return;
+
+  if (*(lwpid_t *)obj != 0)
+    return;
+
+  *(lwpid_t *)obj = atoi (bfd_section_name (abfd, asect) + 5);
+}
+
 static long
 get_current_lwp (int pid)
 {
   struct ptrace_lwpinfo pl;
+  lwpid_t lwpid;
 
+  if (!target_has_execution)
+    {
+      lwpid = 0;
+      bfd_map_over_sections (core_bfd, fbsd_core_get_first_lwp, &lwpid);
+      return lwpid;
+    }
   if (ptrace (PT_LWPINFO, pid, (caddr_t)&pl, sizeof(pl)))
     perror_with_name("PT_LWPINFO");
 
@@ -263,29 +299,50 @@ get_current_thread ()
 }
 
 static void
+fbsd_thread_activate (void)
+{
+  fbsd_thread_active = 1;
+  init_thread_list();
+  fbsd_thread_find_new_threads ();
+  get_current_thread ();
+}
+
+static void
+fbsd_thread_deactivate (void)
+{
+  td_ta_delete_p (thread_agent);
+
+  inferior_ptid = pid_to_ptid (proc_handle.pid);
+  proc_handle.pid = 0;
+  fbsd_thread_active = 0;
+  fbsd_thread_present = 0;
+  init_thread_list ();
+}
+
+static void
 fbsd_thread_new_objfile (struct objfile *objfile)
 {
   td_err_e err;
 
   /* Don't attempt to use thread_db on targets which can not run
      (core files).  */
-  if (objfile == NULL || !target_has_execution)
+  if (objfile == NULL)
     {
       /* All symbols have been discarded.  If the thread_db target is
          active, deactivate it now.  */
-      if (using_thread_db)
+      if (fbsd_thread_active)
         {
           gdb_assert (proc_handle.pid == 0);
-          unpush_target (&thread_db_ops);
-          using_thread_db = 0;
+          fbsd_thread_active = 0;
         }
 
-      keep_thread_db = 0;
-
       goto quit;
     }
 
-  if (using_thread_db)
+  if (!child_suppress_run)
+    goto quit;
+
+  if (fbsd_thread_active)
     /* Nothing to do.  The thread library was already detected and the
        target vector was already activated.  */
     goto quit;
@@ -305,32 +362,21 @@ fbsd_thread_new_objfile (struct objfile *objfile)
 
     case TD_OK:
       /* The thread library was detected.  Activate the thread_db target.  */
-      base_ops = current_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;
-        }
+      fbsd_thread_present = 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)
+      if (fbsd_thread_core == 0 && proc_handle.pid != 0)
         {
-          fbsd_thread_find_new_threads ();
-          get_current_thread ();
+          push_target(&fbsd_thread_ops);
+          fbsd_thread_activate();
         }
       else
-        printf_filtered("%s postpone processing\n", __func__);
+        {
+          td_ta_delete_p(thread_agent);
+          thread_agent = NULL;
+        }
       break;
 
     default:
@@ -347,23 +393,41 @@ fbsd_thread_new_objfile (struct objfile *objfile)
 static void
 fbsd_thread_attach (char *args, int from_tty)
 {
+  fbsd_thread_core = 0;
+
   child_ops.to_attach (args, from_tty);
 
-  /* Destroy thread info; it's no longer valid.  */
-  init_thread_list ();
+  /* Must get symbols from solibs before libthread_db can run! */
+  SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0, auto_solib_add);
 
-  /* The child process is now the actual multi-threaded
-     program.  Snatch its process ID...  */
-  proc_handle.pid = GET_PID (inferior_ptid);
+  if (fbsd_thread_present && !fbsd_thread_active)
+    push_target(&fbsd_thread_ops);
+}
 
-  /* ...and perform the remaining initialization steps.  */
-  fbsd_thread_find_new_threads();
-  get_current_thread ();
+static void
+fbsd_thread_post_attach (int pid)
+{
+  child_ops.to_post_attach (pid);
+
+  if (fbsd_thread_present && !fbsd_thread_active)
+    {
+      proc_handle.pid = GET_PID (inferior_ptid);
+      fbsd_thread_activate ();
+    }
 }
 
 static void
 fbsd_thread_detach (char *args, int from_tty)
 {
+  fbsd_thread_deactivate ();
+  unpush_target (&fbsd_thread_ops);
+
+  /* Clear gdb solib information and symbol file
+     cache, so that after detach and re-attach, new_objfile
+     hook will be called */
+
+  clear_solib();
+  symbol_file_clear(0);
   proc_handle.pid = 0;
   child_ops.to_detach (args, from_tty);
 }
@@ -373,7 +437,7 @@ suspend_thread_callback (const td_thrhandle_t *th_p, void *data)
 {
   int err = td_thr_dbsuspend_p (th_p);
   if (err != 0)
-	printf_filtered("%s %s\n", __func__, thread_db_err_str (err));
+	fprintf_filtered(gdb_stderr, "%s %s\n", __func__, thread_db_err_str (err));
   return (err);
 }
 
@@ -382,7 +446,7 @@ resume_thread_callback (const td_thrhandle_t *th_p, void *data)
 {
   int err = td_thr_dbresume_p (th_p);
   if (err != 0)
-	printf_filtered("%s %s\n", __func__, thread_db_err_str (err));
+	fprintf_filtered(gdb_stderr, "%s %s\n", __func__, thread_db_err_str (err));
   return (err);
 }
 
@@ -395,17 +459,9 @@ fbsd_thread_resume (ptid_t ptid, int step, enum target_signal signo)
   int resume_all, ret;
   long lwp, thvalid = 0;
 
-#if 0
-  printf_filtered("%s ptid=%ld.%ld.%ld step=%d\n", __func__,
-	GET_PID(ptid), GET_LWP(ptid), GET_THREAD(ptid), step);
-  printf_filtered("%s inferior_ptid=%ld.%ld.%ld\n", __func__,
-	GET_PID(inferior_ptid), GET_LWP(inferior_ptid),
-	GET_THREAD(inferior_ptid));
-#endif
-
-  if (proc_handle.pid == 0)
+  if (!fbsd_thread_active)
     {
-      base_ops.to_resume (ptid, step, signo);
+      child_ops.to_resume (ptid, step, signo);
       return;
     }
 
@@ -502,7 +558,7 @@ fbsd_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
   ret = child_ops.to_wait (ptid, ourstatus);
   if (GET_PID(ret) >= 0 && ourstatus->kind == TARGET_WAITKIND_STOPPED)
     {
-      lwp = get_current_lwp (proc_handle.pid);
+      lwp = get_current_lwp (GET_PID(ret));
       ret = thread_from_lwp (BUILD_LWP (lwp, GET_PID (ret)));
       if (!in_thread_list (ret))
         add_thread (ret);
@@ -525,8 +581,16 @@ static int
 fbsd_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
                         struct mem_attrib *attrib, struct target_ops *target)
 {
-  return base_ops.to_xfer_memory (memaddr, myaddr, len, write,
-                                  attrib, target);
+  int err;
+
+  if (target_has_execution)
+    err = child_ops.to_xfer_memory (memaddr, myaddr, len, write, attrib,
+	target);
+  else
+    err = orig_core_ops.to_xfer_memory (memaddr, myaddr, len, write, attrib,
+	target);
+
+  return (err);
 }
 
 static void
@@ -536,7 +600,12 @@ fbsd_lwp_fetch_registers (int regno)
   fpregset_t fpregs;
   lwpid_t lwp;
 
-  /* FIXME, use base_ops to fetch lwp registers! */
+  if (!target_has_execution)
+    {
+      orig_core_ops.to_fetch_registers (-1);
+      return;
+    }
+
   lwp = GET_LWP (inferior_ptid);
 
   if (ptrace (PT_GETREGS, lwp, (caddr_t) &gregs, 0) == -1)
@@ -675,14 +744,17 @@ fbsd_thread_kill (void)
   child_ops.to_kill();
 }
 
+static int
+fbsd_thread_can_run (void)
+{
+  return child_suppress_run;
+}
+
 static void
 fbsd_thread_create_inferior (char *exec_file, char *allargs, char **env)
 {
-  if (!keep_thread_db)
-    {
-      unpush_target (&thread_db_ops);
-      using_thread_db = 0;
-    }
+  if (fbsd_thread_present && !fbsd_thread_active)
+    push_target(&fbsd_thread_ops);
 
   child_ops.to_create_inferior (exec_file, allargs, env);
 }
@@ -690,16 +762,15 @@ fbsd_thread_create_inferior (char *exec_file, char *allargs, char **env)
 static void
 fbsd_thread_post_startup_inferior (ptid_t ptid)
 {
-  if (proc_handle.pid == 0)
+  if (fbsd_thread_present && !fbsd_thread_active)
     {
       /*
        * The child process is now the actual multi-threaded
        * program.  Snatch its process ID... 
        */
       proc_handle.pid = GET_PID (ptid);
-
-      fbsd_thread_find_new_threads ();
-      get_current_thread ();
+      td_ta_new_p (&proc_handle, &thread_agent);
+      fbsd_thread_activate();
     }
 }
 
@@ -710,11 +781,31 @@ fbsd_thread_mourn_inferior (void)
    * Forget about the child's process ID.  We shouldn't need it
    * anymore.
    */
-  proc_handle.pid = 0;
+  if (fbsd_thread_active)
+    fbsd_thread_deactivate ();
+
+  unpush_target (&fbsd_thread_ops);
 
   child_ops.to_mourn_inferior ();
 }
 
+static void
+fbsd_core_check_lwp (bfd *abfd, asection *asect, void *obj)
+{
+  lwpid_t lwp;
+
+  if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
+    return;
+
+  /* already found */
+  if (*(lwpid_t *)obj == 0)
+    return;
+
+  lwp = atoi (bfd_section_name (abfd, asect) + 5);
+  if (*(lwpid_t *)obj == lwp)
+    *(lwpid_t *)obj = 0;
+}
+
 static int
 fbsd_thread_alive (ptid_t ptid)
 {
@@ -722,6 +813,7 @@ fbsd_thread_alive (ptid_t ptid)
   td_thrinfo_t ti;
   td_err_e err;
   gregset_t gregs;
+  lwpid_t lwp;
 
   if (IS_THREAD (ptid))
     {
@@ -745,19 +837,35 @@ fbsd_thread_alive (ptid_t ptid)
       return 1;
     }
 
-  err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
+  if (fbsd_thread_active)
+    {
+      err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
 
-   /*
-    * if the lwp was already mapped to user thread, don't use it
-    * directly, please use user thread id instead.
-    */
-  if (err == TD_OK)
-    return 0;
+      /*
+       * if the lwp was already mapped to user thread, don't use it
+       * directly, please use user thread id instead.
+       */
+      if (err == TD_OK)
+        return 0;
+    }
+
+  if (!target_has_execution)
+    {
+      lwp = GET_LWP (ptid);
+      bfd_map_over_sections (core_bfd, fbsd_core_check_lwp, &lwp);
+      return (lwp == 0); 
+    }
 
   /* check lwp in kernel */
   return ptrace (PT_GETREGS, GET_LWP (ptid), (caddr_t)&gregs, 0) == 0;
 }
 
+static void
+fbsd_thread_files_info (struct target_ops *ignore)
+{
+  child_ops.to_files_info (ignore);
+}
+
 static int
 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
 {
@@ -773,11 +881,10 @@ find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
     return 0;
 
-  ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid));
+  ptid = BUILD_THREAD (ti.ti_tid, proc_handle.pid);
 
   if (!in_thread_list (ptid))
       add_thread (ptid);
- 
   return 0;
 }
 
@@ -786,6 +893,9 @@ fbsd_thread_find_new_threads (void)
 {
   td_err_e err;
 
+  if (!fbsd_thread_active)
+    return;
+
   /* Iterate over all user-space threads to discover new threads. */
   err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback, NULL,
           TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
@@ -908,108 +1018,168 @@ tsd_cb (thread_key_t key, void (*destructor)(void *), void *ignore)
 static void
 fbsd_thread_tsd_cmd (char *exp, int from_tty)
 {
-  td_ta_tsd_iter_p (thread_agent, tsd_cb, NULL);
+  if (fbsd_thread_active)
+    td_ta_tsd_iter_p (thread_agent, tsd_cb, NULL);
 }
 
-static void
-init_thread_db_ops (void)
+static int
+ignore (CORE_ADDR addr, char *contents)
 {
-  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 = fbsd_thread_attach;
-  thread_db_ops.to_detach = fbsd_thread_detach;
-  thread_db_ops.to_resume = fbsd_thread_resume;
-  thread_db_ops.to_wait = fbsd_thread_wait;
-  thread_db_ops.to_fetch_registers = fbsd_thread_fetch_registers;
-  thread_db_ops.to_store_registers = fbsd_thread_store_registers;
-  thread_db_ops.to_xfer_memory = fbsd_thread_xfer_memory;
-  thread_db_ops.to_kill = fbsd_thread_kill;
-  thread_db_ops.to_create_inferior = fbsd_thread_create_inferior;
-  thread_db_ops.to_post_startup_inferior = fbsd_thread_post_startup_inferior;
-  thread_db_ops.to_mourn_inferior = fbsd_thread_mourn_inferior;
-  thread_db_ops.to_thread_alive = fbsd_thread_alive;
-  thread_db_ops.to_find_new_threads = fbsd_thread_find_new_threads;
-  thread_db_ops.to_pid_to_str = fbsd_thread_pid_to_str;
-  thread_db_ops.to_stratum = thread_stratum;
-  thread_db_ops.to_has_thread_control = tc_none;
-  thread_db_ops.to_insert_breakpoint = memory_insert_breakpoint;
-  thread_db_ops.to_remove_breakpoint = memory_remove_breakpoint;
-  thread_db_ops.to_get_thread_local_address = fbsd_thread_get_local_address;
-  thread_db_ops.to_magic = OPS_MAGIC;
+  return 0;
 }
 
-static int
-thread_db_load (void)
+static void
+fbsd_core_open (char *filename, int from_tty)
 {
-  void *handle;
-  td_err_e err;
+  int err;
 
-  handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW);
-  if (handle == NULL)
-      return 0;
+  fbsd_thread_core = 1;
 
-  td_init_p = dlsym (handle, "td_init");
-  if (td_init_p == NULL)
-    return 0;
+  orig_core_ops.to_open (filename, from_tty);
 
-  td_ta_new_p = dlsym (handle, "td_ta_new");
-  if (td_ta_new_p == NULL)
-    return 0;
-
-  td_ta_map_id2thr_p = 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");
-  if (td_ta_map_lwp2thr_p == NULL)
-    return 0;
-
-  td_ta_thr_iter_p = dlsym (handle, "td_ta_thr_iter");
-  if (td_ta_thr_iter_p == NULL)
-    return 0;
-
-  td_thr_validate_p = dlsym (handle, "td_thr_validate");
-  if (td_thr_validate_p == NULL)
-    return 0;
-
-  td_thr_get_info_p = dlsym (handle, "td_thr_get_info");
-  if (td_thr_get_info_p == NULL)
-    return 0;
-
-  td_thr_getfpregs_p = dlsym (handle, "td_thr_getfpregs");
-  if (td_thr_getfpregs_p == NULL)
-    return 0;
+  if (fbsd_thread_present)
+    {
+      err = td_ta_new_p (&proc_handle, &thread_agent);
+      if (err == TD_OK)
+        {
+          proc_handle.pid = elf_tdata (core_bfd)->core_pid;
+          fbsd_thread_activate ();
+        }
+      else
+        error ("fbsd_core_open: td_open: %s", thread_db_err_str (err));
+    }
+}
 
-  td_thr_getgregs_p = dlsym (handle, "td_thr_getgregs");
-  if (td_thr_getgregs_p == NULL)
-    return 0;
+static void
+fbsd_core_close (int quitting)
+{
+  orig_core_ops.to_close (quitting);
+}
 
-  td_thr_setfpregs_p = dlsym (handle, "td_thr_setfpregs");
-  if (td_thr_setfpregs_p == NULL)
-    return 0;
+static void
+fbsd_core_detach (char *args, int from_tty)
+{
+  if (fbsd_thread_active)
+    fbsd_thread_deactivate ();
+  unpush_target (&fbsd_thread_ops);
+  orig_core_ops.to_detach (args, from_tty);
+ 
+  /* Clear gdb solib information and symbol file
+     cache, so that after detach and re-attach, new_objfile
+     hook will be called */
+  clear_solib();
+  symbol_file_clear(0);
+}
 
-  td_thr_setgregs_p = dlsym (handle, "td_thr_setgregs");
-  if (td_thr_setgregs_p == NULL)
-    return 0;
+static void
+fbsd_core_files_info (struct target_ops *ignore)
+{
+  orig_core_ops.to_files_info (ignore);
+}
 
-  td_thr_sstep_p = dlsym(handle, "td_thr_sstep");
-  if (td_thr_sstep_p == NULL)
-    return 0;
+static void
+init_fbsd_core_ops (void)
+{
+  fbsd_core_ops.to_shortname = "FreeBSD-core";
+  fbsd_core_ops.to_longname = "FreeBSD core thread.";
+  fbsd_core_ops.to_doc = "FreeBSD thread support for core files.";
+  fbsd_core_ops.to_open = fbsd_core_open;
+  fbsd_core_ops.to_close = fbsd_core_close;
+  fbsd_core_ops.to_attach = 0;
+  fbsd_core_ops.to_post_attach = 0;
+  fbsd_core_ops.to_detach = fbsd_core_detach;
+  /* fbsd_core_ops.to_resume  = 0; */
+  /* fbsd_core_ops.to_wait  = 0;  */
+  fbsd_core_ops.to_fetch_registers = fbsd_thread_fetch_registers;
+  /* fbsd_core_ops.to_store_registers  = 0; */
+  /* fbsd_core_ops.to_prepare_to_store  = 0; */
+  fbsd_core_ops.to_xfer_memory = fbsd_thread_xfer_memory;
+  fbsd_core_ops.to_files_info = fbsd_core_files_info;
+  fbsd_core_ops.to_insert_breakpoint = ignore;
+  fbsd_core_ops.to_remove_breakpoint = ignore;
+  /* fbsd_core_ops.to_lookup_symbol  = 0; */
+  fbsd_core_ops.to_create_inferior = fbsd_thread_create_inferior;
+  fbsd_core_ops.to_stratum = core_stratum;
+  fbsd_core_ops.to_has_all_memory = 0;
+  fbsd_core_ops.to_has_memory = 1;
+  fbsd_core_ops.to_has_stack = 1;
+  fbsd_core_ops.to_has_registers = 1;
+  fbsd_core_ops.to_has_execution = 0;
+  fbsd_core_ops.to_has_thread_control = tc_none;
+  fbsd_core_ops.to_thread_alive = fbsd_thread_alive;
+  fbsd_core_ops.to_pid_to_str = fbsd_thread_pid_to_str;
+  fbsd_core_ops.to_find_new_threads = fbsd_thread_find_new_threads;
+  fbsd_core_ops.to_sections = 0;
+  fbsd_core_ops.to_sections_end = 0;
+  fbsd_core_ops.to_magic = OPS_MAGIC;
+}
 
-  td_ta_tsd_iter_p = dlsym (handle, "td_ta_tsd_iter");
-  if (td_ta_tsd_iter_p == NULL)
-    return 0;
+static void
+init_fbsd_thread_ops (void)
+{
+  fbsd_thread_ops.to_shortname = "freebsd-threads";
+  fbsd_thread_ops.to_longname = "FreeBSD multithreaded child process.";
+  fbsd_thread_ops.to_doc = "FreeBSD threads support.";
+  fbsd_thread_ops.to_attach = fbsd_thread_attach;
+  fbsd_thread_ops.to_detach = fbsd_thread_detach;
+  fbsd_thread_ops.to_post_attach = fbsd_thread_post_attach;
+  fbsd_thread_ops.to_resume = fbsd_thread_resume;
+  fbsd_thread_ops.to_wait = fbsd_thread_wait;
+  fbsd_thread_ops.to_fetch_registers = fbsd_thread_fetch_registers;
+  fbsd_thread_ops.to_store_registers = fbsd_thread_store_registers;
+  fbsd_thread_ops.to_xfer_memory = fbsd_thread_xfer_memory;
+  fbsd_thread_ops.to_files_info = fbsd_thread_files_info;
+  fbsd_thread_ops.to_kill = fbsd_thread_kill;
+  fbsd_thread_ops.to_create_inferior = fbsd_thread_create_inferior;
+  fbsd_thread_ops.to_post_startup_inferior = fbsd_thread_post_startup_inferior;
+  fbsd_thread_ops.to_mourn_inferior = fbsd_thread_mourn_inferior;
+  fbsd_thread_ops.to_can_run = fbsd_thread_can_run;
+  fbsd_thread_ops.to_thread_alive = fbsd_thread_alive;
+  fbsd_thread_ops.to_find_new_threads = fbsd_thread_find_new_threads;
+  fbsd_thread_ops.to_pid_to_str = fbsd_thread_pid_to_str;
+  fbsd_thread_ops.to_stratum = thread_stratum;
+  fbsd_thread_ops.to_has_thread_control = tc_none;
+  fbsd_thread_ops.to_has_all_memory = 1;
+  fbsd_thread_ops.to_has_memory = 1;
+  fbsd_thread_ops.to_has_stack = 1;
+  fbsd_thread_ops.to_has_registers = 1;
+  fbsd_thread_ops.to_has_execution = 1;
+  fbsd_thread_ops.to_insert_breakpoint = memory_insert_breakpoint;
+  fbsd_thread_ops.to_remove_breakpoint = memory_remove_breakpoint;
+  fbsd_thread_ops.to_get_thread_local_address = fbsd_thread_get_local_address;
+  fbsd_thread_ops.to_magic = OPS_MAGIC;
+}
 
-  td_thr_dbsuspend_p = dlsym (handle, "td_thr_dbsuspend");
-  if (td_thr_dbsuspend_p == NULL)
-    return 0;
+static int
+thread_db_load (void)
+{
+  void *handle;
+  td_err_e err;
 
-  td_thr_dbresume_p = dlsym (handle, "td_thr_dbresume");
-  if (td_thr_dbresume_p == NULL)
-    return 0;
+  handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW);
+  if (handle == NULL)
+      return 0;
 
-  td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr");
+#define resolve(X)			\
+ if (!(X##_p = dlsym (handle, #X)))	\
+   return 0;
+
+  resolve(td_init);
+  resolve(td_ta_new);
+  resolve(td_ta_delete);
+  resolve(td_ta_map_id2thr);
+  resolve(td_ta_map_lwp2thr);
+  resolve(td_ta_thr_iter);
+  resolve(td_thr_get_info);
+  resolve(td_thr_getfpregs);
+  resolve(td_thr_getgregs);
+  resolve(td_thr_setfpregs);
+  resolve(td_thr_setgregs);
+  resolve(td_thr_sstep);
+  resolve(td_ta_tsd_iter);
+  resolve(td_thr_dbsuspend);
+  resolve(td_thr_dbresume);
+  resolve(td_thr_tls_get_addr);
 
   /* Initialize the library.  */
   err = td_init_p ();
@@ -1022,14 +1192,22 @@ thread_db_load (void)
   return 1;
 }
 
+/* we suppress the call to add_target of core_ops in corelow because
+   if there are two targets in the stratum core_stratum, find_core_target
+   won't know which one to return.  see corelow.c for an additonal
+   comment on coreops_suppress_target. */
+
+int coreops_suppress_target = 1;
+
 void
 _initialize_thread_db (void)
 {
-  /* Only initialize the module if we can load libthread_db. */
+  init_fbsd_thread_ops ();
+  init_fbsd_core_ops ();
+
   if (thread_db_load ())
     {
-      init_thread_db_ops ();
-      add_target (&thread_db_ops);
+      add_target (&fbsd_thread_ops);
 
       /* "thread tsd" command */
       add_cmd ("tsd", class_run, fbsd_thread_tsd_cmd,
@@ -1037,13 +1215,23 @@ _initialize_thread_db (void)
             "for the process.\n",
            &thread_cmd_list);
 
+      memcpy (&orig_core_ops, &core_ops, sizeof (struct target_ops));
+      memcpy (&core_ops, &fbsd_core_ops, sizeof (struct target_ops));
+      add_target (&core_ops);
+
       /* Add ourselves to objfile event chain. */
       target_new_objfile_chain = target_new_objfile_hook;
       target_new_objfile_hook = fbsd_thread_new_objfile;
+
+      child_suppress_run = 1;
     }
   else
     {
-      printf_filtered("%s: can not load %s.\n", __func__, LIBTHREAD_DB_SO);
+      fprintf_unfiltered (gdb_stderr,
+        "[GDB will not be able to debug user-mode threads: %s]\n", dlerror());
+     
+      /* allow the user to debug non-threaded core files */
+      add_target (&core_ops);
     }
 }
 
@@ -1075,14 +1263,16 @@ ps_pglobal_lookup (struct ps_prochandle *ph, const char *obj,
 ps_err_e
 ps_pread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t len)
 {
-  return target_read_memory ((CORE_ADDR) addr, buf, len);
+  int err = target_read_memory ((CORE_ADDR) addr, buf, len);
+  return (err == 0 ? PS_OK : PS_ERR);
 }
 
 ps_err_e
 ps_pwrite (struct ps_prochandle *ph, psaddr_t addr, const void *buf,
             size_t len)
 {
-  return target_write_memory ((CORE_ADDR) addr, (void *)buf, len);
+  int err = target_write_memory ((CORE_ADDR) addr, (void *)buf, len);
+  return (err == 0 ? PS_OK : PS_ERR);
 }
 
 ps_err_e