OPTIONS_SINGLE_THREADS=		THREAD_DB_THREAD PTRACE_THREAD NONE_THREAD

NONE_THREAD_DESC=	No thread debugging support

PTRACE_THREAD_DESC=	Use ptrace() for thread debugging (experimental)

THREAD_DB_THREAD_DESC=	Use libthread_db for thread debugging

.if ${PORT_OPTIONS:MPTRACE_THREAD}

	@${PATCH} ${PATCH_ARGS} < ${FILESDIR}/extrapatch-threads-ptrace

.endif

diff --git bfd/elf.c bfd/elf.c

index 9846046..6ccdb8f 100644

--- bfd/elf.c

+++ bfd/elf.c

@@ -9126,6 +9126,13 @@ elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)

     case NT_SIGINFO:

       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",

 					      note);

+

+    case NT_FREEBSD_THRMISC:

+      if (note->namesz == 8

+	  && strcmp (note->namedata, "FreeBSD") == 0)

+	return elfcore_make_note_pseudosection (abfd, ".thrmisc", note);

+      else

+	return TRUE;

     }

 }

diff --git gdb/amd64bsd-nat.c gdb/amd64bsd-nat.c

index 66d4289..c3d8e0e 100644

--- gdb/amd64bsd-nat.c

+++ gdb/amd64bsd-nat.c

@@ -52,7 +52,7 @@ amd64bsd_fetch_inferior_registers (struct target_ops *ops,

     {

       struct reg regs;

-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),

 		  (PTRACE_TYPE_ARG3) &regs, 0) == -1)

 	perror_with_name (_("Couldn't get registers"));

@@ -70,7 +70,7 @@ amd64bsd_fetch_inferior_registers (struct target_ops *ops,

       if (amd64bsd_xsave_len != 0)

 	{

 	  xstateregs = alloca (amd64bsd_xsave_len);

-	  if (ptrace (PT_GETXSTATE, ptid_get_pid (inferior_ptid),

+	  if (ptrace (PT_GETXSTATE, get_ptrace_pid (inferior_ptid),

 		      (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)

 	    perror_with_name (_("Couldn't get extended state status"));

@@ -79,7 +79,7 @@ amd64bsd_fetch_inferior_registers (struct target_ops *ops,

 	}

 #endif

-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_GETFPREGS, get_ptrace_pid (inferior_ptid),

 		  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

 	perror_with_name (_("Couldn't get floating point status"));

@@ -103,11 +114,11 @@ amd64bsd_store_inferior_registers (struc

       memset( &regs, 0, sizeof(struct reg));

       memset( &oldregs, 0, sizeof(struct reg));

-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),

                   (PTRACE_TYPE_ARG3) &regs, 0) == -1)

         perror_with_name (_("Couldn't get registers"));

-      ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),

+      ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),

                   (PTRACE_TYPE_ARG3) &oldregs, 0);

       amd64_collect_native_gregset (regcache, &regs, regnum);

@@ -117,7 +128,7 @@ amd64bsd_store_inferior_registers (struc

         regs.r_rflags ^= (regs.r_rflags ^ oldregs.r_rflags ) & ~PSL_USERCHANGE;

         //printf("    allowed regs.r_rflags = 0x%8.8X\n", regs.r_rflags );

       }

-      if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_SETREGS, get_ptrace_pid (inferior_ptid),

 	          (PTRACE_TYPE_ARG3) &regs, 0) == -1)

         perror_with_name (_("Couldn't write registers"));

