+#endif
+
+#ifdef KERN_PROC_AUXV
+static enum target_xfer_status (*super_xfer_partial) (struct target_ops *ops,
+ enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset,
+ ULONGEST len,
+ ULONGEST *xfered_len);
+
+#ifdef PT_LWPINFO
+/* Return the size of siginfo for the current inferior. */
+
+#ifdef __LP64__
+union sigval32 {
+ int sival_int;
+ uint32_t sival_ptr;
+};
+
+/* This structure matches the naming and layout of `siginfo_t' in
+ <sys/signal.h>. In particular, the `si_foo' macros defined in that
+ header can be used with both types to copy fields in the `_reason'
+ union. */
+
+struct siginfo32
+{
+ int si_signo;
+ int si_errno;
+ int si_code;
+ __pid_t si_pid;
+ __uid_t si_uid;
+ int si_status;
+ uint32_t si_addr;
+ union sigval32 si_value;
+ union
+ {
+ struct
+ {
+ int _trapno;
+ } _fault;
+ struct
+ {
+ int _timerid;
+ int _overrun;
+ } _timer;
+ struct
+ {
+ int _mqd;
+ } _mesgq;
+ struct
+ {
+ int32_t _band;
+ } _poll;
+ struct
+ {
+ int32_t __spare1__;
+ int __spare2__[7];
+ } __spare__;
+ } _reason;
+};
+#endif
+
+static size_t
+fbsd_siginfo_size ()
+{
+#ifdef __LP64__
+ struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
+
+ /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
+ if (gdbarch_long_bit (gdbarch) == 32)
+ return sizeof (struct siginfo32);
+#endif
+ return sizeof (siginfo_t);
+}
+
+/* Convert a native 64-bit siginfo object to a 32-bit object. Note
+ that FreeBSD doesn't support writing to $_siginfo, so this only
+ needs to convert one way. */
+
+static void
+fbsd_convert_siginfo (siginfo_t *si)
+{
+#ifdef __LP64__
+ struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
+
+ /* Is the inferior 32-bit? If not, nothing to do. */
+ if (gdbarch_long_bit (gdbarch) != 32)
+ return;
+
+ struct siginfo32 si32;
+
+ si32.si_signo = si->si_signo;
+ si32.si_errno = si->si_errno;
+ si32.si_code = si->si_code;
+ si32.si_pid = si->si_pid;
+ si32.si_uid = si->si_uid;
+ si32.si_status = si->si_status;
+ si32.si_addr = (uintptr_t) si->si_addr;
+
+ /* If sival_ptr is being used instead of sival_int on a big-endian
+ platform, then sival_int will be zero since it holds the upper
+ 32-bits of the pointer value. */
+#if _BYTE_ORDER == _BIG_ENDIAN
+ if (si->si_value.sival_int == 0)
+ si32.si_value.sival_ptr = (uintptr_t) si->si_value.sival_ptr;
+ else
+ si32.si_value.sival_int = si->si_value.sival_int;
+#else
+ si32.si_value.sival_int = si->si_value.sival_int;
+#endif
+
+ /* Always copy the spare fields and then possibly overwrite them for
+ signal-specific or code-specific fields. */
+ si32._reason.__spare__.__spare1__ = si->_reason.__spare__.__spare1__;
+ for (int i = 0; i < 7; i++)
+ si32._reason.__spare__.__spare2__[i] = si->_reason.__spare__.__spare2__[i];
+ switch (si->si_signo) {
+ case SIGILL:
+ case SIGFPE:
+ case SIGSEGV:
+ case SIGBUS:
+ si32.si_trapno = si->si_trapno;
+ break;
+ }
+ switch (si->si_code) {
+ case SI_TIMER:
+ si32.si_timerid = si->si_timerid;
+ si32.si_overrun = si->si_overrun;
+ break;
+ case SI_MESGQ:
+ si32.si_mqd = si->si_mqd;
+ break;
+ }
+
+ memcpy(si, &si32, sizeof (si32));
+#endif
+}
+#endif
+
+/* Implement the "to_xfer_partial target_ops" method. */
+
+static enum target_xfer_status
+fbsd_xfer_partial (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
+{
+ pid_t pid = ptid_get_pid (inferior_ptid);
+
+ switch (object)
+ {
+#ifdef PT_LWPINFO
+ case TARGET_OBJECT_SIGNAL_INFO:
+ {
+ struct ptrace_lwpinfo pl;
+ size_t siginfo_size;
+
+ /* FreeBSD doesn't support writing to $_siginfo. */
+ if (writebuf != NULL)
+ return TARGET_XFER_E_IO;
+
+ if (inferior_ptid.lwp_p ())
+ pid = inferior_ptid.lwp ();
+
+ siginfo_size = fbsd_siginfo_size ();
+ if (offset > siginfo_size)
+ return TARGET_XFER_E_IO;
+
+ if (ptrace (PT_LWPINFO, pid, (PTRACE_TYPE_ARG3) &pl, sizeof (pl)) == -1)
+ return TARGET_XFER_E_IO;
+
+ if (!(pl.pl_flags & PL_FLAG_SI))
+ return TARGET_XFER_E_IO;
+
+ fbsd_convert_siginfo (&pl.pl_siginfo);
+ if (offset + len > siginfo_size)
+ len = siginfo_size - offset;
+
+ memcpy (readbuf, ((gdb_byte *) &pl.pl_siginfo) + offset, len);
+ *xfered_len = len;
+ return TARGET_XFER_OK;
+ }
+#endif
+ case TARGET_OBJECT_AUXV:
+ {
+ gdb::byte_vector buf_storage;
+ gdb_byte *buf;
+ size_t buflen;
+ int mib[4];
+
+ if (writebuf != NULL)
+ return TARGET_XFER_E_IO;
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_AUXV;
+ mib[3] = pid;
+ if (offset == 0)
+ {
+ buf = readbuf;
+ buflen = len;
+ }
+ else
+ {
+ buflen = offset + len;
+ buf_storage.resize (buflen);
+ buf = buf_storage.data ();
+ }
+ if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
+ {
+ if (offset != 0)
+ {
+ if (buflen > offset)
+ {
+ buflen -= offset;
+ memcpy (readbuf, buf + offset, buflen);
+ }
+ else
+ buflen = 0;
+ }
+ *xfered_len = buflen;
+ return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
+ }
+ return TARGET_XFER_E_IO;
+ }
+ default:
+ return super_xfer_partial (ops, object, annex, readbuf, writebuf, offset,
+ len, xfered_len);
+ }
+}
+#endif
+
+#ifdef PT_LWPINFO
+static int debug_fbsd_lwp;
+
+static void (*super_resume) (struct target_ops *,
+ ptid_t,
+ int,
+ enum gdb_signal);
+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 was 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. */