@@ -134,26 +145,26 @@ amd64bsd_store_inferior_registers (struc

       if (amd64bsd_xsave_len != 0)

 	{

 	  xstateregs = alloca (amd64bsd_xsave_len);

-	  if (ptrace (PT_GETXSTATE, ptid_get_pid (inferior_ptid),

+	  if (ptrace (PT_GETXSTATE, get_ptrace_pid (inferior_ptid),

 		      (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)

 	    perror_with_name (_("Couldn't get extended state status"));

 	  amd64_collect_xsave (regcache, regnum, xstateregs, 0);

-	  if (ptrace (PT_SETXSTATE, ptid_get_pid (inferior_ptid),

+	  if (ptrace (PT_SETXSTATE, get_ptrace_pid (inferior_ptid),

 		      (PTRACE_TYPE_ARG3) xstateregs, amd64bsd_xsave_len) == -1)

 	    perror_with_name (_("Couldn't write extended state status"));

 	  return;

 	}

 #endif

-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_GETFPREGS, get_ptrace_pid (inferior_ptid),

 		  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

 	perror_with_name (_("Couldn't get floating point status"));

       amd64_collect_fxsave (regcache, regnum, &fpregs);

-      if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_SETFPREGS, get_ptrace_pid (inferior_ptid),

 		  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

 	perror_with_name (_("Couldn't write floating point status"));

     }

@@ -183,7 +194,7 @@ amd64bsd_dr_get (ptid_t ptid, int regnum

 {

   struct dbreg dbregs;

-  if (ptrace (PT_GETDBREGS, ptid_get_pid (inferior_ptid),

+  if (ptrace (PT_GETDBREGS, get_ptrace_pid (inferior_ptid),

 	      (PTRACE_TYPE_ARG3) &dbregs, 0) == -1)

     perror_with_name (_("Couldn't read debug registers"));

@@ -195,7 +206,7 @@ amd64bsd_dr_set (int regnum, unsigned lo

 {

   struct dbreg dbregs;

-  if (ptrace (PT_GETDBREGS, ptid_get_pid (inferior_ptid),

+  if (ptrace (PT_GETDBREGS, get_ptrace_pid (inferior_ptid),

               (PTRACE_TYPE_ARG3) &dbregs, 0) == -1)

     perror_with_name (_("Couldn't get debug registers"));

@@ -195,7 +206,7 @@ amd64bsd_dr_set (int regnum, unsigned long value)

   DBREG_DRX ((&dbregs), regnum) = value;

-  if (ptrace (PT_SETDBREGS, ptid_get_pid (inferior_ptid),

+  if (ptrace (PT_SETDBREGS, get_ptrace_pid (inferior_ptid),

               (PTRACE_TYPE_ARG3) &dbregs, 0) == -1)

     perror_with_name (_("Couldn't write debug registers"));

 }

diff --git gdb/config.in gdb/config.in

index 9ef53b3..0e3166b 100644

--- gdb/config.in

+++ gdb/config.in

@@ -450,6 +450,9 @@

 /* Define to 1 if your system has struct lwp. */

 #undef HAVE_STRUCT_LWP

+/* Define to 1 if `struct ptrace_lwpinfo' is a member of `pl_tdname'. */

+#undef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME

+

 /* Define to 1 if your system has struct reg in <machine/reg.h>. */

 #undef HAVE_STRUCT_REG

diff --git gdb/configure gdb/configure

index e8979f0..62f8886 100755

--- gdb/configure

+++ gdb/configure

@@ -12502,6 +12502,22 @@ $as_echo "#define HAVE_PT_GETXMMREGS 1" >>confdefs.h

 fi

+# See if <sys/ptrace.h> supports LWP names on FreeBSD

+# Older FreeBSD versions don't have the pl_tdname member of

+# `struct ptrace_lwpinfo'.

+ac_fn_c_check_member "$LINENO" "struct ptrace_lwpinfo" "pl_tdname" "ac_cv_member_struct_ptrace_lwpinfo_pl_tdname" "#include <sys/ptrace.h>

+"

+if test "x$ac_cv_member_struct_ptrace_lwpinfo_pl_tdname" = x""yes; then :

+

+cat >>confdefs.h <<_ACEOF

+#define HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME 1

+_ACEOF

+

+

+fi

+

+

+

 # Detect which type of /proc is in use, such as for Solaris.

 if test "${target}" = "${host}"; then

diff --git gdb/configure.ac gdb/configure.ac

index a40860a..6664355 100644

--- gdb/configure.ac

+++ gdb/configure.ac

@@ -1564,6 +1564,13 @@ if test $gdb_cv_have_pt_getxmmregs = yes; then

   [Define if sys/ptrace.h defines the PT_GETXMMREGS request.])

 fi

+# See if <sys/ptrace.h> supports LWP names on FreeBSD

+# Older FreeBSD versions don't have the pl_tdname member of

+# `struct ptrace_lwpinfo'.

+AC_CHECK_MEMBERS([struct ptrace_lwpinfo.pl_tdname], [], [],

+                 [#include <sys/ptrace.h>])

+

+

 # Detect which type of /proc is in use, such as for Solaris.

 if test "${target}" = "${host}"; then

diff --git gdb/corelow.c gdb/corelow.c

index 9218003..48dfc87 100644

--- gdb/corelow.c

+++ gdb/corelow.c

@@ -986,6 +986,15 @@ core_pid_to_str (struct target_ops *ops, ptid_t ptid)

   return buf;

 }

+static const char *

+core_thread_name (struct target_ops *self, struct thread_info *thr)

+{

+  if (core_gdbarch

+      && gdbarch_core_thread_name_p (core_gdbarch))

+    return gdbarch_core_thread_name (core_gdbarch, thr);

+  return NULL;

+}

+

 static int

 core_has_memory (struct target_ops *ops)

 {

@@ -1038,6 +1047,7 @@ init_core_ops (void)

   core_ops.to_thread_alive = core_thread_alive;

   core_ops.to_read_description = core_read_description;

   core_ops.to_pid_to_str = core_pid_to_str;

+  core_ops.to_thread_name = core_thread_name;

   core_ops.to_stratum = process_stratum;

   core_ops.to_has_memory = core_has_memory;

   core_ops.to_has_stack = core_has_stack;

diff --git gdb/fbsd-nat.c gdb/fbsd-nat.c

index 9705d45..cf54039 100644

--- gdb/fbsd-nat.c

+++ gdb/fbsd-nat.c

@@ -22,6 +22,7 @@

 #include "inferior.h"

 #include "regcache.h"

 #include "regset.h"

+#include "gdbcmd.h"

 #include "gdbthread.h"

 #include "gdb_wait.h"

 #include <sys/types.h>

@@ -204,11 +205,283 @@ fbsd_find_memory_regions (struct target_ops *self,

 #endif

 #ifdef PT_LWPINFO

+static int debug_fbsd_lwp;

+

 static ptid_t (*super_wait) (struct target_ops *,

 			     ptid_t,

 			     struct target_waitstatus *,

 			     int);

+static void

+show_fbsd_lwp_debug (struct ui_file *file, int from_tty,

+		     struct cmd_list_element *c, const char *value)

+{

+  fprintf_filtered (file, _("Debugging of FreeBSD lwp module is %s.\n"), value);

+}

+

+#if defined(TDP_RFPPWAIT) || defined(HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME)

+/* Fetch the external variant of the kernel's internal process

+   structure for the process PID into KP.  */

+

+static void

+fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp)

+{

+  size_t len;

+  int mib[4];

+

+  len = sizeof *kp;

+  mib[0] = CTL_KERN;

+  mib[1] = KERN_PROC;

+  mib[2] = KERN_PROC_PID;

+  mib[3] = pid;

+  if (sysctl (mib, 4, kp, &len, NULL, 0) == -1)

+    perror_with_name (("sysctl"));

+}

+#endif

+

+/*

+  FreeBSD's first thread support was via a "reentrant" version of libc

+  (libc_r) that first shipped in 2.2.7.  This library multiplexed all

+  of the threads in a process onto a single kernel thread.  This

+  library is supported via the bsd-uthread target.

+

+  FreeBSD 5.1 introduced two new threading libraries that made use of

+  multiple kernel threads.  The first (libkse) scheduled M user

+  threads onto N (<= M) kernel threads (LWPs).  The second (libthr)

+  bound each user thread to a dedicated kernel thread.  libkse shipped

+  as the default threading library (libpthread).

+

+  FreeBSD 5.3 added a libthread_db to abstract the interface across

+  the various thread libraries (libc_r, libkse, and libthr).

+

+  FreeBSD 7.0 switched the default threading library from from libkse

+  to libpthread and removed libc_r.

+

+  FreeBSD 8.0 removed libkse and the in-kernel support for it.  The

+  only threading library supported by 8.0 and later is libthr which

+  ties each user thread directly to an LWP.  To simplify the

+  implementation, this target only supports LWP-backed threads using

+  ptrace directly rather than libthread_db.

+

+  FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.

+*/

+

+/* Return true if PTID is still active in the inferior.  */

+

+static int

+fbsd_thread_alive (struct target_ops *ops, ptid_t ptid)

+{

+  if (ptid_lwp_p (ptid))

+    {

+      struct ptrace_lwpinfo pl;

+

+      if (ptrace (PT_LWPINFO, ptid_get_lwp (ptid), (caddr_t) &pl, sizeof pl)

+	  == -1)

+	return 0;

+#ifdef PL_FLAG_EXITED

+      if (pl.pl_flags & PL_FLAG_EXITED)

+	return 0;

+#endif

+    }

+

+  return 1;

+}

+

+/* Convert PTID to a string.  Returns the string in a static

+   buffer.  */

+

+static char *

+fbsd_pid_to_str (struct target_ops *ops, ptid_t ptid)

+{

+  lwpid_t lwp;

+

+  lwp = ptid_get_lwp (ptid);

+  if (lwp != 0)

+    {

+      static char buf[64];

+      int pid = ptid_get_pid (ptid);

+

+      xsnprintf (buf, sizeof buf, "process %d, LWP %d", pid, lwp);

+      return buf;

+    }

+

+  return normal_pid_to_str (ptid);

+}

+

+#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME

+/* Return the name assigned to a thread by an application.  Returns

+   the string in a static buffer.  */

+

+static const char *

+fbsd_thread_name (struct target_ops *self, struct thread_info *thr)

+{

+  struct ptrace_lwpinfo pl;

+  struct kinfo_proc kp;

+  int pid = ptid_get_pid (thr->ptid);

+  long lwp = ptid_get_lwp (thr->ptid);

+  static char buf[sizeof pl.pl_tdname + 1];

+

+  /* Note that ptrace_lwpinfo returns the process command in pl_tdname

+     if a name has not been set explicitly.  Return a NULL name in

+     that case.  */

+  fbsd_fetch_kinfo_proc (pid, &kp);

+  if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1)

+    perror_with_name (("ptrace"));

+  if (strcmp (kp.ki_comm, pl.pl_tdname) == 0)

+    return NULL;

+  xsnprintf (buf, sizeof buf, "%s", pl.pl_tdname);

+  return buf;

+}

+#endif

+

+#ifdef PT_LWP_EVENTS

+/* Enable LWP events for a specific process.

+

+   To catch LWP events, PT_LWP_EVENTS is set on every traced process.

+   This enables stops on the birth for new LWPs (excluding the "main" LWP)

+   and the death of LWPs (excluding the last LWP in a process).  Note

+   that unlike fork events, the LWP that creates a new LWP does not

+   report an event.  */

+

+static void

+fbsd_enable_lwp_events (pid_t pid)

+{

+  if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)

+    perror_with_name (("ptrace"));

+}

+#endif

+

+/* Add threads for any new LWPs in a process.

+

+   When LWP events are used, this function is only used to detect existing

+   threads when attaching to a process.  On older systems, this function is

+   called to discover new threads each time the thread list is updated.  */

+

+static void

+fbsd_add_threads (pid_t pid)

+{

+  struct cleanup *cleanup;

+  lwpid_t *lwps;

+  int i, nlwps;

+

+  gdb_assert (!in_thread_list (pid_to_ptid (pid)));

+  nlwps = ptrace (PT_GETNUMLWPS, pid, NULL, 0);

+  if (nlwps == -1)

+    perror_with_name (("ptrace"));

+

+  lwps = xcalloc (nlwps, sizeof *lwps);

+  cleanup = make_cleanup (xfree, lwps);

+

+  nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps, nlwps);

+  if (nlwps == -1)

+    perror_with_name (("ptrace"));

+

+  for (i = 0; i < nlwps; i++)

+    {

+      ptid_t ptid = ptid_build (pid, lwps[i], 0);

+

+      if (!in_thread_list (ptid))

+	{

+#ifdef PT_LWP_EVENTS

+	  struct ptrace_lwpinfo pl;

+

+	  /* Don't add exited threads.  Note that this is only called

+	     when attaching to a multi-threaded process.  */

+	  if (ptrace (PT_LWPINFO, lwps[i], (caddr_t) &pl, sizeof pl) == -1)

+	    perror_with_name (("ptrace"));

+	  if (pl.pl_flags & PL_FLAG_EXITED)

+	    continue;

+#endif

+	  if (debug_fbsd_lwp)

+	    fprintf_unfiltered (gdb_stdlog,

+				"FLWP: adding thread for LWP %u\n",

+				lwps[i]);

+	  add_thread (ptid);

+	}

+    }

+  do_cleanups (cleanup);

+}

+

+/* Implement the "to_update_thread_list" target_ops method.  */

+

+static void

+fbsd_update_thread_list (struct target_ops *ops)

+{

+#ifdef PT_LWP_EVENTS

+  /* With support for thread events, threads are added/deleted from the

+     list as events are reported, so just try deleting exited threads.  */

+  delete_exited_threads ();

+#else

+  prune_threads ();

+

+  fbsd_add_threads (ptid_get_pid (inferior_ptid));

+#endif

+}

+

+static void (*super_resume) (struct target_ops *,

+			     ptid_t,

+			     int,

+			     enum gdb_signal);

+

+static int

+resume_one_thread_cb (struct thread_info *tp, void *data)

+{

+  ptid_t *ptid = data;

+  int request;

+

+  if (ptid_get_pid (tp->ptid) != ptid_get_pid (*ptid))

+    return 0;

+

+  if (ptid_get_lwp (tp->ptid) == ptid_get_lwp (*ptid))

+    request = PT_RESUME;

+  else

+    request = PT_SUSPEND;

+

+  if (ptrace (request, ptid_get_lwp (tp->ptid), NULL, 0) == -1)

+    perror_with_name (("ptrace"));

+  return 0;

+}

+

+static int

+resume_all_threads_cb (struct thread_info *tp, void *data)

+{

+  ptid_t *filter = data;

+

+  if (!ptid_match (tp->ptid, *filter))

+    return 0;

+

+  if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1)

+    perror_with_name (("ptrace"));

+  return 0;

+}

+

+/* Implement the "to_resume" target_ops method.  */

+

+static void

+fbsd_resume (struct target_ops *ops,

+	     ptid_t ptid, int step, enum gdb_signal signo)

+{

+

+  if (debug_fbsd_lwp)

+    fprintf_unfiltered (gdb_stdlog,

+			"FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",

+			ptid_get_pid (ptid), ptid_get_lwp (ptid),

+			ptid_get_tid (ptid));

+  if (ptid_lwp_p (ptid))

+    {

+      /* If ptid is a specific LWP, suspend all other LWPs in the process.  */

+      iterate_over_threads (resume_one_thread_cb, &ptid);

+    }

+  else

+    {

+      /* If ptid is a wildcard, resume all matching threads (they won't run

+	 until the process is continued however).  */

+      iterate_over_threads (resume_all_threads_cb, &ptid);

+      ptid = inferior_ptid;

+    }

+  super_resume (ops, ptid, step, signo);

+}

+

 #ifdef TDP_RFPPWAIT

 /*

   To catch fork events, PT_FOLLOW_FORK is set on every traced process

@@ -246,7 +519,7 @@ static ptid_t (*super_wait) (struct target_ops *,

 struct fbsd_fork_child_info

 {

   struct fbsd_fork_child_info *next;

-  pid_t child;			/* Pid of new child.  */

+  ptid_t child;			/* Pid of new child.  */

 };

 static struct fbsd_fork_child_info *fbsd_pending_children;

@@ -255,7 +528,7 @@ static struct fbsd_fork_child_info *fbsd_pending_children;

    corresponding fork event in the parent.  */

 static void

-fbsd_remember_child (pid_t pid)

+fbsd_remember_child (ptid_t pid)

 {

   struct fbsd_fork_child_info *info;

@@ -267,45 +540,29 @@ fbsd_remember_child (pid_t pid)

 }

 /* Check for a previously-recorded new child process event for PID.

-   If one is found, remove it from the list.  */

+   If one is found, remove it from the list and return the PTID.  */

-static int

+static ptid_t

 fbsd_is_child_pending (pid_t pid)

 {

   struct fbsd_fork_child_info *info, *prev;

+  ptid_t ptid;

   prev = NULL;

   for (info = fbsd_pending_children; info; prev = info, info = info->next)

     {

-      if (info->child == pid)

+      if (ptid_get_pid (info->child) == pid)

 	{

 	  if (prev == NULL)

 	    fbsd_pending_children = info->next;

 	  else

 	    prev->next = info->next;

+	  ptid = info->child;

 	  xfree (info);

-	  return 1;

+	  return ptid;

 	}

     }

-  return 0;

-}

-

-/* Fetch the external variant of the kernel's internal process

-   structure for the process PID into KP.  */

-

-static void

-fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp)

-{

-  size_t len;

-  int mib[4];

-

-  len = sizeof *kp;

-  mib[0] = CTL_KERN;

-  mib[1] = KERN_PROC;

-  mib[2] = KERN_PROC_PID;

-  mib[3] = pid;

-  if (sysctl (mib, 4, kp, &len, NULL, 0) == -1)

-    perror_with_name (("sysctl"));

+  return null_ptid;

 }

 #endif

@@ -330,21 +587,83 @@ fbsd_wait (struct target_ops *ops,

 	  int status;

 	  pid = ptid_get_pid (wptid);

-	  if (ptrace (PT_LWPINFO, pid, (caddr_t)&pl, sizeof pl) == -1)

+	  if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1)

 	    perror_with_name (("ptrace"));

+	  wptid = ptid_build (pid, pl.pl_lwpid, 0);

+

+#ifdef PT_LWP_EVENTS

+	  if (pl.pl_flags & PL_FLAG_EXITED)

+	    {

+	      /* If GDB attaches to a multi-threaded process, exiting

+		 threads might be skipped during fbsd_post_attach that

+		 have not yet reported their PL_FLAG_EXITED event.

+		 Ignore EXITED events for an unknown LWP.  */

+	      if (in_thread_list (wptid))

+		{

+		  if (debug_fbsd_lwp)

+		    fprintf_unfiltered (gdb_stdlog,

+					"FLWP: deleting thread for LWP %u\n",

+					pl.pl_lwpid);

+		  if (print_thread_events)

+		    printf_unfiltered (_("[%s exited]\n"), target_pid_to_str

+				       (wptid));

+		  delete_thread (wptid);

+		}

+	      if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)

+		perror_with_name (("ptrace"));

+	      continue;

+	    }

+#endif

+

+	  /* Switch to an LWP PTID on the first stop in a new process.

+	     This is done after handling PL_FLAG_EXITED to avoid

+	     switching to an exited LWP.  It is done before checking

+	     PL_FLAG_BORN in case the first stop reported after

+	     attaching to an existing process is a PL_FLAG_BORN

+	     event.  */

+	  if (in_thread_list (pid_to_ptid (pid)))

+	    {

+	      if (debug_fbsd_lwp)

+		fprintf_unfiltered (gdb_stdlog,

+				    "FLWP: using LWP %u for first thread\n",

+				    pl.pl_lwpid);

+	      thread_change_ptid (pid_to_ptid (pid), wptid);

+	    }

+

+#ifdef PT_LWP_EVENTS

+	  if (pl.pl_flags & PL_FLAG_BORN)

+	    {

+	      /* If GDB attaches to a multi-threaded process, newborn

+		 threads might be added by fbsd_add_threads that have

+		 not yet reported their PL_FLAG_BORN event.  Ignore

+		 BORN events for an already-known LWP.  */

+	      if (!in_thread_list (wptid))

+		{

+		  if (debug_fbsd_lwp)

+		    fprintf_unfiltered (gdb_stdlog,

+					"FLWP: adding thread for LWP %u\n",

+					pl.pl_lwpid);

+		  add_thread (wptid);

+		}

+	      ourstatus->kind = TARGET_WAITKIND_SPURIOUS;

+	      return wptid;

+	    }

+#endif

+

 #ifdef TDP_RFPPWAIT

 	  if (pl.pl_flags & PL_FLAG_FORKED)

 	    {

 	      struct kinfo_proc kp;

+	      ptid_t child_ptid;

 	      pid_t child;

 	      child = pl.pl_child_pid;

 	      ourstatus->kind = TARGET_WAITKIND_FORKED;

-	      ourstatus->value.related_pid = pid_to_ptid (child);

 	      /* Make sure the other end of the fork is stopped too.  */

-	      if (!fbsd_is_child_pending (child))

+	      child_ptid = fbsd_is_child_pending (child);

+	      if (ptid_equal (child_ptid, null_ptid))

 		{

 		  pid = waitpid (child, &status, 0);

 		  if (pid == -1)

@@ -356,6 +675,7 @@ fbsd_wait (struct target_ops *ops,

 		    perror_with_name (("ptrace"));

 		  gdb_assert (pl.pl_flags & PL_FLAG_CHILD);

+		  child_ptid = ptid_build (child, pl.pl_lwpid, 0);

 		}

 	      /* For vfork, the child process will have the P_PPWAIT

@@ -363,6 +683,7 @@ fbsd_wait (struct target_ops *ops,

 	      fbsd_fetch_kinfo_proc (child, &kp);

 	      if (kp.ki_flag & P_PPWAIT)

 		ourstatus->kind = TARGET_WAITKIND_VFORKED;

+	      ourstatus->value.related_pid = child_ptid;

 	      return wptid;

 	    }

@@ -372,7 +693,7 @@ fbsd_wait (struct target_ops *ops,

 	      /* Remember that this child forked, but do not report it

 		 until the parent reports its corresponding fork

 		 event.  */

-	      fbsd_remember_child (ptid_get_pid (wptid));

+	      fbsd_remember_child (wptid);

 	      continue;

 	    }

 #endif

@@ -451,13 +772,19 @@ fbsd_enable_follow_fork (pid_t pid)

   if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)

     perror_with_name (("ptrace"));

 }

+#endif

 /* Implement the "to_post_startup_inferior" target_ops method.  */

 static void

 fbsd_post_startup_inferior (struct target_ops *self, ptid_t pid)

 {

+#ifdef TDP_RFPPWAIT

   fbsd_enable_follow_fork (ptid_get_pid (pid));

+#endif

+#ifdef PT_LWP_EVENTS

+  fbsd_enable_lwp_events (ptid_get_pid (pid));

+#endif

 }

 /* Implement the "to_post_attach" target_ops method.  */

@@ -465,9 +792,14 @@ fbsd_post_startup_inferior (struct target_ops *self, ptid_t pid)

 static void

 fbsd_post_attach (struct target_ops *self, int pid)

 {

+#ifdef TDP_RFPPWAIT

   fbsd_enable_follow_fork (pid);

-}

 #endif

+#ifdef PT_LWP_EVENTS

+  fbsd_enable_lwp_events (pid);

+#endif

+  fbsd_add_threads (pid);

+}

 #ifdef PL_FLAG_EXEC

 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes

@@ -493,16 +825,25 @@ fbsd_nat_add_target (struct target_ops *t)

   t->to_pid_to_exec_file = fbsd_pid_to_exec_file;

   t->to_find_memory_regions = fbsd_find_memory_regions;

 #ifdef PT_LWPINFO

+  t->to_thread_alive = fbsd_thread_alive;

+  t->to_pid_to_str = fbsd_pid_to_str;

+#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME

+  t->to_thread_name = fbsd_thread_name;

+#endif

+  t->to_update_thread_list = fbsd_update_thread_list;

+  t->to_has_thread_control = tc_schedlock;

+  super_resume = t->to_resume;

+  t->to_resume = fbsd_resume;

   super_wait = t->to_wait;

   t->to_wait = fbsd_wait;

+  t->to_post_startup_inferior = fbsd_post_startup_inferior;

+  t->to_post_attach = fbsd_post_attach;

 #ifdef TDP_RFPPWAIT

   t->to_follow_fork = fbsd_follow_fork;

   t->to_insert_fork_catchpoint = fbsd_insert_fork_catchpoint;

   t->to_remove_fork_catchpoint = fbsd_remove_fork_catchpoint;

   t->to_insert_vfork_catchpoint = fbsd_insert_vfork_catchpoint;

   t->to_remove_vfork_catchpoint = fbsd_remove_vfork_catchpoint;

-  t->to_post_startup_inferior = fbsd_post_startup_inferior;

-  t->to_post_attach = fbsd_post_attach;

 #endif

 #ifdef PL_FLAG_EXEC

   t->to_insert_exec_catchpoint = fbsd_insert_exec_catchpoint;

@@ -511,3 +852,21 @@ fbsd_nat_add_target (struct target_ops *t)

 #endif

   add_target (t);

 }

+

+/* Provide a prototype to silence -Wmissing-prototypes.  */

+extern initialize_file_ftype _initialize_fbsd_nat;

+

+void

+_initialize_fbsd_nat (void)

+{

+#ifdef PT_LWPINFO

+  add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance,

+			   &debug_fbsd_lwp, _("\

+Set debugging of FreeBSD lwp module."), _("\

+Show debugging of FreeBSD lwp module."), _("\

+Enables printf debugging output."),

+			   NULL,

+			   &show_fbsd_lwp_debug,

+			   &setdebuglist, &showdebuglist);

+#endif

+}

diff --git gdb/fbsd-tdep.c gdb/fbsd-tdep.c

index 9609cd8..5aa24c6 100644

--- gdb/fbsd-tdep.c

+++ gdb/fbsd-tdep.c

@@ -28,6 +28,70 @@

 #include "fbsd-tdep.h"

+/* This is how we want PTIDs from core files to be printed.  */

+

+static char *

+fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)

+{

+  static char buf[80];

+

+  if (ptid_get_lwp (ptid) != 0)

+    {

+      xsnprintf (buf, sizeof buf, "LWP %ld", ptid_get_lwp (ptid));

+      return buf;

+    }

+

+  return normal_pid_to_str (ptid);

+}

+

+/* Extract the name assigned to a thread from a core.  Returns the

+   string in a static buffer.  */

+

+static const char *

+fbsd_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr)

+{

+  static char buf[80];

+  struct bfd_section *section;

+  bfd_size_type size;

+  char sectionstr[32];

+

+  if (ptid_get_lwp (thr->ptid) != 0)

+    {

+      /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread

+	 whose contents are defined by a "struct thrmisc" declared in

+	 <sys/procfs.h> on FreeBSD.  The per-thread name is stored as

+	 a null-terminated string as the first member of the

+	 structure.  Rather than define the full structure here, just

+	 extract the null-terminated name from the start of the

+	 note.  */

+      xsnprintf (sectionstr, sizeof sectionstr, ".thrmisc/%ld",

+		ptid_get_lwp (thr->ptid));

+      section = bfd_get_section_by_name (core_bfd, sectionstr);

+      if (section != NULL && bfd_section_size (core_bfd, section) > 0)

+	{

+	  /* Truncate the name if it is longer than "buf".  */

+	  size = bfd_section_size (core_bfd, section);

+	  if (size > sizeof buf - 1)

+	    size = sizeof buf - 1;

+	  if (bfd_get_section_contents (core_bfd, section, buf, (file_ptr) 0,

+					size)

+	      && buf[0] != '\0')

+	    {

+	      buf[size] = '\0';

+

+	      /* Note that each thread will report the process command

+		 as its thread name instead of an empty name if a name

+		 has not been set explicitly.  Return a NULL name in

+		 that case.  */

+	      if (strcmp (buf, elf_tdata (core_bfd)->core->program) != 0)

+		return buf;

+	    }

+	}

+    }

+

+  return NULL;

+}

+

 static int

 find_signalled_thread (struct thread_info *info, void *data)

 {

@@ -38,17 +102,9 @@ find_signalled_thread (struct thread_info *info, void *data)

   return 0;

 }

-static enum gdb_signal

-find_stop_signal (void)

-{

-  struct thread_info *info =

-    iterate_over_threads (find_signalled_thread, NULL);

-

-  if (info)

-    return info->suspend.stop_signal;

-  else

-    return GDB_SIGNAL_0;

-}

+/* Structure for passing information from

+   fbsd_collect_thread_registers via an iterator to

+   fbsd_collect_regset_section_cb. */

 struct fbsd_collect_regset_section_cb_data

 {

@@ -56,6 +112,9 @@ struct fbsd_collect_regset_section_cb_data

   bfd *obfd;

   char *note_data;

   int *note_size;

+  unsigned long lwp;

+  enum gdb_signal stop_signal;

+  int abort_iteration;

 };

 static void

@@ -64,7 +123,11 @@ fbsd_collect_regset_section_cb (const char *sect_name, int size,

 				const char *human_name, void *cb_data)

 {

   char *buf;

-  struct fbsd_collect_regset_section_cb_data *data = cb_data;

+  struct fbsd_collect_regset_section_cb_data *data

+    = (struct fbsd_collect_regset_section_cb_data *) cb_data;

+

+  if (data->abort_iteration)

+    return;

   gdb_assert (regset->collect_regset);

@@ -74,13 +137,73 @@ fbsd_collect_regset_section_cb (const char *sect_name, int size,

   /* PRSTATUS still needs to be treated specially.  */

   if (strcmp (sect_name, ".reg") == 0)

     data->note_data = (char *) elfcore_write_prstatus

-      (data->obfd, data->note_data, data->note_size,

-       ptid_get_pid (inferior_ptid), find_stop_signal (), buf);

+      (data->obfd, data->note_data, data->note_size, data->lwp,

+       gdb_signal_to_host (data->stop_signal), buf);

   else

     data->note_data = (char *) elfcore_write_register_note

       (data->obfd, data->note_data, data->note_size,

        sect_name, buf, size);

   xfree (buf);

+

+  if (data->note_data == NULL)

+    data->abort_iteration = 1;

+}

+

+/* Records the thread's register state for the corefile note

+   section.  */

+

+static char *

+fbsd_collect_thread_registers (const struct regcache *regcache,

+			       ptid_t ptid, bfd *obfd,

+			       char *note_data, int *note_size,

+			       enum gdb_signal stop_signal)

+{

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

+  struct fbsd_collect_regset_section_cb_data data;

+

+  data.regcache = regcache;

+  data.obfd = obfd;

+  data.note_data = note_data;

+  data.note_size = note_size;

+  data.stop_signal = stop_signal;

+  data.abort_iteration = 0;

+  data.lwp = ptid_get_lwp (ptid);

+

+  gdbarch_iterate_over_regset_sections (gdbarch,

+					fbsd_collect_regset_section_cb,

+					&data, regcache);

+  return data.note_data;

+}

+

+struct fbsd_corefile_thread_data

+{

+  struct gdbarch *gdbarch;

+  bfd *obfd;

+  char *note_data;

+  int *note_size;

+  enum gdb_signal stop_signal;

+};

+

+/* Records the thread's register state for the corefile note

+   section.  */

+

+static void

+fbsd_corefile_thread (struct thread_info *info,

+		      struct fbsd_corefile_thread_data *args)

+{

+  struct cleanup *old_chain;

+  struct regcache *regcache;

+

+  regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);

+

+  old_chain = save_inferior_ptid ();

+  inferior_ptid = info->ptid;

+  target_fetch_registers (regcache, -1);

+  do_cleanups (old_chain);

+

+  args->note_data = fbsd_collect_thread_registers

+    (regcache, info->ptid, args->obfd, args->note_data,

+     args->note_size, args->stop_signal);

 }

 /* Create appropriate note sections for a corefile, returning them in

@@ -89,10 +212,10 @@ fbsd_collect_regset_section_cb (const char *sect_name, int size,

 static char *

 fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)

 {

-  struct regcache *regcache = get_current_regcache ();

-  char *note_data;

+  struct fbsd_corefile_thread_data thread_args;

+  char *note_data = NULL;

   Elf_Internal_Ehdr *i_ehdrp;

-  struct fbsd_collect_regset_section_cb_data data;

+  struct thread_info *curr_thr, *signalled_thr, *thr;

   /* Put a "FreeBSD" label in the ELF header.  */

   i_ehdrp = elf_elfheader (obfd);

@@ -100,16 +223,6 @@ fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)

   gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch));

-  data.regcache = regcache;

-  data.obfd = obfd;

-  data.note_data = NULL;

-  data.note_size = note_size;

-  target_fetch_registers (regcache, -1);

-  gdbarch_iterate_over_regset_sections (gdbarch,

-					fbsd_collect_regset_section_cb,

-					&data, regcache);

-  note_data = data.note_data;

-

   if (get_exec_file (0))

     {

       const char *fname = lbasename (get_exec_file (0));

@@ -123,6 +236,50 @@ fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)

 					  fname, psargs);

     }

+  /* Thread register information.  */

+  TRY

+    {

+      update_thread_list ();

+    }

+  CATCH (e, RETURN_MASK_ERROR)

+    {

+      exception_print (gdb_stderr, e);

+    }

+  END_CATCH

+

+  /* Like the kernel, prefer dumping the signalled thread first.

+     "First thread" is what tools use to infer the signalled thread.

+     In case there's more than one signalled thread, prefer the

+     current thread, if it is signalled.  */

+  curr_thr = inferior_thread ();

+  if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)

+    signalled_thr = curr_thr;

+  else

+    {

+      signalled_thr = iterate_over_threads (find_signalled_thread, NULL);

+      if (signalled_thr == NULL)

+	signalled_thr = curr_thr;

+    }

+

+  thread_args.gdbarch = gdbarch;

+  thread_args.obfd = obfd;

+  thread_args.note_data = note_data;

+  thread_args.note_size = note_size;

+  thread_args.stop_signal = signalled_thr->suspend.stop_signal;

+

+  fbsd_corefile_thread (signalled_thr, &thread_args);

+  ALL_NON_EXITED_THREADS (thr)

+    {

+      if (thr == signalled_thr)

+	continue;

+      if (ptid_get_pid (thr->ptid) != ptid_get_pid (inferior_ptid))

+	continue;

+

+      fbsd_corefile_thread (thr, &thread_args);

+    }

+

+  note_data = thread_args.note_data;

+

   return note_data;

 }

@@ -131,5 +288,7 @@ fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)

 void

 fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)

 {

+  set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);

+  set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);

   set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);

 }

diff --git gdb/gdbarch.c gdb/gdbarch.c

index c289334..c8e2512 100644

--- gdb/gdbarch.c

+++ gdb/gdbarch.c

@@ -269,6 +269,7 @@ struct gdbarch

   gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries;

   gdbarch_core_xfer_shared_libraries_aix_ftype *core_xfer_shared_libraries_aix;

   gdbarch_core_pid_to_str_ftype *core_pid_to_str;

+  gdbarch_core_thread_name_ftype *core_thread_name;

   const char * gcore_bfd_target;

   int vtable_function_descriptors;

   int vbit_in_delta;

@@ -604,6 +605,7 @@ verify_gdbarch (struct gdbarch *gdbarch)

   /* Skip verify of core_xfer_shared_libraries, has predicate.  */

   /* Skip verify of core_xfer_shared_libraries_aix, has predicate.  */

   /* Skip verify of core_pid_to_str, has predicate.  */

+  /* Skip verify of core_thread_name, has predicate.  */

   /* Skip verify of gcore_bfd_target, has predicate.  */

   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */

   /* Skip verify of vbit_in_delta, invalid_p == 0 */

@@ -816,6 +818,12 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)

                       "gdbarch_dump: core_read_description = <%s>\n",

                       host_address_to_string (gdbarch->core_read_description));

   fprintf_unfiltered (file,

+                      "gdbarch_dump: gdbarch_core_thread_name_p() = %d\n",

+                      gdbarch_core_thread_name_p (gdbarch));

+  fprintf_unfiltered (file,

+                      "gdbarch_dump: core_thread_name = <%s>\n",

+                      host_address_to_string (gdbarch->core_thread_name));

+  fprintf_unfiltered (file,

                       "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",

                       gdbarch_core_xfer_shared_libraries_p (gdbarch));

   fprintf_unfiltered (file,

@@ -3546,6 +3554,30 @@ set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch,

 }

 int

+gdbarch_core_thread_name_p (struct gdbarch *gdbarch)

+{

+  gdb_assert (gdbarch != NULL);

+  return gdbarch->core_thread_name != NULL;

+}

+

+const char *

+gdbarch_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr)

+{

+  gdb_assert (gdbarch != NULL);

+  gdb_assert (gdbarch->core_thread_name != NULL);

+  if (gdbarch_debug >= 2)

+    fprintf_unfiltered (gdb_stdlog, "gdbarch_core_thread_name called\n");

+  return gdbarch->core_thread_name (gdbarch, thr);

+}

+

+void

+set_gdbarch_core_thread_name (struct gdbarch *gdbarch,

+                              gdbarch_core_thread_name_ftype core_thread_name)

+{

+  gdbarch->core_thread_name = core_thread_name;

+}

+

+int

 gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch)

 {

   gdb_assert (gdbarch != NULL);

diff --git gdb/gdbarch.h gdb/gdbarch.h

index 7d6a0cf..4dab0f7 100644

--- gdb/gdbarch.h

+++ gdb/gdbarch.h

@@ -64,6 +64,7 @@ struct ravenscar_arch_ops;

 struct elf_internal_linux_prpsinfo;

 struct mem_range;

 struct syscalls_info;

+struct thread_info;

 #include "regcache.h"

@@ -866,6 +867,14 @@ typedef char * (gdbarch_core_pid_to_str_ftype) (struct gdbarch *gdbarch, ptid_t

 extern char * gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid);

 extern void set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch, gdbarch_core_pid_to_str_ftype *core_pid_to_str);

+/* How the core target extracts the name of a thread from a core file. */

+

+extern int gdbarch_core_thread_name_p (struct gdbarch *gdbarch);

+

+typedef const char * (gdbarch_core_thread_name_ftype) (struct gdbarch *gdbarch, struct thread_info *thr);

+extern const char * gdbarch_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr);

+extern void set_gdbarch_core_thread_name (struct gdbarch *gdbarch, gdbarch_core_thread_name_ftype *core_thread_name);

+

 /* BFD target to use when generating a core file. */

 extern int gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch);

diff --git gdb/i386bsd-nat.c gdb/i386bsd-nat.c

index ac8a19b..922c0e7 100644

--- gdb/i386bsd-nat.c

+++ gdb/i386bsd-nat.c

@@ -138,7 +138,7 @@ i386bsd_fetch_inferior_registers (struct target_ops *ops,

     {

       struct reg regs;

-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),

 		  (PTRACE_TYPE_ARG3) &regs, 0) == -1)

 	perror_with_name (_("Couldn't get registers"));

@@ -160,7 +160,7 @@ i386bsd_fetch_inferior_registers (struct target_ops *ops,

 	  char *xstateregs;

 	  xstateregs = alloca (i386bsd_xsave_len);

-	  if (ptrace (PT_GETXSTATE, ptid_get_pid (inferior_ptid),

+	  if (ptrace (PT_GETXSTATE, get_ptrace_pid (inferior_ptid),

 		      (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)

 	    perror_with_name (_("Couldn't get extended state status"));

@@ -171,7 +171,7 @@ i386bsd_fetch_inferior_registers (struct target_ops *ops,

 #ifdef HAVE_PT_GETXMMREGS

       if (have_ptrace_xmmregs != 0

-	  && ptrace(PT_GETXMMREGS, ptid_get_pid (inferior_ptid),

+	  && ptrace(PT_GETXMMREGS, get_ptrace_pid (inferior_ptid),

 		    (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)

 	{

 	  have_ptrace_xmmregs = 1;

@@ -181,7 +181,7 @@ i386bsd_fetch_inferior_registers (struct target_ops *ops,

 	{

 	  have_ptrace_xmmregs = 0;

 #endif

-          if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),

+          if (ptrace (PT_GETFPREGS, get_ptrace_pid (inferior_ptid),

 		      (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

 	    perror_with_name (_("Couldn't get floating point status"));

@@ -203,13 +203,13 @@ i386bsd_store_inferior_registers (struct target_ops *ops,

     {

       struct reg regs;

-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),

                   (PTRACE_TYPE_ARG3) &regs, 0) == -1)

         perror_with_name (_("Couldn't get registers"));

       i386bsd_collect_gregset (regcache, &regs, regnum);

-      if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_SETREGS, get_ptrace_pid (inferior_ptid),

 	          (PTRACE_TYPE_ARG3) &regs, 0) == -1)

         perror_with_name (_("Couldn't write registers"));

@@ -230,13 +230,13 @@ i386bsd_store_inferior_registers (struct target_ops *ops,

 	  char *xstateregs;

 	  xstateregs = alloca (i386bsd_xsave_len);

-	  if (ptrace (PT_GETXSTATE, ptid_get_pid (inferior_ptid),

+	  if (ptrace (PT_GETXSTATE, get_ptrace_pid (inferior_ptid),

 		      (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)

 	    perror_with_name (_("Couldn't get extended state status"));

 	  i387_collect_xsave (regcache, -1, xstateregs, 0);

-	  if (ptrace (PT_SETXSTATE, ptid_get_pid (inferior_ptid),

+	  if (ptrace (PT_SETXSTATE, get_ptrace_pid (inferior_ptid),

 		      (PTRACE_TYPE_ARG3) xstateregs, i386bsd_xsave_len) == -1)

 	    perror_with_name (_("Couldn't write extended state status"));

 	  return;

@@ -245,14 +245,14 @@ i386bsd_store_inferior_registers (struct target_ops *ops,

 #ifdef HAVE_PT_GETXMMREGS

       if (have_ptrace_xmmregs != 0

-	  && ptrace(PT_GETXMMREGS, ptid_get_pid (inferior_ptid),

+	  && ptrace(PT_GETXMMREGS, get_ptrace_pid (inferior_ptid),

 		    (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)

 	{

 	  have_ptrace_xmmregs = 1;

 	  i387_collect_fxsave (regcache, regnum, xmmregs);

-	  if (ptrace (PT_SETXMMREGS, ptid_get_pid (inferior_ptid),

+	  if (ptrace (PT_SETXMMREGS, get_ptrace_pid (inferior_ptid),

 		      (PTRACE_TYPE_ARG3) xmmregs, 0) == -1)

             perror_with_name (_("Couldn't write XMM registers"));

 	}

@@ -260,13 +260,13 @@ i386bsd_store_inferior_registers (struct target_ops *ops,

 	{

 	  have_ptrace_xmmregs = 0;

 #endif

-          if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),

+          if (ptrace (PT_GETFPREGS, get_ptrace_pid (inferior_ptid),

 		      (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

 	    perror_with_name (_("Couldn't get floating point status"));

           i387_collect_fsave (regcache, regnum, &fpregs);

-          if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),

+          if (ptrace (PT_SETFPREGS, get_ptrace_pid (inferior_ptid),

 		      (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

 	    perror_with_name (_("Couldn't write floating point status"));

 #ifdef HAVE_PT_GETXMMREGS

@@ -305,7 +305,7 @@ i386bsd_dr_get (ptid_t ptid, int regnum)

 {

   struct dbreg dbregs;

-  if (ptrace (PT_GETDBREGS, ptid_get_pid (inferior_ptid),

+  if (ptrace (PT_GETDBREGS, get_ptrace_pid (inferior_ptid),

 	      (PTRACE_TYPE_ARG3) &dbregs, 0) == -1)

     perror_with_name (_("Couldn't read debug registers"));

@@ -317,7 +317,7 @@ i386bsd_dr_set (int regnum, unsigned int value)

 {

   struct dbreg dbregs;

-  if (ptrace (PT_GETDBREGS, ptid_get_pid (inferior_ptid),

+  if (ptrace (PT_GETDBREGS, get_ptrace_pid (inferior_ptid),

               (PTRACE_TYPE_ARG3) &dbregs, 0) == -1)

     perror_with_name (_("Couldn't get debug registers"));

@@ -328,7 +328,7 @@ i386bsd_dr_set (int regnum, unsigned int value)

   DBREG_DRX ((&dbregs), regnum) = value;

-  if (ptrace (PT_SETDBREGS, ptid_get_pid (inferior_ptid),

+  if (ptrace (PT_SETDBREGS, get_ptrace_pid (inferior_ptid),

               (PTRACE_TYPE_ARG3) &dbregs, 0) == -1)

     perror_with_name (_("Couldn't write debug registers"));

 }

diff --git gdb/inf-ptrace.c gdb/inf-ptrace.c

index cd58dfb..06c4e4f 100644

--- gdb/inf-ptrace.c

+++ gdb/inf-ptrace.c

@@ -304,7 +304,7 @@ inf_ptrace_stop (struct target_ops *self, ptid_t ptid)

 /* Return which PID to pass to ptrace in order to observe/control the

    tracee identified by PTID.  */

-static pid_t

+pid_t

 get_ptrace_pid (ptid_t ptid)

 {

   pid_t pid;

diff --git gdb/inf-ptrace.h gdb/inf-ptrace.h

index e74ec84..504821b 100644

--- gdb/inf-ptrace.h

+++ gdb/inf-ptrace.h

@@ -33,4 +33,9 @@ extern struct target_ops *

   inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)

 					(struct gdbarch *, int, int));

+/* Return which PID to pass to ptrace in order to observe/control the

+   tracee identified by PTID.  */

+

+extern pid_t get_ptrace_pid (ptid_t);

+

 #endif

diff --git gdb/ppcfbsd-nat.c gdb/ppcfbsd-nat.c

index 778e19a..df89c2d 100644

--- gdb/ppcfbsd-nat.c

+++ gdb/ppcfbsd-nat.c

@@ -121,7 +121,7 @@ ppcfbsd_fetch_inferior_registers (struct target_ops *ops,

 {

   gdb_gregset_t regs;

-  if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),

+  if (ptrace (PT_GETREGS, ptid_get_lwp (inferior_ptid),

 	      (PTRACE_TYPE_ARG3) &regs, 0) == -1)

     perror_with_name (_("Couldn't get registers"));

@@ -132,7 +132,7 @@ ppcfbsd_fetch_inferior_registers (struct target_ops *ops,

       const struct regset *fpregset = ppc_fbsd_fpregset ();

       gdb_fpregset_t fpregs;

-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_GETFPREGS, ptid_get_lwp (inferior_ptid),

 		  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

 	perror_with_name (_("Couldn't get FP registers"));

@@ -149,13 +149,13 @@ ppcfbsd_store_inferior_registers (struct target_ops *ops,

 {

   gdb_gregset_t regs;

-  if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),

+  if (ptrace (PT_GETREGS, ptid_get_lwp (inferior_ptid),

 	      (PTRACE_TYPE_ARG3) &regs, 0) == -1)

     perror_with_name (_("Couldn't get registers"));

   fill_gregset (regcache, &regs, regno);

-  if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),

+  if (ptrace (PT_SETREGS, ptid_get_lwp (inferior_ptid),

 	      (PTRACE_TYPE_ARG3) &regs, 0) == -1)

     perror_with_name (_("Couldn't write registers"));

@@ -163,13 +163,13 @@ ppcfbsd_store_inferior_registers (struct target_ops *ops,

     {

       gdb_fpregset_t fpregs;

-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_GETFPREGS, ptid_get_lwp (inferior_ptid),

 		  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

 	perror_with_name (_("Couldn't get FP registers"));

       fill_fpregset (regcache, &fpregs, regno);

-      if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),

+      if (ptrace (PT_SETFPREGS, ptid_get_lwp (inferior_ptid),

 		  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

 	perror_with_name (_("Couldn't set FP registers"));

     }

diff --git include/elf/common.h include/elf/common.h

index e6d8c14..39582df 100644

--- include/elf/common.h

+++ include/elf/common.h

@@ -594,6 +594,20 @@

 /* Note segment for SystemTap probes.  */

 #define NT_STAPSDT	3

+/* Note segments for core files on FreeBSD systems.  Note name is

+   "FreeBSD".  */

+

+#define	NT_FREEBSD_THRMISC	7	/* Thread miscellaneous info. */

+#define	NT_FREEBSD_PROCSTAT_PROC	8	/* Procstat proc data. */

+#define	NT_FREEBSD_PROCSTAT_FILES	9	/* Procstat files data. */

+#define	NT_FREEBSD_PROCSTAT_VMMAP	10	/* Procstat vmmap data. */

+#define	NT_FREEBSD_PROCSTAT_GROUPS	11	/* Procstat groups data. */

+#define	NT_FREEBSD_PROCSTAT_UMASK	12	/* Procstat umask data. */

+#define	NT_FREEBSD_PROCSTAT_RLIMIT	13	/* Procstat rlimit data. */

+#define	NT_FREEBSD_PROCSTAT_OSREL	14	/* Procstat osreldate data. */

+#define	NT_FREEBSD_PROCSTAT_PSSTRINGS	15	/* Procstat ps_strings data. */

+#define	NT_FREEBSD_PROCSTAT_AUXV	16	/* Procstat auxv data. */

+

 /* Note segments for core files on NetBSD systems.  Note name

    must start with "NetBSD-CORE".  */