MFC r303818, r303833, r303941, r304478, r304481, r304483, r304484, r304554,

    r304555, r304556, r304557, r304558, r304559, r304561, r304563, r304564,
    r304565, r304615, r304742, r304743, r304744, r304745, r304748, r304886,
    r304991, r305928, r305938, r305987, r306185:

  Bring CloudABI support back in sync with HEAD.

  - Add support for running 32-bit executables on amd64, armv6 and i386.

  - As these new architectures require the use of the vDSO, merge back
    vDSO support for 64-bit executables running on amd64 and arm64 as
    well. This has the advantage that support for vDSO-less execution
    can be phased out when 11.0 becomes unsupported, as opposed to 11.x.

  This change has been tested by running the cloudlibc unit tests on all
  supported architectures, which seems to work fine.

13 files changed, 3400 insertions, 0 deletions

diff --git a/sys/compat/cloudabi32/Makefile b/sys/compat/cloudabi32/Makefile
new file mode 100644
index 0000000..5d1ff52
--- /dev/null
+++ b/sys/compat/cloudabi32/Makefile
@@ -0,0 +1,14 @@
+# $FreeBSD$
+
+all:
+	@echo "make sysent only"
+
+sysent: cloudabi32_sysent.c cloudabi32_syscall.h cloudabi32_proto.h \
+    cloudabi32_syscalls.c cloudabi32_systrace_args.c
+
+cloudabi32_sysent.c cloudabi32_syscall.h cloudabi32_proto.h \
+    cloudabi32_syscalls.c cloudabi32_systrace_args.c: \
+    ../../kern/makesyscalls.sh ../../contrib/cloudabi/syscalls32.master \
+    syscalls.conf
+	sh ../../kern/makesyscalls.sh ../../contrib/cloudabi/syscalls32.master \
+	    syscalls.conf
diff --git a/sys/compat/cloudabi32/cloudabi32_fd.c b/sys/compat/cloudabi32/cloudabi32_fd.c
new file mode 100644
index 0000000..1754c48
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_fd.c
@@ -0,0 +1,145 @@
+/*-
+ * Copyright (c) 2015 Nuxi, https://nuxi.nl/
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/limits.h>
+#include <sys/malloc.h>
+#include <sys/syscallsubr.h>
+#include <sys/systm.h>
+#include <sys/uio.h>
+
+#include <contrib/cloudabi/cloudabi32_types.h>
+
+#include <compat/cloudabi32/cloudabi32_proto.h>
+#include <compat/cloudabi32/cloudabi32_util.h>
+
+/* Copies in 32-bit iovec structures from userspace. */
+static int
+cloudabi32_copyinuio(const cloudabi32_iovec_t *iovp, size_t iovcnt,
+    struct uio **uiop)
+{
+	cloudabi32_iovec_t iovobj;
+	struct uio *uio;
+	struct iovec *iov;
+	size_t i;
+	int error;
+
+	/* Allocate uio and iovecs. */
+	if (iovcnt > UIO_MAXIOV)
+		return (EINVAL);
+	uio = malloc(sizeof(struct uio) + iovcnt * sizeof(struct iovec),
+	    M_IOV, M_WAITOK);
+	iov = (struct iovec *)(uio + 1);
+
+	/* Initialize uio. */
+	uio->uio_iov = iov;
+	uio->uio_iovcnt = iovcnt;
+	uio->uio_segflg = UIO_USERSPACE;
+	uio->uio_offset = -1;
+	uio->uio_resid = 0;
+
+	/* Copy in iovecs. */
+	for (i = 0; i < iovcnt; i++) {
+		error = copyin(&iovp[i], &iovobj, sizeof(iovobj));
+		if (error != 0) {
+			free(uio, M_IOV);
+			return (error);
+		}
+		iov[i].iov_base = TO_PTR(iovobj.iov_base);
+		iov[i].iov_len = iovobj.iov_len;
+		if (iov[i].iov_len > INT32_MAX - uio->uio_resid) {
+			free(uio, M_IOV);
+			return (EINVAL);
+		}
+		uio->uio_resid += iov[i].iov_len;
+	}
+
+	*uiop = uio;
+	return (0);
+}
+
+int
+cloudabi32_sys_fd_pread(struct thread *td,
+    struct cloudabi32_sys_fd_pread_args *uap)
+{
+	struct uio *uio;
+	int error;
+
+	error = cloudabi32_copyinuio(uap->iov, uap->iovcnt, &uio);
+	if (error != 0)
+		return (error);
+	error = kern_preadv(td, uap->fd, uio, uap->offset);
+	free(uio, M_IOV);
+	return (error);
+}
+
+int
+cloudabi32_sys_fd_pwrite(struct thread *td,
+    struct cloudabi32_sys_fd_pwrite_args *uap)
+{
+	struct uio *uio;
+	int error;
+
+	error = cloudabi32_copyinuio(TO_PTR(uap->iov), uap->iovcnt, &uio);
+	if (error != 0)
+		return (error);
+	error = kern_pwritev(td, uap->fd, uio, uap->offset);
+	free(uio, M_IOV);
+	return (error);
+}
+
+int
+cloudabi32_sys_fd_read(struct thread *td,
+    struct cloudabi32_sys_fd_read_args *uap)
+{
+	struct uio *uio;
+	int error;
+
+	error = cloudabi32_copyinuio(uap->iov, uap->iovcnt, &uio);
+	if (error != 0)
+		return (error);
+	error = kern_readv(td, uap->fd, uio);
+	free(uio, M_IOV);
+	return (error);
+}
+
+int
+cloudabi32_sys_fd_write(struct thread *td,
+    struct cloudabi32_sys_fd_write_args *uap)
+{
+	struct uio *uio;
+	int error;
+
+	error = cloudabi32_copyinuio(TO_PTR(uap->iov), uap->iovcnt, &uio);
+	if (error != 0)
+		return (error);
+	error = kern_writev(td, uap->fd, uio);
+	free(uio, M_IOV);
+	return (error);
+}
diff --git a/sys/compat/cloudabi32/cloudabi32_module.c b/sys/compat/cloudabi32/cloudabi32_module.c
new file mode 100644
index 0000000..3e4e4a7
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_module.c
@@ -0,0 +1,167 @@
+/*-
+ * Copyright (c) 2015 Nuxi, https://nuxi.nl/
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/imgact.h>
+#include <sys/kernel.h>
+#include <sys/module.h>
+#include <sys/proc.h>
+#include <sys/smp.h>
+#include <sys/sysctl.h>
+#include <sys/sysent.h>
+#include <sys/systm.h>
+
+#include <contrib/cloudabi/cloudabi32_types.h>
+
+#include <compat/cloudabi/cloudabi_util.h>
+
+#include <compat/cloudabi32/cloudabi32_util.h>
+
+extern char _binary_cloudabi32_vdso_o_start[];
+extern char _binary_cloudabi32_vdso_o_end[];
+
+register_t *
+cloudabi32_copyout_strings(struct image_params *imgp)
+{
+	struct image_args *args;
+	uintptr_t begin;
+	size_t len;
+
+	/* Copy out program arguments. */
+	args = imgp->args;
+	len = args->begin_envv - args->begin_argv;
+	begin = rounddown2(imgp->sysent->sv_usrstack - len, sizeof(register_t));
+	copyout(args->begin_argv, (void *)begin, len);
+	return ((register_t *)begin);
+}
+
+int
+cloudabi32_fixup(register_t **stack_base, struct image_params *imgp)
+{
+	char canarybuf[64];
+	Elf32_Auxargs *args;
+	struct thread *td;
+	void *argdata, *canary;
+	size_t argdatalen;
+	int error;
+
+	/*
+	 * CloudABI executables do not store the FreeBSD OS release
+	 * number in their header. Set the OS release number to the
+	 * latest version of FreeBSD, so that system calls behave as if
+	 * called natively.
+	 */
+	td = curthread;
+	td->td_proc->p_osrel = __FreeBSD_version;
+
+	/* Store canary for stack smashing protection. */
+	argdata = *stack_base;
+	arc4rand(canarybuf, sizeof(canarybuf), 0);
+	*stack_base -= howmany(sizeof(canarybuf), sizeof(register_t));
+	canary = *stack_base;
+	error = copyout(canarybuf, canary, sizeof(canarybuf));
+	if (error != 0)
+		return (error);
+
+	/*
+	 * Compute length of program arguments. As the argument data is
+	 * binary safe, we had to add a trailing null byte in
+	 * exec_copyin_data_fds(). Undo this by reducing the length.
+	 */
+	args = (Elf32_Auxargs *)imgp->auxargs;
+	argdatalen = imgp->args->begin_envv - imgp->args->begin_argv;
+	if (argdatalen > 0)
+		--argdatalen;
+
+	/* Write out an auxiliary vector. */
+	cloudabi32_auxv_t auxv[] = {
+#define	VAL(type, val)	{ .a_type = (type), .a_val = (val) }
+#define	PTR(type, ptr)	{ .a_type = (type), .a_ptr = (uintptr_t)(ptr) }
+		PTR(CLOUDABI_AT_ARGDATA, argdata),
+		VAL(CLOUDABI_AT_ARGDATALEN, argdatalen),
+		VAL(CLOUDABI_AT_BASE, args->base),
+		PTR(CLOUDABI_AT_CANARY, canary),
+		VAL(CLOUDABI_AT_CANARYLEN, sizeof(canarybuf)),
+		VAL(CLOUDABI_AT_NCPUS, mp_ncpus),
+		VAL(CLOUDABI_AT_PAGESZ, args->pagesz),
+		PTR(CLOUDABI_AT_PHDR, args->phdr),
+		VAL(CLOUDABI_AT_PHNUM, args->phnum),
+		VAL(CLOUDABI_AT_TID, td->td_tid),
+		PTR(CLOUDABI_AT_SYSINFO_EHDR,
+		    imgp->proc->p_sysent->sv_shared_page_base),
+#undef VAL
+#undef PTR
+		{ .a_type = CLOUDABI_AT_NULL },
+	};
+	*stack_base -= howmany(sizeof(auxv), sizeof(register_t));
+	error = copyout(auxv, *stack_base, sizeof(auxv));
+	if (error != 0)
+		return (error);
+
+	/* Reserve space for storing the TCB. */
+	*stack_base -= howmany(sizeof(cloudabi32_tcb_t), sizeof(register_t));
+	return (0);
+}
+
+static int
+cloudabi32_modevent(module_t mod, int type, void *data)
+{
+
+	switch (type) {
+	case MOD_LOAD:
+		cloudabi_vdso_init(cloudabi32_brand.sysvec,
+		    _binary_cloudabi32_vdso_o_start,
+		    _binary_cloudabi32_vdso_o_end);
+		if (elf32_insert_brand_entry(&cloudabi32_brand) < 0) {
+			printf("Failed to add CloudABI ELF brand handler\n");
+			return (EINVAL);
+		}
+		return (0);
+	case MOD_UNLOAD:
+		if (elf32_brand_inuse(&cloudabi32_brand))
+			return (EBUSY);
+		if (elf32_remove_brand_entry(&cloudabi32_brand) < 0) {
+			printf("Failed to remove CloudABI ELF brand handler\n");
+			return (EINVAL);
+		}
+		cloudabi_vdso_destroy(cloudabi32_brand.sysvec);
+		return (0);
+	default:
+		return (EOPNOTSUPP);
+	}
+}
+
+static moduledata_t cloudabi32_module = {
+	"cloudabi32",
+	cloudabi32_modevent,
+	NULL
+};
+
+DECLARE_MODULE_TIED(cloudabi32, cloudabi32_module, SI_SUB_EXEC, SI_ORDER_ANY);
+MODULE_DEPEND(cloudabi32, cloudabi, 1, 1, 1);
+FEATURE(cloudabi32, "CloudABI 32bit support");
diff --git a/sys/compat/cloudabi32/cloudabi32_poll.c b/sys/compat/cloudabi32/cloudabi32_poll.c
new file mode 100644
index 0000000..5215580
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_poll.c
@@ -0,0 +1,408 @@
+/*-
+ * Copyright (c) 2015 Nuxi, https://nuxi.nl/
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/proc.h>
+#include <sys/syscallsubr.h>
+
+#include <contrib/cloudabi/cloudabi32_types.h>
+
+#include <compat/cloudabi/cloudabi_util.h>
+
+#include <compat/cloudabi32/cloudabi32_proto.h>
+#include <compat/cloudabi32/cloudabi32_util.h>
+
+/* Converts a FreeBSD signal number to a CloudABI signal number. */
+static cloudabi_signal_t
+convert_signal(int sig)
+{
+	static const cloudabi_signal_t signals[] = {
+		[SIGABRT]	= CLOUDABI_SIGABRT,
+		[SIGALRM]	= CLOUDABI_SIGALRM,
+		[SIGBUS]	= CLOUDABI_SIGBUS,
+		[SIGCHLD]	= CLOUDABI_SIGCHLD,
+		[SIGCONT]	= CLOUDABI_SIGCONT,
+		[SIGFPE]	= CLOUDABI_SIGFPE,
+		[SIGHUP]	= CLOUDABI_SIGHUP,
+		[SIGILL]	= CLOUDABI_SIGILL,
+		[SIGINT]	= CLOUDABI_SIGINT,
+		[SIGKILL]	= CLOUDABI_SIGKILL,
+		[SIGPIPE]	= CLOUDABI_SIGPIPE,
+		[SIGQUIT]	= CLOUDABI_SIGQUIT,
+		[SIGSEGV]	= CLOUDABI_SIGSEGV,
+		[SIGSTOP]	= CLOUDABI_SIGSTOP,
+		[SIGSYS]	= CLOUDABI_SIGSYS,
+		[SIGTERM]	= CLOUDABI_SIGTERM,
+		[SIGTRAP]	= CLOUDABI_SIGTRAP,
+		[SIGTSTP]	= CLOUDABI_SIGTSTP,
+		[SIGTTIN]	= CLOUDABI_SIGTTIN,
+		[SIGTTOU]	= CLOUDABI_SIGTTOU,
+		[SIGURG]	= CLOUDABI_SIGURG,
+		[SIGUSR1]	= CLOUDABI_SIGUSR1,
+		[SIGUSR2]	= CLOUDABI_SIGUSR2,
+		[SIGVTALRM]	= CLOUDABI_SIGVTALRM,
+		[SIGXCPU]	= CLOUDABI_SIGXCPU,
+		[SIGXFSZ]	= CLOUDABI_SIGXFSZ,
+	};
+
+	/* Convert unknown signals to SIGABRT. */
+	if (sig < 0 || sig >= nitems(signals) || signals[sig] == 0)
+		return (SIGABRT);
+	return (signals[sig]);
+}
+
+struct cloudabi32_kevent_args {
+	const cloudabi32_subscription_t *in;
+	cloudabi32_event_t *out;
+	bool once;
+};
+
+/* Converts CloudABI's subscription objects to FreeBSD's struct kevent. */
+static int
+cloudabi32_kevent_copyin(void *arg, struct kevent *kevp, int count)
+{
+	cloudabi32_subscription_t sub;
+	struct cloudabi32_kevent_args *args;
+	cloudabi_timestamp_t ts;
+	int error;
+
+	args = arg;
+	while (count-- > 0) {
+		/* TODO(ed): Copy in multiple entries at once. */
+		error = copyin(args->in++, &sub, sizeof(sub));
+		if (error != 0)
+			return (error);
+
+		memset(kevp, 0, sizeof(*kevp));
+		kevp->udata = TO_PTR(sub.userdata);
+		switch (sub.type) {
+		case CLOUDABI_EVENTTYPE_CLOCK:
+			kevp->filter = EVFILT_TIMER;
+			kevp->ident = sub.clock.identifier;
+			kevp->fflags = NOTE_NSECONDS;
+			if ((sub.clock.flags &
+			    CLOUDABI_SUBSCRIPTION_CLOCK_ABSTIME) != 0 &&
+			    sub.clock.timeout > 0) {
+				/* Convert absolute timestamp to a relative. */
+				error = cloudabi_clock_time_get(curthread,
+				    sub.clock.clock_id, &ts);
+				if (error != 0)
+					return (error);
+				ts = ts > sub.clock.timeout ? 0 :
+				    sub.clock.timeout - ts;
+			} else {
+				/* Relative timestamp. */
+				ts = sub.clock.timeout;
+			}
+			kevp->data = ts > INTPTR_MAX ? INTPTR_MAX : ts;
+			break;
+		case CLOUDABI_EVENTTYPE_FD_READ:
+			kevp->filter = EVFILT_READ;
+			kevp->ident = sub.fd_readwrite.fd;
+			if ((sub.fd_readwrite.flags &
+			    CLOUDABI_SUBSCRIPTION_FD_READWRITE_POLL) != 0)
+				kevp->fflags = NOTE_FILE_POLL;
+			break;
+		case CLOUDABI_EVENTTYPE_FD_WRITE:
+			kevp->filter = EVFILT_WRITE;
+			kevp->ident = sub.fd_readwrite.fd;
+			break;
+		case CLOUDABI_EVENTTYPE_PROC_TERMINATE:
+			kevp->filter = EVFILT_PROCDESC;
+			kevp->ident = sub.proc_terminate.fd;
+			kevp->fflags = NOTE_EXIT;
+			break;
+		}
+		if (args->once) {
+			/* Ignore flags. Simply use oneshot mode. */
+			kevp->flags = EV_ADD | EV_ONESHOT;
+		} else {
+			/* Translate flags. */
+			if ((sub.flags & CLOUDABI_SUBSCRIPTION_ADD) != 0)
+				kevp->flags |= EV_ADD;
+			if ((sub.flags & CLOUDABI_SUBSCRIPTION_CLEAR) != 0)
+				kevp->flags |= EV_CLEAR;
+			if ((sub.flags & CLOUDABI_SUBSCRIPTION_DELETE) != 0)
+				kevp->flags |= EV_DELETE;
+			if ((sub.flags & CLOUDABI_SUBSCRIPTION_DISABLE) != 0)
+				kevp->flags |= EV_DISABLE;
+			if ((sub.flags & CLOUDABI_SUBSCRIPTION_ENABLE) != 0)
+				kevp->flags |= EV_ENABLE;
+			if ((sub.flags & CLOUDABI_SUBSCRIPTION_ONESHOT) != 0)
+				kevp->flags |= EV_ONESHOT;
+		}
+		++kevp;
+	}
+	return (0);
+}
+
+/* Converts FreeBSD's struct kevent to CloudABI's event objects. */
+static int
+cloudabi32_kevent_copyout(void *arg, struct kevent *kevp, int count)
+{
+	cloudabi32_event_t ev;
+	struct cloudabi32_kevent_args *args;
+	int error;
+
+	args = arg;
+	while (count-- > 0) {
+		/* Convert fields that should always be present. */
+		memset(&ev, 0, sizeof(ev));
+		ev.userdata = (uintptr_t)kevp->udata;
+		switch (kevp->filter) {
+		case EVFILT_TIMER:
+			ev.type = CLOUDABI_EVENTTYPE_CLOCK;
+			ev.clock.identifier = kevp->ident;
+			break;
+		case EVFILT_READ:
+			ev.type = CLOUDABI_EVENTTYPE_FD_READ;
+			ev.fd_readwrite.fd = kevp->ident;
+			break;
+		case EVFILT_WRITE:
+			ev.type = CLOUDABI_EVENTTYPE_FD_WRITE;
+			ev.fd_readwrite.fd = kevp->ident;
+			break;
+		case EVFILT_PROCDESC:
+			ev.type = CLOUDABI_EVENTTYPE_PROC_TERMINATE;
+			ev.proc_terminate.fd = kevp->ident;
+			break;
+		}
+
+		if ((kevp->flags & EV_ERROR) == 0) {
+			/* Success. */
+			switch (kevp->filter) {
+			case EVFILT_READ:
+			case EVFILT_WRITE:
+				ev.fd_readwrite.nbytes = kevp->data;
+				if ((kevp->flags & EV_EOF) != 0) {
+					ev.fd_readwrite.flags |=
+					    CLOUDABI_EVENT_FD_READWRITE_HANGUP;
+				}
+				break;
+			case EVFILT_PROCDESC:
+				if (WIFSIGNALED(kevp->data)) {
+					/* Process got signalled. */
+					ev.proc_terminate.signal =
+					   convert_signal(WTERMSIG(kevp->data));
+					ev.proc_terminate.exitcode = 0;
+				} else {
+					/* Process exited. */
+					ev.proc_terminate.signal = 0;
+					ev.proc_terminate.exitcode =
+					    WEXITSTATUS(kevp->data);
+				}
+				break;
+			}
+		} else {
+			/* Error. */
+			ev.error = cloudabi_convert_errno(kevp->data);
+		}
+		++kevp;
+
+		/* TODO(ed): Copy out multiple entries at once. */
+		error = copyout(&ev, args->out++, sizeof(ev));
+		if (error != 0)
+			return (error);
+	}
+	return (0);
+}
+
+int
+cloudabi32_sys_poll(struct thread *td, struct cloudabi32_sys_poll_args *uap)
+{
+	struct cloudabi32_kevent_args args = {
+		.in	= uap->in,
+		.out	= uap->out,
+		.once	= true,
+	};
+	struct kevent_copyops copyops = {
+		.k_copyin	= cloudabi32_kevent_copyin,
+		.k_copyout	= cloudabi32_kevent_copyout,
+		.arg		= &args,
+	};
+
+	/*
+	 * Bandaid to support CloudABI futex constructs that are not
+	 * implemented through FreeBSD's kqueue().
+	 */
+	if (uap->nsubscriptions == 1) {
+		cloudabi32_subscription_t sub;
+		cloudabi32_event_t ev = {};
+		int error;
+
+		error = copyin(uap->in, &sub, sizeof(sub));
+		if (error != 0)
+			return (error);
+		ev.userdata = sub.userdata;
+		ev.type = sub.type;
+		if (sub.type == CLOUDABI_EVENTTYPE_CONDVAR) {
+			/* Wait on a condition variable. */
+			ev.condvar.condvar = sub.condvar.condvar;
+			ev.error = cloudabi_convert_errno(
+			    cloudabi_futex_condvar_wait(
+			        td, TO_PTR(sub.condvar.condvar),
+			        sub.condvar.condvar_scope,
+			        TO_PTR(sub.condvar.lock),
+			        sub.condvar.lock_scope,
+			        CLOUDABI_CLOCK_MONOTONIC, UINT64_MAX, 0));
+			td->td_retval[0] = 1;
+			return (copyout(&ev, uap->out, sizeof(ev)));
+		} else if (sub.type == CLOUDABI_EVENTTYPE_LOCK_RDLOCK) {
+			/* Acquire a read lock. */
+			ev.lock.lock = sub.lock.lock;
+			ev.error = cloudabi_convert_errno(
+			    cloudabi_futex_lock_rdlock(
+			        td, TO_PTR(sub.lock.lock),
+			        sub.lock.lock_scope, CLOUDABI_CLOCK_MONOTONIC,
+			        UINT64_MAX, 0));
+			td->td_retval[0] = 1;
+			return (copyout(&ev, uap->out, sizeof(ev)));
+		} else if (sub.type == CLOUDABI_EVENTTYPE_LOCK_WRLOCK) {
+			/* Acquire a write lock. */
+			ev.lock.lock = sub.lock.lock;
+			ev.error = cloudabi_convert_errno(
+			    cloudabi_futex_lock_wrlock(
+			        td, TO_PTR(sub.lock.lock),
+			        sub.lock.lock_scope, CLOUDABI_CLOCK_MONOTONIC,
+			        UINT64_MAX, 0));
+			td->td_retval[0] = 1;
+			return (copyout(&ev, uap->out, sizeof(ev)));
+		}
+	} else if (uap->nsubscriptions == 2) {
+		cloudabi32_subscription_t sub[2];
+		cloudabi32_event_t ev[2] = {};
+		int error;
+
+		error = copyin(uap->in, &sub, sizeof(sub));
+		if (error != 0)
+			return (error);
+		ev[0].userdata = sub[0].userdata;
+		ev[0].type = sub[0].type;
+		ev[1].userdata = sub[1].userdata;
+		ev[1].type = sub[1].type;
+		if (sub[0].type == CLOUDABI_EVENTTYPE_CONDVAR &&
+		    sub[1].type == CLOUDABI_EVENTTYPE_CLOCK &&
+		    sub[1].clock.flags == CLOUDABI_SUBSCRIPTION_CLOCK_ABSTIME) {
+			/* Wait for a condition variable with timeout. */
+			ev[0].condvar.condvar = sub[0].condvar.condvar;
+			ev[1].clock.identifier = sub[1].clock.identifier;
+			error = cloudabi_futex_condvar_wait(
+			    td, TO_PTR(sub[0].condvar.condvar),
+			    sub[0].condvar.condvar_scope,
+			    TO_PTR(sub[0].condvar.lock),
+			    sub[0].condvar.lock_scope, sub[1].clock.clock_id,
+			    sub[1].clock.timeout, sub[1].clock.precision);
+			if (error == ETIMEDOUT) {
+				td->td_retval[0] = 1;
+				return (copyout(&ev[1], uap->out,
+				    sizeof(ev[1])));
+			}
+
+			ev[0].error = cloudabi_convert_errno(error);
+			td->td_retval[0] = 1;
+			return (copyout(&ev[0], uap->out, sizeof(ev[0])));
+		} else if (sub[0].type == CLOUDABI_EVENTTYPE_LOCK_RDLOCK &&
+		    sub[1].type == CLOUDABI_EVENTTYPE_CLOCK &&
+		    sub[1].clock.flags == CLOUDABI_SUBSCRIPTION_CLOCK_ABSTIME) {
+			/* Acquire a read lock with a timeout. */
+			ev[0].lock.lock = sub[0].lock.lock;
+			ev[1].clock.identifier = sub[1].clock.identifier;
+			error = cloudabi_futex_lock_rdlock(
+			    td, TO_PTR(sub[0].lock.lock),
+			    sub[0].lock.lock_scope, sub[1].clock.clock_id,
+			    sub[1].clock.timeout, sub[1].clock.precision);
+			if (error == ETIMEDOUT) {
+				td->td_retval[0] = 1;
+				return (copyout(&ev[1], uap->out,
+				    sizeof(ev[1])));
+			}
+
+			ev[0].error = cloudabi_convert_errno(error);
+			td->td_retval[0] = 1;
+			return (copyout(&ev[0], uap->out, sizeof(ev[0])));
+		} else if (sub[0].type == CLOUDABI_EVENTTYPE_LOCK_WRLOCK &&
+		    sub[1].type == CLOUDABI_EVENTTYPE_CLOCK &&
+		    sub[1].clock.flags == CLOUDABI_SUBSCRIPTION_CLOCK_ABSTIME) {
+			/* Acquire a write lock with a timeout. */
+			ev[0].lock.lock = sub[0].lock.lock;
+			ev[1].clock.identifier = sub[1].clock.identifier;
+			error = cloudabi_futex_lock_wrlock(
+			    td, TO_PTR(sub[0].lock.lock),
+			    sub[0].lock.lock_scope, sub[1].clock.clock_id,
+			    sub[1].clock.timeout, sub[1].clock.precision);
+			if (error == ETIMEDOUT) {
+				td->td_retval[0] = 1;
+				return (copyout(&ev[1], uap->out,
+				    sizeof(ev[1])));
+			}
+
+			ev[0].error = cloudabi_convert_errno(error);
+			td->td_retval[0] = 1;
+			return (copyout(&ev[0], uap->out, sizeof(ev[0])));
+		}
+	}
+
+	return (kern_kevent_anonymous(td, uap->nsubscriptions, &copyops));
+}
+
+int
+cloudabi32_sys_poll_fd(struct thread *td,
+    struct cloudabi32_sys_poll_fd_args *uap)
+{
+	struct cloudabi32_kevent_args args = {
+		.in	= uap->in,
+		.out	= uap->out,
+		.once	= false,
+	};
+	struct kevent_copyops copyops = {
+		.k_copyin	= cloudabi32_kevent_copyin,
+		.k_copyout	= cloudabi32_kevent_copyout,
+		.arg		= &args,
+	};
+	cloudabi32_subscription_t subtimo;
+	struct timespec timeout;
+	int error;
+
+	if (uap->timeout != NULL) {
+		/* Poll with a timeout. */
+		error = copyin(uap->timeout, &subtimo, sizeof(subtimo));
+		if (error != 0)
+			return (error);
+		if (subtimo.type != CLOUDABI_EVENTTYPE_CLOCK ||
+		    subtimo.clock.flags != 0)
+			return (EINVAL);
+		timeout.tv_sec = subtimo.clock.timeout / 1000000000;
+		timeout.tv_nsec = subtimo.clock.timeout % 1000000000;
+		return (kern_kevent(td, uap->fd, uap->nin, uap->nout, &copyops,
+		    &timeout));
+	} else {
+		/* Poll without a timeout. */
+		return (kern_kevent(td, uap->fd, uap->nin, uap->nout, &copyops,
+		    NULL));
+	}
+}
diff --git a/sys/compat/cloudabi32/cloudabi32_proto.h b/sys/compat/cloudabi32/cloudabi32_proto.h
new file mode 100644
index 0000000..3f028d5
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_proto.h
@@ -0,0 +1,465 @@
+/*
+ * System call prototypes.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * $FreeBSD$
+ * created from FreeBSD: head/sys/contrib/cloudabi/syscalls32.master 304563 2016-08-21 15:56:19Z ed 
+ */
+
+#ifndef _CLOUDABI32_SYSPROTO_H_
+#define	_CLOUDABI32_SYSPROTO_H_
+
+#include <sys/signal.h>
+#include <sys/acl.h>
+#include <sys/cpuset.h>
+#include <sys/_ffcounter.h>
+#include <sys/_semaphore.h>
+#include <sys/ucontext.h>
+#include <sys/wait.h>
+
+#include <bsm/audit_kevents.h>
+
+struct proc;
+
+struct thread;
+
+#define	PAD_(t)	(sizeof(register_t) <= sizeof(t) ? \
+		0 : sizeof(register_t) - sizeof(t))
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+#define	PADL_(t)	0
+#define	PADR_(t)	PAD_(t)
+#else
+#define	PADL_(t)	PAD_(t)
+#define	PADR_(t)	0
+#endif
+
+struct cloudabi_sys_clock_res_get_args {
+	char clock_id_l_[PADL_(cloudabi_clockid_t)]; cloudabi_clockid_t clock_id; char clock_id_r_[PADR_(cloudabi_clockid_t)];
+};
+struct cloudabi_sys_clock_time_get_args {
+	char clock_id_l_[PADL_(cloudabi_clockid_t)]; cloudabi_clockid_t clock_id; char clock_id_r_[PADR_(cloudabi_clockid_t)];
+	char precision_l_[PADL_(cloudabi_timestamp_t)]; cloudabi_timestamp_t precision; char precision_r_[PADR_(cloudabi_timestamp_t)];
+};
+struct cloudabi_sys_condvar_signal_args {
+	char condvar_l_[PADL_(cloudabi_condvar_t *)]; cloudabi_condvar_t * condvar; char condvar_r_[PADR_(cloudabi_condvar_t *)];
+	char scope_l_[PADL_(cloudabi_scope_t)]; cloudabi_scope_t scope; char scope_r_[PADR_(cloudabi_scope_t)];
+	char nwaiters_l_[PADL_(cloudabi_nthreads_t)]; cloudabi_nthreads_t nwaiters; char nwaiters_r_[PADR_(cloudabi_nthreads_t)];
+};
+struct cloudabi_sys_fd_close_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+};
+struct cloudabi_sys_fd_create1_args {
+	char type_l_[PADL_(cloudabi_filetype_t)]; cloudabi_filetype_t type; char type_r_[PADR_(cloudabi_filetype_t)];
+};
+struct cloudabi_sys_fd_create2_args {
+	char type_l_[PADL_(cloudabi_filetype_t)]; cloudabi_filetype_t type; char type_r_[PADR_(cloudabi_filetype_t)];
+};
+struct cloudabi_sys_fd_datasync_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+};
+struct cloudabi_sys_fd_dup_args {
+	char from_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t from; char from_r_[PADR_(cloudabi_fd_t)];
+};
+struct cloudabi32_sys_fd_pread_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char iov_l_[PADL_(const cloudabi32_iovec_t *)]; const cloudabi32_iovec_t * iov; char iov_r_[PADR_(const cloudabi32_iovec_t *)];
+	char iovcnt_l_[PADL_(size_t)]; size_t iovcnt; char iovcnt_r_[PADR_(size_t)];
+	char offset_l_[PADL_(cloudabi_filesize_t)]; cloudabi_filesize_t offset; char offset_r_[PADR_(cloudabi_filesize_t)];
+};
+struct cloudabi32_sys_fd_pwrite_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char iov_l_[PADL_(const cloudabi32_ciovec_t *)]; const cloudabi32_ciovec_t * iov; char iov_r_[PADR_(const cloudabi32_ciovec_t *)];
+	char iovcnt_l_[PADL_(size_t)]; size_t iovcnt; char iovcnt_r_[PADR_(size_t)];
+	char offset_l_[PADL_(cloudabi_filesize_t)]; cloudabi_filesize_t offset; char offset_r_[PADR_(cloudabi_filesize_t)];
+};
+struct cloudabi32_sys_fd_read_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char iov_l_[PADL_(const cloudabi32_iovec_t *)]; const cloudabi32_iovec_t * iov; char iov_r_[PADR_(const cloudabi32_iovec_t *)];
+	char iovcnt_l_[PADL_(size_t)]; size_t iovcnt; char iovcnt_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_fd_replace_args {
+	char from_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t from; char from_r_[PADR_(cloudabi_fd_t)];
+	char to_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t to; char to_r_[PADR_(cloudabi_fd_t)];
+};
+struct cloudabi_sys_fd_seek_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char offset_l_[PADL_(cloudabi_filedelta_t)]; cloudabi_filedelta_t offset; char offset_r_[PADR_(cloudabi_filedelta_t)];
+	char whence_l_[PADL_(cloudabi_whence_t)]; cloudabi_whence_t whence; char whence_r_[PADR_(cloudabi_whence_t)];
+};
+struct cloudabi_sys_fd_stat_get_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char buf_l_[PADL_(cloudabi_fdstat_t *)]; cloudabi_fdstat_t * buf; char buf_r_[PADR_(cloudabi_fdstat_t *)];
+};
+struct cloudabi_sys_fd_stat_put_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char buf_l_[PADL_(const cloudabi_fdstat_t *)]; const cloudabi_fdstat_t * buf; char buf_r_[PADR_(const cloudabi_fdstat_t *)];
+	char flags_l_[PADL_(cloudabi_fdsflags_t)]; cloudabi_fdsflags_t flags; char flags_r_[PADR_(cloudabi_fdsflags_t)];
+};
+struct cloudabi_sys_fd_sync_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+};
+struct cloudabi32_sys_fd_write_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char iov_l_[PADL_(const cloudabi32_ciovec_t *)]; const cloudabi32_ciovec_t * iov; char iov_r_[PADR_(const cloudabi32_ciovec_t *)];
+	char iovcnt_l_[PADL_(size_t)]; size_t iovcnt; char iovcnt_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_file_advise_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char offset_l_[PADL_(cloudabi_filesize_t)]; cloudabi_filesize_t offset; char offset_r_[PADR_(cloudabi_filesize_t)];
+	char len_l_[PADL_(cloudabi_filesize_t)]; cloudabi_filesize_t len; char len_r_[PADR_(cloudabi_filesize_t)];
+	char advice_l_[PADL_(cloudabi_advice_t)]; cloudabi_advice_t advice; char advice_r_[PADR_(cloudabi_advice_t)];
+};
+struct cloudabi_sys_file_allocate_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char offset_l_[PADL_(cloudabi_filesize_t)]; cloudabi_filesize_t offset; char offset_r_[PADR_(cloudabi_filesize_t)];
+	char len_l_[PADL_(cloudabi_filesize_t)]; cloudabi_filesize_t len; char len_r_[PADR_(cloudabi_filesize_t)];
+};
+struct cloudabi_sys_file_create_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)];
+	char pathlen_l_[PADL_(size_t)]; size_t pathlen; char pathlen_r_[PADR_(size_t)];
+	char type_l_[PADL_(cloudabi_filetype_t)]; cloudabi_filetype_t type; char type_r_[PADR_(cloudabi_filetype_t)];
+};
+struct cloudabi_sys_file_link_args {
+	char fd1_l_[PADL_(cloudabi_lookup_t)]; cloudabi_lookup_t fd1; char fd1_r_[PADR_(cloudabi_lookup_t)];
+	char path1_l_[PADL_(const char *)]; const char * path1; char path1_r_[PADR_(const char *)];
+	char path1len_l_[PADL_(size_t)]; size_t path1len; char path1len_r_[PADR_(size_t)];
+	char fd2_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd2; char fd2_r_[PADR_(cloudabi_fd_t)];
+	char path2_l_[PADL_(const char *)]; const char * path2; char path2_r_[PADR_(const char *)];
+	char path2len_l_[PADL_(size_t)]; size_t path2len; char path2len_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_file_open_args {
+	char dirfd_l_[PADL_(cloudabi_lookup_t)]; cloudabi_lookup_t dirfd; char dirfd_r_[PADR_(cloudabi_lookup_t)];
+	char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)];
+	char pathlen_l_[PADL_(size_t)]; size_t pathlen; char pathlen_r_[PADR_(size_t)];
+	char oflags_l_[PADL_(cloudabi_oflags_t)]; cloudabi_oflags_t oflags; char oflags_r_[PADR_(cloudabi_oflags_t)];
+	char fds_l_[PADL_(const cloudabi_fdstat_t *)]; const cloudabi_fdstat_t * fds; char fds_r_[PADR_(const cloudabi_fdstat_t *)];
+};
+struct cloudabi_sys_file_readdir_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char buf_l_[PADL_(void *)]; void * buf; char buf_r_[PADR_(void *)];
+	char nbyte_l_[PADL_(size_t)]; size_t nbyte; char nbyte_r_[PADR_(size_t)];
+	char cookie_l_[PADL_(cloudabi_dircookie_t)]; cloudabi_dircookie_t cookie; char cookie_r_[PADR_(cloudabi_dircookie_t)];
+};
+struct cloudabi_sys_file_readlink_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)];
+	char pathlen_l_[PADL_(size_t)]; size_t pathlen; char pathlen_r_[PADR_(size_t)];
+	char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)];
+	char bufsize_l_[PADL_(size_t)]; size_t bufsize; char bufsize_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_file_rename_args {
+	char oldfd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t oldfd; char oldfd_r_[PADR_(cloudabi_fd_t)];
+	char old_l_[PADL_(const char *)]; const char * old; char old_r_[PADR_(const char *)];
+	char oldlen_l_[PADL_(size_t)]; size_t oldlen; char oldlen_r_[PADR_(size_t)];
+	char newfd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t newfd; char newfd_r_[PADR_(cloudabi_fd_t)];
+	char new_l_[PADL_(const char *)]; const char * new; char new_r_[PADR_(const char *)];
+	char newlen_l_[PADL_(size_t)]; size_t newlen; char newlen_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_file_stat_fget_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char buf_l_[PADL_(cloudabi_filestat_t *)]; cloudabi_filestat_t * buf; char buf_r_[PADR_(cloudabi_filestat_t *)];
+};
+struct cloudabi_sys_file_stat_fput_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char buf_l_[PADL_(const cloudabi_filestat_t *)]; const cloudabi_filestat_t * buf; char buf_r_[PADR_(const cloudabi_filestat_t *)];
+	char flags_l_[PADL_(cloudabi_fsflags_t)]; cloudabi_fsflags_t flags; char flags_r_[PADR_(cloudabi_fsflags_t)];
+};
+struct cloudabi_sys_file_stat_get_args {
+	char fd_l_[PADL_(cloudabi_lookup_t)]; cloudabi_lookup_t fd; char fd_r_[PADR_(cloudabi_lookup_t)];
+	char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)];
+	char pathlen_l_[PADL_(size_t)]; size_t pathlen; char pathlen_r_[PADR_(size_t)];
+	char buf_l_[PADL_(cloudabi_filestat_t *)]; cloudabi_filestat_t * buf; char buf_r_[PADR_(cloudabi_filestat_t *)];
+};
+struct cloudabi_sys_file_stat_put_args {
+	char fd_l_[PADL_(cloudabi_lookup_t)]; cloudabi_lookup_t fd; char fd_r_[PADR_(cloudabi_lookup_t)];
+	char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)];
+	char pathlen_l_[PADL_(size_t)]; size_t pathlen; char pathlen_r_[PADR_(size_t)];
+	char buf_l_[PADL_(const cloudabi_filestat_t *)]; const cloudabi_filestat_t * buf; char buf_r_[PADR_(const cloudabi_filestat_t *)];
+	char flags_l_[PADL_(cloudabi_fsflags_t)]; cloudabi_fsflags_t flags; char flags_r_[PADR_(cloudabi_fsflags_t)];
+};
+struct cloudabi_sys_file_symlink_args {
+	char path1_l_[PADL_(const char *)]; const char * path1; char path1_r_[PADR_(const char *)];
+	char path1len_l_[PADL_(size_t)]; size_t path1len; char path1len_r_[PADR_(size_t)];
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char path2_l_[PADL_(const char *)]; const char * path2; char path2_r_[PADR_(const char *)];
+	char path2len_l_[PADL_(size_t)]; size_t path2len; char path2len_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_file_unlink_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)];
+	char pathlen_l_[PADL_(size_t)]; size_t pathlen; char pathlen_r_[PADR_(size_t)];
+	char flags_l_[PADL_(cloudabi_ulflags_t)]; cloudabi_ulflags_t flags; char flags_r_[PADR_(cloudabi_ulflags_t)];
+};
+struct cloudabi_sys_lock_unlock_args {
+	char lock_l_[PADL_(cloudabi_lock_t *)]; cloudabi_lock_t * lock; char lock_r_[PADR_(cloudabi_lock_t *)];
+	char scope_l_[PADL_(cloudabi_scope_t)]; cloudabi_scope_t scope; char scope_r_[PADR_(cloudabi_scope_t)];
+};
+struct cloudabi_sys_mem_advise_args {
+	char addr_l_[PADL_(void *)]; void * addr; char addr_r_[PADR_(void *)];
+	char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)];
+	char advice_l_[PADL_(cloudabi_advice_t)]; cloudabi_advice_t advice; char advice_r_[PADR_(cloudabi_advice_t)];
+};
+struct cloudabi_sys_mem_lock_args {
+	char addr_l_[PADL_(const void *)]; const void * addr; char addr_r_[PADR_(const void *)];
+	char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_mem_map_args {
+	char addr_l_[PADL_(void *)]; void * addr; char addr_r_[PADR_(void *)];
+	char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)];
+	char prot_l_[PADL_(cloudabi_mprot_t)]; cloudabi_mprot_t prot; char prot_r_[PADR_(cloudabi_mprot_t)];
+	char flags_l_[PADL_(cloudabi_mflags_t)]; cloudabi_mflags_t flags; char flags_r_[PADR_(cloudabi_mflags_t)];
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char off_l_[PADL_(cloudabi_filesize_t)]; cloudabi_filesize_t off; char off_r_[PADR_(cloudabi_filesize_t)];
+};
+struct cloudabi_sys_mem_protect_args {
+	char addr_l_[PADL_(void *)]; void * addr; char addr_r_[PADR_(void *)];
+	char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)];
+	char prot_l_[PADL_(cloudabi_mprot_t)]; cloudabi_mprot_t prot; char prot_r_[PADR_(cloudabi_mprot_t)];
+};
+struct cloudabi_sys_mem_sync_args {
+	char addr_l_[PADL_(void *)]; void * addr; char addr_r_[PADR_(void *)];
+	char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)];
+	char flags_l_[PADL_(cloudabi_msflags_t)]; cloudabi_msflags_t flags; char flags_r_[PADR_(cloudabi_msflags_t)];
+};
+struct cloudabi_sys_mem_unlock_args {
+	char addr_l_[PADL_(const void *)]; const void * addr; char addr_r_[PADR_(const void *)];
+	char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_mem_unmap_args {
+	char addr_l_[PADL_(void *)]; void * addr; char addr_r_[PADR_(void *)];
+	char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)];
+};
+struct cloudabi32_sys_poll_args {
+	char in_l_[PADL_(const cloudabi32_subscription_t *)]; const cloudabi32_subscription_t * in; char in_r_[PADR_(const cloudabi32_subscription_t *)];
+	char out_l_[PADL_(cloudabi32_event_t *)]; cloudabi32_event_t * out; char out_r_[PADR_(cloudabi32_event_t *)];
+	char nsubscriptions_l_[PADL_(size_t)]; size_t nsubscriptions; char nsubscriptions_r_[PADR_(size_t)];
+};
+struct cloudabi32_sys_poll_fd_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char in_l_[PADL_(const cloudabi32_subscription_t *)]; const cloudabi32_subscription_t * in; char in_r_[PADR_(const cloudabi32_subscription_t *)];
+	char nin_l_[PADL_(size_t)]; size_t nin; char nin_r_[PADR_(size_t)];
+	char out_l_[PADL_(cloudabi32_event_t *)]; cloudabi32_event_t * out; char out_r_[PADR_(cloudabi32_event_t *)];
+	char nout_l_[PADL_(size_t)]; size_t nout; char nout_r_[PADR_(size_t)];
+	char timeout_l_[PADL_(const cloudabi32_subscription_t *)]; const cloudabi32_subscription_t * timeout; char timeout_r_[PADR_(const cloudabi32_subscription_t *)];
+};
+struct cloudabi_sys_proc_exec_args {
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char data_l_[PADL_(const void *)]; const void * data; char data_r_[PADR_(const void *)];
+	char datalen_l_[PADL_(size_t)]; size_t datalen; char datalen_r_[PADR_(size_t)];
+	char fds_l_[PADL_(const cloudabi_fd_t *)]; const cloudabi_fd_t * fds; char fds_r_[PADR_(const cloudabi_fd_t *)];
+	char fdslen_l_[PADL_(size_t)]; size_t fdslen; char fdslen_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_proc_exit_args {
+	char rval_l_[PADL_(cloudabi_exitcode_t)]; cloudabi_exitcode_t rval; char rval_r_[PADR_(cloudabi_exitcode_t)];
+};
+struct cloudabi_sys_proc_fork_args {
+	register_t dummy;
+};
+struct cloudabi_sys_proc_raise_args {
+	char sig_l_[PADL_(cloudabi_signal_t)]; cloudabi_signal_t sig; char sig_r_[PADR_(cloudabi_signal_t)];
+};
+struct cloudabi_sys_random_get_args {
+	char buf_l_[PADL_(void *)]; void * buf; char buf_r_[PADR_(void *)];
+	char nbyte_l_[PADL_(size_t)]; size_t nbyte; char nbyte_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_sock_accept_args {
+	char sock_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t sock; char sock_r_[PADR_(cloudabi_fd_t)];
+	char buf_l_[PADL_(cloudabi_sockstat_t *)]; cloudabi_sockstat_t * buf; char buf_r_[PADR_(cloudabi_sockstat_t *)];
+};
+struct cloudabi_sys_sock_bind_args {
+	char sock_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t sock; char sock_r_[PADR_(cloudabi_fd_t)];
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)];
+	char pathlen_l_[PADL_(size_t)]; size_t pathlen; char pathlen_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_sock_connect_args {
+	char sock_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t sock; char sock_r_[PADR_(cloudabi_fd_t)];
+	char fd_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t fd; char fd_r_[PADR_(cloudabi_fd_t)];
+	char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)];
+	char pathlen_l_[PADL_(size_t)]; size_t pathlen; char pathlen_r_[PADR_(size_t)];
+};
+struct cloudabi_sys_sock_listen_args {
+	char sock_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t sock; char sock_r_[PADR_(cloudabi_fd_t)];
+	char backlog_l_[PADL_(cloudabi_backlog_t)]; cloudabi_backlog_t backlog; char backlog_r_[PADR_(cloudabi_backlog_t)];
+};
+struct cloudabi32_sys_sock_recv_args {
+	char sock_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t sock; char sock_r_[PADR_(cloudabi_fd_t)];
+	char in_l_[PADL_(const cloudabi32_recv_in_t *)]; const cloudabi32_recv_in_t * in; char in_r_[PADR_(const cloudabi32_recv_in_t *)];
+	char out_l_[PADL_(cloudabi32_recv_out_t *)]; cloudabi32_recv_out_t * out; char out_r_[PADR_(cloudabi32_recv_out_t *)];
+};
+struct cloudabi32_sys_sock_send_args {
+	char sock_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t sock; char sock_r_[PADR_(cloudabi_fd_t)];
+	char in_l_[PADL_(const cloudabi32_send_in_t *)]; const cloudabi32_send_in_t * in; char in_r_[PADR_(const cloudabi32_send_in_t *)];
+	char out_l_[PADL_(cloudabi32_send_out_t *)]; cloudabi32_send_out_t * out; char out_r_[PADR_(cloudabi32_send_out_t *)];
+};
+struct cloudabi_sys_sock_shutdown_args {
+	char sock_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t sock; char sock_r_[PADR_(cloudabi_fd_t)];
+	char how_l_[PADL_(cloudabi_sdflags_t)]; cloudabi_sdflags_t how; char how_r_[PADR_(cloudabi_sdflags_t)];
+};
+struct cloudabi_sys_sock_stat_get_args {
+	char sock_l_[PADL_(cloudabi_fd_t)]; cloudabi_fd_t sock; char sock_r_[PADR_(cloudabi_fd_t)];
+	char buf_l_[PADL_(cloudabi_sockstat_t *)]; cloudabi_sockstat_t * buf; char buf_r_[PADR_(cloudabi_sockstat_t *)];
+	char flags_l_[PADL_(cloudabi_ssflags_t)]; cloudabi_ssflags_t flags; char flags_r_[PADR_(cloudabi_ssflags_t)];
+};
+struct cloudabi32_sys_thread_create_args {
+	char attr_l_[PADL_(cloudabi32_threadattr_t *)]; cloudabi32_threadattr_t * attr; char attr_r_[PADR_(cloudabi32_threadattr_t *)];
+};
+struct cloudabi_sys_thread_exit_args {
+	char lock_l_[PADL_(cloudabi_lock_t *)]; cloudabi_lock_t * lock; char lock_r_[PADR_(cloudabi_lock_t *)];
+	char scope_l_[PADL_(cloudabi_scope_t)]; cloudabi_scope_t scope; char scope_r_[PADR_(cloudabi_scope_t)];
+};
+struct cloudabi_sys_thread_yield_args {
+	register_t dummy;
+};
+int	cloudabi_sys_clock_res_get(struct thread *, struct cloudabi_sys_clock_res_get_args *);
+int	cloudabi_sys_clock_time_get(struct thread *, struct cloudabi_sys_clock_time_get_args *);
+int	cloudabi_sys_condvar_signal(struct thread *, struct cloudabi_sys_condvar_signal_args *);
+int	cloudabi_sys_fd_close(struct thread *, struct cloudabi_sys_fd_close_args *);
+int	cloudabi_sys_fd_create1(struct thread *, struct cloudabi_sys_fd_create1_args *);
+int	cloudabi_sys_fd_create2(struct thread *, struct cloudabi_sys_fd_create2_args *);
+int	cloudabi_sys_fd_datasync(struct thread *, struct cloudabi_sys_fd_datasync_args *);
+int	cloudabi_sys_fd_dup(struct thread *, struct cloudabi_sys_fd_dup_args *);
+int	cloudabi32_sys_fd_pread(struct thread *, struct cloudabi32_sys_fd_pread_args *);
+int	cloudabi32_sys_fd_pwrite(struct thread *, struct cloudabi32_sys_fd_pwrite_args *);
+int	cloudabi32_sys_fd_read(struct thread *, struct cloudabi32_sys_fd_read_args *);
+int	cloudabi_sys_fd_replace(struct thread *, struct cloudabi_sys_fd_replace_args *);
+int	cloudabi_sys_fd_seek(struct thread *, struct cloudabi_sys_fd_seek_args *);
+int	cloudabi_sys_fd_stat_get(struct thread *, struct cloudabi_sys_fd_stat_get_args *);
+int	cloudabi_sys_fd_stat_put(struct thread *, struct cloudabi_sys_fd_stat_put_args *);
+int	cloudabi_sys_fd_sync(struct thread *, struct cloudabi_sys_fd_sync_args *);
+int	cloudabi32_sys_fd_write(struct thread *, struct cloudabi32_sys_fd_write_args *);
+int	cloudabi_sys_file_advise(struct thread *, struct cloudabi_sys_file_advise_args *);
+int	cloudabi_sys_file_allocate(struct thread *, struct cloudabi_sys_file_allocate_args *);
+int	cloudabi_sys_file_create(struct thread *, struct cloudabi_sys_file_create_args *);
+int	cloudabi_sys_file_link(struct thread *, struct cloudabi_sys_file_link_args *);
+int	cloudabi_sys_file_open(struct thread *, struct cloudabi_sys_file_open_args *);
+int	cloudabi_sys_file_readdir(struct thread *, struct cloudabi_sys_file_readdir_args *);
+int	cloudabi_sys_file_readlink(struct thread *, struct cloudabi_sys_file_readlink_args *);
+int	cloudabi_sys_file_rename(struct thread *, struct cloudabi_sys_file_rename_args *);
+int	cloudabi_sys_file_stat_fget(struct thread *, struct cloudabi_sys_file_stat_fget_args *);
+int	cloudabi_sys_file_stat_fput(struct thread *, struct cloudabi_sys_file_stat_fput_args *);
+int	cloudabi_sys_file_stat_get(struct thread *, struct cloudabi_sys_file_stat_get_args *);
+int	cloudabi_sys_file_stat_put(struct thread *, struct cloudabi_sys_file_stat_put_args *);
+int	cloudabi_sys_file_symlink(struct thread *, struct cloudabi_sys_file_symlink_args *);
+int	cloudabi_sys_file_unlink(struct thread *, struct cloudabi_sys_file_unlink_args *);
+int	cloudabi_sys_lock_unlock(struct thread *, struct cloudabi_sys_lock_unlock_args *);
+int	cloudabi_sys_mem_advise(struct thread *, struct cloudabi_sys_mem_advise_args *);
+int	cloudabi_sys_mem_lock(struct thread *, struct cloudabi_sys_mem_lock_args *);
+int	cloudabi_sys_mem_map(struct thread *, struct cloudabi_sys_mem_map_args *);
+int	cloudabi_sys_mem_protect(struct thread *, struct cloudabi_sys_mem_protect_args *);
+int	cloudabi_sys_mem_sync(struct thread *, struct cloudabi_sys_mem_sync_args *);
+int	cloudabi_sys_mem_unlock(struct thread *, struct cloudabi_sys_mem_unlock_args *);
+int	cloudabi_sys_mem_unmap(struct thread *, struct cloudabi_sys_mem_unmap_args *);
+int	cloudabi32_sys_poll(struct thread *, struct cloudabi32_sys_poll_args *);
+int	cloudabi32_sys_poll_fd(struct thread *, struct cloudabi32_sys_poll_fd_args *);
+int	cloudabi_sys_proc_exec(struct thread *, struct cloudabi_sys_proc_exec_args *);
+int	cloudabi_sys_proc_exit(struct thread *, struct cloudabi_sys_proc_exit_args *);
+int	cloudabi_sys_proc_fork(struct thread *, struct cloudabi_sys_proc_fork_args *);
+int	cloudabi_sys_proc_raise(struct thread *, struct cloudabi_sys_proc_raise_args *);
+int	cloudabi_sys_random_get(struct thread *, struct cloudabi_sys_random_get_args *);
+int	cloudabi_sys_sock_accept(struct thread *, struct cloudabi_sys_sock_accept_args *);
+int	cloudabi_sys_sock_bind(struct thread *, struct cloudabi_sys_sock_bind_args *);
+int	cloudabi_sys_sock_connect(struct thread *, struct cloudabi_sys_sock_connect_args *);
+int	cloudabi_sys_sock_listen(struct thread *, struct cloudabi_sys_sock_listen_args *);
+int	cloudabi32_sys_sock_recv(struct thread *, struct cloudabi32_sys_sock_recv_args *);
+int	cloudabi32_sys_sock_send(struct thread *, struct cloudabi32_sys_sock_send_args *);
+int	cloudabi_sys_sock_shutdown(struct thread *, struct cloudabi_sys_sock_shutdown_args *);
+int	cloudabi_sys_sock_stat_get(struct thread *, struct cloudabi_sys_sock_stat_get_args *);
+int	cloudabi32_sys_thread_create(struct thread *, struct cloudabi32_sys_thread_create_args *);
+int	cloudabi_sys_thread_exit(struct thread *, struct cloudabi_sys_thread_exit_args *);
+int	cloudabi_sys_thread_yield(struct thread *, struct cloudabi_sys_thread_yield_args *);
+
+#ifdef COMPAT_43
+
+
+#endif /* COMPAT_43 */
+
+
+#ifdef COMPAT_FREEBSD4
+
+
+#endif /* COMPAT_FREEBSD4 */
+
+
+#ifdef COMPAT_FREEBSD6
+
+
+#endif /* COMPAT_FREEBSD6 */
+
+
+#ifdef COMPAT_FREEBSD7
+
+
+#endif /* COMPAT_FREEBSD7 */
+
+
+#ifdef COMPAT_FREEBSD10
+
+
+#endif /* COMPAT_FREEBSD10 */
+
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_clock_res_get	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_clock_time_get	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_condvar_signal	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_fd_close	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_fd_create1	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_fd_create2	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_fd_datasync	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_fd_dup	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi32_sys_fd_pread	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi32_sys_fd_pwrite	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi32_sys_fd_read	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_fd_replace	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_fd_seek	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_fd_stat_get	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_fd_stat_put	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_fd_sync	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi32_sys_fd_write	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_advise	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_allocate	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_create	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_link	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_open	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_readdir	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_readlink	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_rename	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_stat_fget	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_stat_fput	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_stat_get	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_stat_put	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_symlink	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_file_unlink	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_lock_unlock	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_mem_advise	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_mem_lock	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_mem_map	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_mem_protect	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_mem_sync	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_mem_unlock	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_mem_unmap	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi32_sys_poll	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi32_sys_poll_fd	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_proc_exec	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_proc_exit	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_proc_fork	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_proc_raise	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_random_get	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_sock_accept	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_sock_bind	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_sock_connect	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_sock_listen	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi32_sys_sock_recv	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi32_sys_sock_send	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_sock_shutdown	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_sock_stat_get	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi32_sys_thread_create	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_thread_exit	AUE_NULL
+#define	CLOUDABI32_SYS_AUE_cloudabi_sys_thread_yield	AUE_NULL
+
+#undef PAD_
+#undef PADL_
+#undef PADR_
+
+#endif /* !_CLOUDABI32_SYSPROTO_H_ */
diff --git a/sys/compat/cloudabi32/cloudabi32_sock.c b/sys/compat/cloudabi32/cloudabi32_sock.c
new file mode 100644
index 0000000..24ed32c
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_sock.c
@@ -0,0 +1,148 @@
+/*-
+ * Copyright (c) 2015 Nuxi, https://nuxi.nl/
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/proc.h>
+#include <sys/socket.h>
+#include <sys/syscallsubr.h>
+#include <sys/systm.h>
+#include <sys/uio.h>
+
+#include <contrib/cloudabi/cloudabi32_types.h>
+
+#include <compat/cloudabi/cloudabi_util.h>
+
+#include <compat/cloudabi32/cloudabi32_proto.h>
+#include <compat/cloudabi32/cloudabi32_util.h>
+
+static MALLOC_DEFINE(M_SOCKET, "socket", "CloudABI socket");
+
+int
+cloudabi32_sys_sock_recv(struct thread *td,
+    struct cloudabi32_sys_sock_recv_args *uap)
+{
+	struct sockaddr_storage ss;
+	cloudabi32_recv_in_t ri;
+	cloudabi32_recv_out_t ro = {};
+	cloudabi32_iovec_t iovobj;
+	struct msghdr msghdr = {};
+	const cloudabi32_iovec_t *user_iov;
+	size_t i;
+	int error;
+
+	error = copyin(uap->in, &ri, sizeof(ri));
+	if (error != 0)
+		return (error);
+
+	/* Convert results in cloudabi_recv_in_t to struct msghdr. */
+	if (ri.ri_datalen > UIO_MAXIOV)
+		return (EINVAL);
+	msghdr.msg_iovlen = ri.ri_datalen;
+	msghdr.msg_iov = malloc(msghdr.msg_iovlen * sizeof(struct iovec),
+	    M_SOCKET, M_WAITOK);
+	user_iov = TO_PTR(ri.ri_data);
+	for (i = 0; i < msghdr.msg_iovlen; i++) {
+		error = copyin(&user_iov[i], &iovobj, sizeof(iovobj));
+		if (error != 0) {
+			free(msghdr.msg_iov, M_SOCKET);
+			return (error);
+		}
+		msghdr.msg_iov[i].iov_base = TO_PTR(iovobj.iov_base);
+		msghdr.msg_iov[i].iov_len = iovobj.iov_len;
+	}
+	msghdr.msg_name = &ss;
+	msghdr.msg_namelen = sizeof(ss);
+	if (ri.ri_flags & CLOUDABI_MSG_PEEK)
+		msghdr.msg_flags |= MSG_PEEK;
+	if (ri.ri_flags & CLOUDABI_MSG_WAITALL)
+		msghdr.msg_flags |= MSG_WAITALL;
+
+	/* TODO(ed): Add file descriptor passing. */
+	error = kern_recvit(td, uap->sock, &msghdr, UIO_SYSSPACE, NULL);
+	free(msghdr.msg_iov, M_SOCKET);
+	if (error != 0)
+		return (error);
+
+	/* Convert results in msghdr to cloudabi_recv_out_t. */
+	ro.ro_datalen = td->td_retval[0];
+	cloudabi_convert_sockaddr((struct sockaddr *)&ss,
+	    MIN(msghdr.msg_namelen, sizeof(ss)), &ro.ro_peername);
+	td->td_retval[0] = 0;
+	return (copyout(&ro, uap->out, sizeof(ro)));
+}
+
+int
+cloudabi32_sys_sock_send(struct thread *td,
+    struct cloudabi32_sys_sock_send_args *uap)
+{
+	cloudabi32_send_in_t si;
+	cloudabi32_send_out_t so = {};
+	cloudabi32_ciovec_t iovobj;
+	struct msghdr msghdr = {};
+	const cloudabi32_ciovec_t *user_iov;
+	size_t i;
+	int error, flags;
+
+	error = copyin(uap->in, &si, sizeof(si));
+	if (error != 0)
+		return (error);
+
+	/* Convert results in cloudabi_send_in_t to struct msghdr. */
+	if (si.si_datalen > UIO_MAXIOV)
+		return (EINVAL);
+	msghdr.msg_iovlen = si.si_datalen;
+	msghdr.msg_iov = malloc(msghdr.msg_iovlen * sizeof(struct iovec),
+	    M_SOCKET, M_WAITOK);
+	user_iov = TO_PTR(si.si_data);
+	for (i = 0; i < msghdr.msg_iovlen; i++) {
+		error = copyin(&user_iov[i], &iovobj, sizeof(iovobj));
+		if (error != 0) {
+			free(msghdr.msg_iov, M_SOCKET);
+			return (error);
+		}
+		msghdr.msg_iov[i].iov_base = TO_PTR(iovobj.iov_base);
+		msghdr.msg_iov[i].iov_len = iovobj.iov_len;
+	}
+
+	flags = MSG_NOSIGNAL;
+	if (si.si_flags & CLOUDABI_MSG_EOR)
+		flags |= MSG_EOR;
+
+	/* TODO(ed): Add file descriptor passing. */
+	error = kern_sendit(td, uap->sock, &msghdr, flags, NULL, UIO_USERSPACE);
+	free(msghdr.msg_iov, M_SOCKET);
+	if (error != 0)
+		return (error);
+
+	/* Convert results in msghdr to cloudabi_send_out_t. */
+	so.so_datalen = td->td_retval[0];
+	td->td_retval[0] = 0;
+	return (copyout(&so, uap->out, sizeof(so)));
+}
diff --git a/sys/compat/cloudabi32/cloudabi32_syscall.h b/sys/compat/cloudabi32/cloudabi32_syscall.h
new file mode 100644
index 0000000..4cba6fd
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_syscall.h
@@ -0,0 +1,66 @@
+/*
+ * System call numbers.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * $FreeBSD$
+ * created from FreeBSD: head/sys/contrib/cloudabi/syscalls32.master 304563 2016-08-21 15:56:19Z ed 
+ */
+
+#define	CLOUDABI32_SYS_cloudabi_sys_clock_res_get	0
+#define	CLOUDABI32_SYS_cloudabi_sys_clock_time_get	1
+#define	CLOUDABI32_SYS_cloudabi_sys_condvar_signal	2
+#define	CLOUDABI32_SYS_cloudabi_sys_fd_close	3
+#define	CLOUDABI32_SYS_cloudabi_sys_fd_create1	4
+#define	CLOUDABI32_SYS_cloudabi_sys_fd_create2	5
+#define	CLOUDABI32_SYS_cloudabi_sys_fd_datasync	6
+#define	CLOUDABI32_SYS_cloudabi_sys_fd_dup	7
+#define	CLOUDABI32_SYS_cloudabi32_sys_fd_pread	8
+#define	CLOUDABI32_SYS_cloudabi32_sys_fd_pwrite	9
+#define	CLOUDABI32_SYS_cloudabi32_sys_fd_read	10
+#define	CLOUDABI32_SYS_cloudabi_sys_fd_replace	11
+#define	CLOUDABI32_SYS_cloudabi_sys_fd_seek	12
+#define	CLOUDABI32_SYS_cloudabi_sys_fd_stat_get	13
+#define	CLOUDABI32_SYS_cloudabi_sys_fd_stat_put	14
+#define	CLOUDABI32_SYS_cloudabi_sys_fd_sync	15
+#define	CLOUDABI32_SYS_cloudabi32_sys_fd_write	16
+#define	CLOUDABI32_SYS_cloudabi_sys_file_advise	17
+#define	CLOUDABI32_SYS_cloudabi_sys_file_allocate	18
+#define	CLOUDABI32_SYS_cloudabi_sys_file_create	19
+#define	CLOUDABI32_SYS_cloudabi_sys_file_link	20
+#define	CLOUDABI32_SYS_cloudabi_sys_file_open	21
+#define	CLOUDABI32_SYS_cloudabi_sys_file_readdir	22
+#define	CLOUDABI32_SYS_cloudabi_sys_file_readlink	23
+#define	CLOUDABI32_SYS_cloudabi_sys_file_rename	24
+#define	CLOUDABI32_SYS_cloudabi_sys_file_stat_fget	25
+#define	CLOUDABI32_SYS_cloudabi_sys_file_stat_fput	26
+#define	CLOUDABI32_SYS_cloudabi_sys_file_stat_get	27
+#define	CLOUDABI32_SYS_cloudabi_sys_file_stat_put	28
+#define	CLOUDABI32_SYS_cloudabi_sys_file_symlink	29
+#define	CLOUDABI32_SYS_cloudabi_sys_file_unlink	30
+#define	CLOUDABI32_SYS_cloudabi_sys_lock_unlock	31
+#define	CLOUDABI32_SYS_cloudabi_sys_mem_advise	32
+#define	CLOUDABI32_SYS_cloudabi_sys_mem_lock	33
+#define	CLOUDABI32_SYS_cloudabi_sys_mem_map	34
+#define	CLOUDABI32_SYS_cloudabi_sys_mem_protect	35
+#define	CLOUDABI32_SYS_cloudabi_sys_mem_sync	36
+#define	CLOUDABI32_SYS_cloudabi_sys_mem_unlock	37
+#define	CLOUDABI32_SYS_cloudabi_sys_mem_unmap	38
+#define	CLOUDABI32_SYS_cloudabi32_sys_poll	39
+#define	CLOUDABI32_SYS_cloudabi32_sys_poll_fd	40
+#define	CLOUDABI32_SYS_cloudabi_sys_proc_exec	41
+#define	CLOUDABI32_SYS_cloudabi_sys_proc_exit	42
+#define	CLOUDABI32_SYS_cloudabi_sys_proc_fork	43
+#define	CLOUDABI32_SYS_cloudabi_sys_proc_raise	44
+#define	CLOUDABI32_SYS_cloudabi_sys_random_get	45
+#define	CLOUDABI32_SYS_cloudabi_sys_sock_accept	46
+#define	CLOUDABI32_SYS_cloudabi_sys_sock_bind	47
+#define	CLOUDABI32_SYS_cloudabi_sys_sock_connect	48
+#define	CLOUDABI32_SYS_cloudabi_sys_sock_listen	49
+#define	CLOUDABI32_SYS_cloudabi32_sys_sock_recv	50
+#define	CLOUDABI32_SYS_cloudabi32_sys_sock_send	51
+#define	CLOUDABI32_SYS_cloudabi_sys_sock_shutdown	52
+#define	CLOUDABI32_SYS_cloudabi_sys_sock_stat_get	53
+#define	CLOUDABI32_SYS_cloudabi32_sys_thread_create	54
+#define	CLOUDABI32_SYS_cloudabi_sys_thread_exit	55
+#define	CLOUDABI32_SYS_cloudabi_sys_thread_yield	56
+#define	CLOUDABI32_SYS_MAXSYSCALL	57
diff --git a/sys/compat/cloudabi32/cloudabi32_syscalls.c b/sys/compat/cloudabi32/cloudabi32_syscalls.c
new file mode 100644
index 0000000..56a46fb
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_syscalls.c
@@ -0,0 +1,67 @@
+/*
+ * System call names.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * $FreeBSD$
+ * created from FreeBSD: head/sys/contrib/cloudabi/syscalls32.master 304563 2016-08-21 15:56:19Z ed 
+ */
+
+const char *cloudabi32_syscallnames[] = {
+	"cloudabi_sys_clock_res_get",			/* 0 = cloudabi_sys_clock_res_get */
+	"cloudabi_sys_clock_time_get",			/* 1 = cloudabi_sys_clock_time_get */
+	"cloudabi_sys_condvar_signal",			/* 2 = cloudabi_sys_condvar_signal */
+	"cloudabi_sys_fd_close",			/* 3 = cloudabi_sys_fd_close */
+	"cloudabi_sys_fd_create1",			/* 4 = cloudabi_sys_fd_create1 */
+	"cloudabi_sys_fd_create2",			/* 5 = cloudabi_sys_fd_create2 */
+	"cloudabi_sys_fd_datasync",			/* 6 = cloudabi_sys_fd_datasync */
+	"cloudabi_sys_fd_dup",			/* 7 = cloudabi_sys_fd_dup */
+	"cloudabi32_sys_fd_pread",			/* 8 = cloudabi32_sys_fd_pread */
+	"cloudabi32_sys_fd_pwrite",			/* 9 = cloudabi32_sys_fd_pwrite */
+	"cloudabi32_sys_fd_read",			/* 10 = cloudabi32_sys_fd_read */
+	"cloudabi_sys_fd_replace",			/* 11 = cloudabi_sys_fd_replace */
+	"cloudabi_sys_fd_seek",			/* 12 = cloudabi_sys_fd_seek */
+	"cloudabi_sys_fd_stat_get",			/* 13 = cloudabi_sys_fd_stat_get */
+	"cloudabi_sys_fd_stat_put",			/* 14 = cloudabi_sys_fd_stat_put */
+	"cloudabi_sys_fd_sync",			/* 15 = cloudabi_sys_fd_sync */
+	"cloudabi32_sys_fd_write",			/* 16 = cloudabi32_sys_fd_write */
+	"cloudabi_sys_file_advise",			/* 17 = cloudabi_sys_file_advise */
+	"cloudabi_sys_file_allocate",			/* 18 = cloudabi_sys_file_allocate */
+	"cloudabi_sys_file_create",			/* 19 = cloudabi_sys_file_create */
+	"cloudabi_sys_file_link",			/* 20 = cloudabi_sys_file_link */
+	"cloudabi_sys_file_open",			/* 21 = cloudabi_sys_file_open */
+	"cloudabi_sys_file_readdir",			/* 22 = cloudabi_sys_file_readdir */
+	"cloudabi_sys_file_readlink",			/* 23 = cloudabi_sys_file_readlink */
+	"cloudabi_sys_file_rename",			/* 24 = cloudabi_sys_file_rename */
+	"cloudabi_sys_file_stat_fget",			/* 25 = cloudabi_sys_file_stat_fget */
+	"cloudabi_sys_file_stat_fput",			/* 26 = cloudabi_sys_file_stat_fput */
+	"cloudabi_sys_file_stat_get",			/* 27 = cloudabi_sys_file_stat_get */
+	"cloudabi_sys_file_stat_put",			/* 28 = cloudabi_sys_file_stat_put */
+	"cloudabi_sys_file_symlink",			/* 29 = cloudabi_sys_file_symlink */
+	"cloudabi_sys_file_unlink",			/* 30 = cloudabi_sys_file_unlink */
+	"cloudabi_sys_lock_unlock",			/* 31 = cloudabi_sys_lock_unlock */
+	"cloudabi_sys_mem_advise",			/* 32 = cloudabi_sys_mem_advise */
+	"cloudabi_sys_mem_lock",			/* 33 = cloudabi_sys_mem_lock */
+	"cloudabi_sys_mem_map",			/* 34 = cloudabi_sys_mem_map */
+	"cloudabi_sys_mem_protect",			/* 35 = cloudabi_sys_mem_protect */
+	"cloudabi_sys_mem_sync",			/* 36 = cloudabi_sys_mem_sync */
+	"cloudabi_sys_mem_unlock",			/* 37 = cloudabi_sys_mem_unlock */
+	"cloudabi_sys_mem_unmap",			/* 38 = cloudabi_sys_mem_unmap */
+	"cloudabi32_sys_poll",			/* 39 = cloudabi32_sys_poll */
+	"cloudabi32_sys_poll_fd",			/* 40 = cloudabi32_sys_poll_fd */
+	"cloudabi_sys_proc_exec",			/* 41 = cloudabi_sys_proc_exec */
+	"cloudabi_sys_proc_exit",			/* 42 = cloudabi_sys_proc_exit */
+	"cloudabi_sys_proc_fork",			/* 43 = cloudabi_sys_proc_fork */
+	"cloudabi_sys_proc_raise",			/* 44 = cloudabi_sys_proc_raise */
+	"cloudabi_sys_random_get",			/* 45 = cloudabi_sys_random_get */
+	"cloudabi_sys_sock_accept",			/* 46 = cloudabi_sys_sock_accept */
+	"cloudabi_sys_sock_bind",			/* 47 = cloudabi_sys_sock_bind */
+	"cloudabi_sys_sock_connect",			/* 48 = cloudabi_sys_sock_connect */
+	"cloudabi_sys_sock_listen",			/* 49 = cloudabi_sys_sock_listen */
+	"cloudabi32_sys_sock_recv",			/* 50 = cloudabi32_sys_sock_recv */
+	"cloudabi32_sys_sock_send",			/* 51 = cloudabi32_sys_sock_send */
+	"cloudabi_sys_sock_shutdown",			/* 52 = cloudabi_sys_sock_shutdown */
+	"cloudabi_sys_sock_stat_get",			/* 53 = cloudabi_sys_sock_stat_get */
+	"cloudabi32_sys_thread_create",			/* 54 = cloudabi32_sys_thread_create */
+	"cloudabi_sys_thread_exit",			/* 55 = cloudabi_sys_thread_exit */
+	"cloudabi_sys_thread_yield",			/* 56 = cloudabi_sys_thread_yield */
+};
diff --git a/sys/compat/cloudabi32/cloudabi32_sysent.c b/sys/compat/cloudabi32/cloudabi32_sysent.c
new file mode 100644
index 0000000..187e384
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_sysent.c
@@ -0,0 +1,75 @@
+/*
+ * System call switch table.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * $FreeBSD$
+ * created from FreeBSD: head/sys/contrib/cloudabi/syscalls32.master 304563 2016-08-21 15:56:19Z ed 
+ */
+
+#include <sys/sysent.h>
+#include <sys/sysproto.h>
+#include <contrib/cloudabi/cloudabi32_types.h>
+#include <compat/cloudabi32/cloudabi32_proto.h>
+
+#define AS(name) (sizeof(struct name) / sizeof(register_t))
+
+/* The casts are bogus but will do for now. */
+struct sysent cloudabi32_sysent[] = {
+	{ AS(cloudabi_sys_clock_res_get_args), (sy_call_t *)cloudabi_sys_clock_res_get, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 0 = cloudabi_sys_clock_res_get */
+	{ AS(cloudabi_sys_clock_time_get_args), (sy_call_t *)cloudabi_sys_clock_time_get, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 1 = cloudabi_sys_clock_time_get */
+	{ AS(cloudabi_sys_condvar_signal_args), (sy_call_t *)cloudabi_sys_condvar_signal, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 2 = cloudabi_sys_condvar_signal */
+	{ AS(cloudabi_sys_fd_close_args), (sy_call_t *)cloudabi_sys_fd_close, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 3 = cloudabi_sys_fd_close */
+	{ AS(cloudabi_sys_fd_create1_args), (sy_call_t *)cloudabi_sys_fd_create1, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 4 = cloudabi_sys_fd_create1 */
+	{ AS(cloudabi_sys_fd_create2_args), (sy_call_t *)cloudabi_sys_fd_create2, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 5 = cloudabi_sys_fd_create2 */
+	{ AS(cloudabi_sys_fd_datasync_args), (sy_call_t *)cloudabi_sys_fd_datasync, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 6 = cloudabi_sys_fd_datasync */
+	{ AS(cloudabi_sys_fd_dup_args), (sy_call_t *)cloudabi_sys_fd_dup, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 7 = cloudabi_sys_fd_dup */
+	{ AS(cloudabi32_sys_fd_pread_args), (sy_call_t *)cloudabi32_sys_fd_pread, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 8 = cloudabi32_sys_fd_pread */
+	{ AS(cloudabi32_sys_fd_pwrite_args), (sy_call_t *)cloudabi32_sys_fd_pwrite, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 9 = cloudabi32_sys_fd_pwrite */
+	{ AS(cloudabi32_sys_fd_read_args), (sy_call_t *)cloudabi32_sys_fd_read, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 10 = cloudabi32_sys_fd_read */
+	{ AS(cloudabi_sys_fd_replace_args), (sy_call_t *)cloudabi_sys_fd_replace, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 11 = cloudabi_sys_fd_replace */
+	{ AS(cloudabi_sys_fd_seek_args), (sy_call_t *)cloudabi_sys_fd_seek, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 12 = cloudabi_sys_fd_seek */
+	{ AS(cloudabi_sys_fd_stat_get_args), (sy_call_t *)cloudabi_sys_fd_stat_get, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 13 = cloudabi_sys_fd_stat_get */
+	{ AS(cloudabi_sys_fd_stat_put_args), (sy_call_t *)cloudabi_sys_fd_stat_put, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 14 = cloudabi_sys_fd_stat_put */
+	{ AS(cloudabi_sys_fd_sync_args), (sy_call_t *)cloudabi_sys_fd_sync, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 15 = cloudabi_sys_fd_sync */
+	{ AS(cloudabi32_sys_fd_write_args), (sy_call_t *)cloudabi32_sys_fd_write, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 16 = cloudabi32_sys_fd_write */
+	{ AS(cloudabi_sys_file_advise_args), (sy_call_t *)cloudabi_sys_file_advise, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 17 = cloudabi_sys_file_advise */
+	{ AS(cloudabi_sys_file_allocate_args), (sy_call_t *)cloudabi_sys_file_allocate, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 18 = cloudabi_sys_file_allocate */
+	{ AS(cloudabi_sys_file_create_args), (sy_call_t *)cloudabi_sys_file_create, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 19 = cloudabi_sys_file_create */
+	{ AS(cloudabi_sys_file_link_args), (sy_call_t *)cloudabi_sys_file_link, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 20 = cloudabi_sys_file_link */
+	{ AS(cloudabi_sys_file_open_args), (sy_call_t *)cloudabi_sys_file_open, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 21 = cloudabi_sys_file_open */
+	{ AS(cloudabi_sys_file_readdir_args), (sy_call_t *)cloudabi_sys_file_readdir, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 22 = cloudabi_sys_file_readdir */
+	{ AS(cloudabi_sys_file_readlink_args), (sy_call_t *)cloudabi_sys_file_readlink, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 23 = cloudabi_sys_file_readlink */
+	{ AS(cloudabi_sys_file_rename_args), (sy_call_t *)cloudabi_sys_file_rename, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 24 = cloudabi_sys_file_rename */
+	{ AS(cloudabi_sys_file_stat_fget_args), (sy_call_t *)cloudabi_sys_file_stat_fget, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 25 = cloudabi_sys_file_stat_fget */
+	{ AS(cloudabi_sys_file_stat_fput_args), (sy_call_t *)cloudabi_sys_file_stat_fput, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 26 = cloudabi_sys_file_stat_fput */
+	{ AS(cloudabi_sys_file_stat_get_args), (sy_call_t *)cloudabi_sys_file_stat_get, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 27 = cloudabi_sys_file_stat_get */
+	{ AS(cloudabi_sys_file_stat_put_args), (sy_call_t *)cloudabi_sys_file_stat_put, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 28 = cloudabi_sys_file_stat_put */
+	{ AS(cloudabi_sys_file_symlink_args), (sy_call_t *)cloudabi_sys_file_symlink, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 29 = cloudabi_sys_file_symlink */
+	{ AS(cloudabi_sys_file_unlink_args), (sy_call_t *)cloudabi_sys_file_unlink, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 30 = cloudabi_sys_file_unlink */
+	{ AS(cloudabi_sys_lock_unlock_args), (sy_call_t *)cloudabi_sys_lock_unlock, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 31 = cloudabi_sys_lock_unlock */
+	{ AS(cloudabi_sys_mem_advise_args), (sy_call_t *)cloudabi_sys_mem_advise, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 32 = cloudabi_sys_mem_advise */
+	{ AS(cloudabi_sys_mem_lock_args), (sy_call_t *)cloudabi_sys_mem_lock, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 33 = cloudabi_sys_mem_lock */
+	{ AS(cloudabi_sys_mem_map_args), (sy_call_t *)cloudabi_sys_mem_map, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 34 = cloudabi_sys_mem_map */
+	{ AS(cloudabi_sys_mem_protect_args), (sy_call_t *)cloudabi_sys_mem_protect, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 35 = cloudabi_sys_mem_protect */
+	{ AS(cloudabi_sys_mem_sync_args), (sy_call_t *)cloudabi_sys_mem_sync, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 36 = cloudabi_sys_mem_sync */
+	{ AS(cloudabi_sys_mem_unlock_args), (sy_call_t *)cloudabi_sys_mem_unlock, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 37 = cloudabi_sys_mem_unlock */
+	{ AS(cloudabi_sys_mem_unmap_args), (sy_call_t *)cloudabi_sys_mem_unmap, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 38 = cloudabi_sys_mem_unmap */
+	{ AS(cloudabi32_sys_poll_args), (sy_call_t *)cloudabi32_sys_poll, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 39 = cloudabi32_sys_poll */
+	{ AS(cloudabi32_sys_poll_fd_args), (sy_call_t *)cloudabi32_sys_poll_fd, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 40 = cloudabi32_sys_poll_fd */
+	{ AS(cloudabi_sys_proc_exec_args), (sy_call_t *)cloudabi_sys_proc_exec, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 41 = cloudabi_sys_proc_exec */
+	{ AS(cloudabi_sys_proc_exit_args), (sy_call_t *)cloudabi_sys_proc_exit, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 42 = cloudabi_sys_proc_exit */
+	{ 0, (sy_call_t *)cloudabi_sys_proc_fork, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 43 = cloudabi_sys_proc_fork */
+	{ AS(cloudabi_sys_proc_raise_args), (sy_call_t *)cloudabi_sys_proc_raise, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 44 = cloudabi_sys_proc_raise */
+	{ AS(cloudabi_sys_random_get_args), (sy_call_t *)cloudabi_sys_random_get, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 45 = cloudabi_sys_random_get */
+	{ AS(cloudabi_sys_sock_accept_args), (sy_call_t *)cloudabi_sys_sock_accept, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 46 = cloudabi_sys_sock_accept */
+	{ AS(cloudabi_sys_sock_bind_args), (sy_call_t *)cloudabi_sys_sock_bind, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 47 = cloudabi_sys_sock_bind */
+	{ AS(cloudabi_sys_sock_connect_args), (sy_call_t *)cloudabi_sys_sock_connect, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 48 = cloudabi_sys_sock_connect */
+	{ AS(cloudabi_sys_sock_listen_args), (sy_call_t *)cloudabi_sys_sock_listen, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 49 = cloudabi_sys_sock_listen */
+	{ AS(cloudabi32_sys_sock_recv_args), (sy_call_t *)cloudabi32_sys_sock_recv, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 50 = cloudabi32_sys_sock_recv */
+	{ AS(cloudabi32_sys_sock_send_args), (sy_call_t *)cloudabi32_sys_sock_send, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 51 = cloudabi32_sys_sock_send */
+	{ AS(cloudabi_sys_sock_shutdown_args), (sy_call_t *)cloudabi_sys_sock_shutdown, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 52 = cloudabi_sys_sock_shutdown */
+	{ AS(cloudabi_sys_sock_stat_get_args), (sy_call_t *)cloudabi_sys_sock_stat_get, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 53 = cloudabi_sys_sock_stat_get */
+	{ AS(cloudabi32_sys_thread_create_args), (sy_call_t *)cloudabi32_sys_thread_create, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 54 = cloudabi32_sys_thread_create */
+	{ AS(cloudabi_sys_thread_exit_args), (sy_call_t *)cloudabi_sys_thread_exit, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 55 = cloudabi_sys_thread_exit */
+	{ 0, (sy_call_t *)cloudabi_sys_thread_yield, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },	/* 56 = cloudabi_sys_thread_yield */
+};
diff --git a/sys/compat/cloudabi32/cloudabi32_systrace_args.c b/sys/compat/cloudabi32/cloudabi32_systrace_args.c
new file mode 100644
index 0000000..0ba5ec5
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_systrace_args.c
@@ -0,0 +1,1702 @@
+/*
+ * System call argument to DTrace register array converstion.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * $FreeBSD$
+ * This file is part of the DTrace syscall provider.
+ */
+
+static void
+systrace_args(int sysnum, void *params, uint64_t *uarg, int *n_args)
+{
+	int64_t *iarg  = (int64_t *) uarg;
+	switch (sysnum) {
+	/* cloudabi_sys_clock_res_get */
+	case 0: {
+		struct cloudabi_sys_clock_res_get_args *p = params;
+		iarg[0] = p->clock_id; /* cloudabi_clockid_t */
+		*n_args = 1;
+		break;
+	}
+	/* cloudabi_sys_clock_time_get */
+	case 1: {
+		struct cloudabi_sys_clock_time_get_args *p = params;
+		iarg[0] = p->clock_id; /* cloudabi_clockid_t */
+		iarg[1] = p->precision; /* cloudabi_timestamp_t */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_condvar_signal */
+	case 2: {
+		struct cloudabi_sys_condvar_signal_args *p = params;
+		uarg[0] = (intptr_t) p->condvar; /* cloudabi_condvar_t * */
+		iarg[1] = p->scope; /* cloudabi_scope_t */
+		iarg[2] = p->nwaiters; /* cloudabi_nthreads_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_fd_close */
+	case 3: {
+		struct cloudabi_sys_fd_close_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		*n_args = 1;
+		break;
+	}
+	/* cloudabi_sys_fd_create1 */
+	case 4: {
+		struct cloudabi_sys_fd_create1_args *p = params;
+		iarg[0] = p->type; /* cloudabi_filetype_t */
+		*n_args = 1;
+		break;
+	}
+	/* cloudabi_sys_fd_create2 */
+	case 5: {
+		struct cloudabi_sys_fd_create2_args *p = params;
+		iarg[0] = p->type; /* cloudabi_filetype_t */
+		*n_args = 1;
+		break;
+	}
+	/* cloudabi_sys_fd_datasync */
+	case 6: {
+		struct cloudabi_sys_fd_datasync_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		*n_args = 1;
+		break;
+	}
+	/* cloudabi_sys_fd_dup */
+	case 7: {
+		struct cloudabi_sys_fd_dup_args *p = params;
+		iarg[0] = p->from; /* cloudabi_fd_t */
+		*n_args = 1;
+		break;
+	}
+	/* cloudabi32_sys_fd_pread */
+	case 8: {
+		struct cloudabi32_sys_fd_pread_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->iov; /* const cloudabi32_iovec_t * */
+		uarg[2] = p->iovcnt; /* size_t */
+		iarg[3] = p->offset; /* cloudabi_filesize_t */
+		*n_args = 4;
+		break;
+	}
+	/* cloudabi32_sys_fd_pwrite */
+	case 9: {
+		struct cloudabi32_sys_fd_pwrite_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->iov; /* const cloudabi32_ciovec_t * */
+		uarg[2] = p->iovcnt; /* size_t */
+		iarg[3] = p->offset; /* cloudabi_filesize_t */
+		*n_args = 4;
+		break;
+	}
+	/* cloudabi32_sys_fd_read */
+	case 10: {
+		struct cloudabi32_sys_fd_read_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->iov; /* const cloudabi32_iovec_t * */
+		uarg[2] = p->iovcnt; /* size_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_fd_replace */
+	case 11: {
+		struct cloudabi_sys_fd_replace_args *p = params;
+		iarg[0] = p->from; /* cloudabi_fd_t */
+		iarg[1] = p->to; /* cloudabi_fd_t */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_fd_seek */
+	case 12: {
+		struct cloudabi_sys_fd_seek_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		iarg[1] = p->offset; /* cloudabi_filedelta_t */
+		iarg[2] = p->whence; /* cloudabi_whence_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_fd_stat_get */
+	case 13: {
+		struct cloudabi_sys_fd_stat_get_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->buf; /* cloudabi_fdstat_t * */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_fd_stat_put */
+	case 14: {
+		struct cloudabi_sys_fd_stat_put_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->buf; /* const cloudabi_fdstat_t * */
+		iarg[2] = p->flags; /* cloudabi_fdsflags_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_fd_sync */
+	case 15: {
+		struct cloudabi_sys_fd_sync_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		*n_args = 1;
+		break;
+	}
+	/* cloudabi32_sys_fd_write */
+	case 16: {
+		struct cloudabi32_sys_fd_write_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->iov; /* const cloudabi32_ciovec_t * */
+		uarg[2] = p->iovcnt; /* size_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_file_advise */
+	case 17: {
+		struct cloudabi_sys_file_advise_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		iarg[1] = p->offset; /* cloudabi_filesize_t */
+		iarg[2] = p->len; /* cloudabi_filesize_t */
+		iarg[3] = p->advice; /* cloudabi_advice_t */
+		*n_args = 4;
+		break;
+	}
+	/* cloudabi_sys_file_allocate */
+	case 18: {
+		struct cloudabi_sys_file_allocate_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		iarg[1] = p->offset; /* cloudabi_filesize_t */
+		iarg[2] = p->len; /* cloudabi_filesize_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_file_create */
+	case 19: {
+		struct cloudabi_sys_file_create_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->path; /* const char * */
+		uarg[2] = p->pathlen; /* size_t */
+		iarg[3] = p->type; /* cloudabi_filetype_t */
+		*n_args = 4;
+		break;
+	}
+	/* cloudabi_sys_file_link */
+	case 20: {
+		struct cloudabi_sys_file_link_args *p = params;
+		iarg[0] = p->fd1; /* cloudabi_lookup_t */
+		uarg[1] = (intptr_t) p->path1; /* const char * */
+		uarg[2] = p->path1len; /* size_t */
+		iarg[3] = p->fd2; /* cloudabi_fd_t */
+		uarg[4] = (intptr_t) p->path2; /* const char * */
+		uarg[5] = p->path2len; /* size_t */
+		*n_args = 6;
+		break;
+	}
+	/* cloudabi_sys_file_open */
+	case 21: {
+		struct cloudabi_sys_file_open_args *p = params;
+		iarg[0] = p->dirfd; /* cloudabi_lookup_t */
+		uarg[1] = (intptr_t) p->path; /* const char * */
+		uarg[2] = p->pathlen; /* size_t */
+		iarg[3] = p->oflags; /* cloudabi_oflags_t */
+		uarg[4] = (intptr_t) p->fds; /* const cloudabi_fdstat_t * */
+		*n_args = 5;
+		break;
+	}
+	/* cloudabi_sys_file_readdir */
+	case 22: {
+		struct cloudabi_sys_file_readdir_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->buf; /* void * */
+		uarg[2] = p->nbyte; /* size_t */
+		iarg[3] = p->cookie; /* cloudabi_dircookie_t */
+		*n_args = 4;
+		break;
+	}
+	/* cloudabi_sys_file_readlink */
+	case 23: {
+		struct cloudabi_sys_file_readlink_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->path; /* const char * */
+		uarg[2] = p->pathlen; /* size_t */
+		uarg[3] = (intptr_t) p->buf; /* char * */
+		uarg[4] = p->bufsize; /* size_t */
+		*n_args = 5;
+		break;
+	}
+	/* cloudabi_sys_file_rename */
+	case 24: {
+		struct cloudabi_sys_file_rename_args *p = params;
+		iarg[0] = p->oldfd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->old; /* const char * */
+		uarg[2] = p->oldlen; /* size_t */
+		iarg[3] = p->newfd; /* cloudabi_fd_t */
+		uarg[4] = (intptr_t) p->new; /* const char * */
+		uarg[5] = p->newlen; /* size_t */
+		*n_args = 6;
+		break;
+	}
+	/* cloudabi_sys_file_stat_fget */
+	case 25: {
+		struct cloudabi_sys_file_stat_fget_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->buf; /* cloudabi_filestat_t * */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_file_stat_fput */
+	case 26: {
+		struct cloudabi_sys_file_stat_fput_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->buf; /* const cloudabi_filestat_t * */
+		iarg[2] = p->flags; /* cloudabi_fsflags_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_file_stat_get */
+	case 27: {
+		struct cloudabi_sys_file_stat_get_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_lookup_t */
+		uarg[1] = (intptr_t) p->path; /* const char * */
+		uarg[2] = p->pathlen; /* size_t */
+		uarg[3] = (intptr_t) p->buf; /* cloudabi_filestat_t * */
+		*n_args = 4;
+		break;
+	}
+	/* cloudabi_sys_file_stat_put */
+	case 28: {
+		struct cloudabi_sys_file_stat_put_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_lookup_t */
+		uarg[1] = (intptr_t) p->path; /* const char * */
+		uarg[2] = p->pathlen; /* size_t */
+		uarg[3] = (intptr_t) p->buf; /* const cloudabi_filestat_t * */
+		iarg[4] = p->flags; /* cloudabi_fsflags_t */
+		*n_args = 5;
+		break;
+	}
+	/* cloudabi_sys_file_symlink */
+	case 29: {
+		struct cloudabi_sys_file_symlink_args *p = params;
+		uarg[0] = (intptr_t) p->path1; /* const char * */
+		uarg[1] = p->path1len; /* size_t */
+		iarg[2] = p->fd; /* cloudabi_fd_t */
+		uarg[3] = (intptr_t) p->path2; /* const char * */
+		uarg[4] = p->path2len; /* size_t */
+		*n_args = 5;
+		break;
+	}
+	/* cloudabi_sys_file_unlink */
+	case 30: {
+		struct cloudabi_sys_file_unlink_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->path; /* const char * */
+		uarg[2] = p->pathlen; /* size_t */
+		iarg[3] = p->flags; /* cloudabi_ulflags_t */
+		*n_args = 4;
+		break;
+	}
+	/* cloudabi_sys_lock_unlock */
+	case 31: {
+		struct cloudabi_sys_lock_unlock_args *p = params;
+		uarg[0] = (intptr_t) p->lock; /* cloudabi_lock_t * */
+		iarg[1] = p->scope; /* cloudabi_scope_t */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_mem_advise */
+	case 32: {
+		struct cloudabi_sys_mem_advise_args *p = params;
+		uarg[0] = (intptr_t) p->addr; /* void * */
+		uarg[1] = p->len; /* size_t */
+		iarg[2] = p->advice; /* cloudabi_advice_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_mem_lock */
+	case 33: {
+		struct cloudabi_sys_mem_lock_args *p = params;
+		uarg[0] = (intptr_t) p->addr; /* const void * */
+		uarg[1] = p->len; /* size_t */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_mem_map */
+	case 34: {
+		struct cloudabi_sys_mem_map_args *p = params;
+		uarg[0] = (intptr_t) p->addr; /* void * */
+		uarg[1] = p->len; /* size_t */
+		iarg[2] = p->prot; /* cloudabi_mprot_t */
+		iarg[3] = p->flags; /* cloudabi_mflags_t */
+		iarg[4] = p->fd; /* cloudabi_fd_t */
+		iarg[5] = p->off; /* cloudabi_filesize_t */
+		*n_args = 6;
+		break;
+	}
+	/* cloudabi_sys_mem_protect */
+	case 35: {
+		struct cloudabi_sys_mem_protect_args *p = params;
+		uarg[0] = (intptr_t) p->addr; /* void * */
+		uarg[1] = p->len; /* size_t */
+		iarg[2] = p->prot; /* cloudabi_mprot_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_mem_sync */
+	case 36: {
+		struct cloudabi_sys_mem_sync_args *p = params;
+		uarg[0] = (intptr_t) p->addr; /* void * */
+		uarg[1] = p->len; /* size_t */
+		iarg[2] = p->flags; /* cloudabi_msflags_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_mem_unlock */
+	case 37: {
+		struct cloudabi_sys_mem_unlock_args *p = params;
+		uarg[0] = (intptr_t) p->addr; /* const void * */
+		uarg[1] = p->len; /* size_t */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_mem_unmap */
+	case 38: {
+		struct cloudabi_sys_mem_unmap_args *p = params;
+		uarg[0] = (intptr_t) p->addr; /* void * */
+		uarg[1] = p->len; /* size_t */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi32_sys_poll */
+	case 39: {
+		struct cloudabi32_sys_poll_args *p = params;
+		uarg[0] = (intptr_t) p->in; /* const cloudabi32_subscription_t * */
+		uarg[1] = (intptr_t) p->out; /* cloudabi32_event_t * */
+		uarg[2] = p->nsubscriptions; /* size_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi32_sys_poll_fd */
+	case 40: {
+		struct cloudabi32_sys_poll_fd_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->in; /* const cloudabi32_subscription_t * */
+		uarg[2] = p->nin; /* size_t */
+		uarg[3] = (intptr_t) p->out; /* cloudabi32_event_t * */
+		uarg[4] = p->nout; /* size_t */
+		uarg[5] = (intptr_t) p->timeout; /* const cloudabi32_subscription_t * */
+		*n_args = 6;
+		break;
+	}
+	/* cloudabi_sys_proc_exec */
+	case 41: {
+		struct cloudabi_sys_proc_exec_args *p = params;
+		iarg[0] = p->fd; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->data; /* const void * */
+		uarg[2] = p->datalen; /* size_t */
+		uarg[3] = (intptr_t) p->fds; /* const cloudabi_fd_t * */
+		uarg[4] = p->fdslen; /* size_t */
+		*n_args = 5;
+		break;
+	}
+	/* cloudabi_sys_proc_exit */
+	case 42: {
+		struct cloudabi_sys_proc_exit_args *p = params;
+		iarg[0] = p->rval; /* cloudabi_exitcode_t */
+		*n_args = 1;
+		break;
+	}
+	/* cloudabi_sys_proc_fork */
+	case 43: {
+		*n_args = 0;
+		break;
+	}
+	/* cloudabi_sys_proc_raise */
+	case 44: {
+		struct cloudabi_sys_proc_raise_args *p = params;
+		iarg[0] = p->sig; /* cloudabi_signal_t */
+		*n_args = 1;
+		break;
+	}
+	/* cloudabi_sys_random_get */
+	case 45: {
+		struct cloudabi_sys_random_get_args *p = params;
+		uarg[0] = (intptr_t) p->buf; /* void * */
+		uarg[1] = p->nbyte; /* size_t */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_sock_accept */
+	case 46: {
+		struct cloudabi_sys_sock_accept_args *p = params;
+		iarg[0] = p->sock; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->buf; /* cloudabi_sockstat_t * */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_sock_bind */
+	case 47: {
+		struct cloudabi_sys_sock_bind_args *p = params;
+		iarg[0] = p->sock; /* cloudabi_fd_t */
+		iarg[1] = p->fd; /* cloudabi_fd_t */
+		uarg[2] = (intptr_t) p->path; /* const char * */
+		uarg[3] = p->pathlen; /* size_t */
+		*n_args = 4;
+		break;
+	}
+	/* cloudabi_sys_sock_connect */
+	case 48: {
+		struct cloudabi_sys_sock_connect_args *p = params;
+		iarg[0] = p->sock; /* cloudabi_fd_t */
+		iarg[1] = p->fd; /* cloudabi_fd_t */
+		uarg[2] = (intptr_t) p->path; /* const char * */
+		uarg[3] = p->pathlen; /* size_t */
+		*n_args = 4;
+		break;
+	}
+	/* cloudabi_sys_sock_listen */
+	case 49: {
+		struct cloudabi_sys_sock_listen_args *p = params;
+		iarg[0] = p->sock; /* cloudabi_fd_t */
+		iarg[1] = p->backlog; /* cloudabi_backlog_t */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi32_sys_sock_recv */
+	case 50: {
+		struct cloudabi32_sys_sock_recv_args *p = params;
+		iarg[0] = p->sock; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->in; /* const cloudabi32_recv_in_t * */
+		uarg[2] = (intptr_t) p->out; /* cloudabi32_recv_out_t * */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi32_sys_sock_send */
+	case 51: {
+		struct cloudabi32_sys_sock_send_args *p = params;
+		iarg[0] = p->sock; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->in; /* const cloudabi32_send_in_t * */
+		uarg[2] = (intptr_t) p->out; /* cloudabi32_send_out_t * */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi_sys_sock_shutdown */
+	case 52: {
+		struct cloudabi_sys_sock_shutdown_args *p = params;
+		iarg[0] = p->sock; /* cloudabi_fd_t */
+		iarg[1] = p->how; /* cloudabi_sdflags_t */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_sock_stat_get */
+	case 53: {
+		struct cloudabi_sys_sock_stat_get_args *p = params;
+		iarg[0] = p->sock; /* cloudabi_fd_t */
+		uarg[1] = (intptr_t) p->buf; /* cloudabi_sockstat_t * */
+		iarg[2] = p->flags; /* cloudabi_ssflags_t */
+		*n_args = 3;
+		break;
+	}
+	/* cloudabi32_sys_thread_create */
+	case 54: {
+		struct cloudabi32_sys_thread_create_args *p = params;
+		uarg[0] = (intptr_t) p->attr; /* cloudabi32_threadattr_t * */
+		*n_args = 1;
+		break;
+	}
+	/* cloudabi_sys_thread_exit */
+	case 55: {
+		struct cloudabi_sys_thread_exit_args *p = params;
+		uarg[0] = (intptr_t) p->lock; /* cloudabi_lock_t * */
+		iarg[1] = p->scope; /* cloudabi_scope_t */
+		*n_args = 2;
+		break;
+	}
+	/* cloudabi_sys_thread_yield */
+	case 56: {
+		*n_args = 0;
+		break;
+	}
+	default:
+		*n_args = 0;
+		break;
+	};
+}
+static void
+systrace_entry_setargdesc(int sysnum, int ndx, char *desc, size_t descsz)
+{
+	const char *p = NULL;
+	switch (sysnum) {
+	/* cloudabi_sys_clock_res_get */
+	case 0:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_clockid_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_clock_time_get */
+	case 1:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_clockid_t";
+			break;
+		case 1:
+			p = "cloudabi_timestamp_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_condvar_signal */
+	case 2:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_condvar_t *";
+			break;
+		case 1:
+			p = "cloudabi_scope_t";
+			break;
+		case 2:
+			p = "cloudabi_nthreads_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_fd_close */
+	case 3:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_fd_create1 */
+	case 4:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_filetype_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_fd_create2 */
+	case 5:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_filetype_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_fd_datasync */
+	case 6:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_fd_dup */
+	case 7:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi32_sys_fd_pread */
+	case 8:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const cloudabi32_iovec_t *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "cloudabi_filesize_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi32_sys_fd_pwrite */
+	case 9:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const cloudabi32_ciovec_t *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "cloudabi_filesize_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi32_sys_fd_read */
+	case 10:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const cloudabi32_iovec_t *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_fd_replace */
+	case 11:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_fd_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_fd_seek */
+	case 12:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_filedelta_t";
+			break;
+		case 2:
+			p = "cloudabi_whence_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_fd_stat_get */
+	case 13:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_fdstat_t *";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_fd_stat_put */
+	case 14:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const cloudabi_fdstat_t *";
+			break;
+		case 2:
+			p = "cloudabi_fdsflags_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_fd_sync */
+	case 15:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi32_sys_fd_write */
+	case 16:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const cloudabi32_ciovec_t *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_advise */
+	case 17:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_filesize_t";
+			break;
+		case 2:
+			p = "cloudabi_filesize_t";
+			break;
+		case 3:
+			p = "cloudabi_advice_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_allocate */
+	case 18:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_filesize_t";
+			break;
+		case 2:
+			p = "cloudabi_filesize_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_create */
+	case 19:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const char *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "cloudabi_filetype_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_link */
+	case 20:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_lookup_t";
+			break;
+		case 1:
+			p = "const char *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "cloudabi_fd_t";
+			break;
+		case 4:
+			p = "const char *";
+			break;
+		case 5:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_open */
+	case 21:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_lookup_t";
+			break;
+		case 1:
+			p = "const char *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "cloudabi_oflags_t";
+			break;
+		case 4:
+			p = "const cloudabi_fdstat_t *";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_readdir */
+	case 22:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "void *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "cloudabi_dircookie_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_readlink */
+	case 23:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const char *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "char *";
+			break;
+		case 4:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_rename */
+	case 24:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const char *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "cloudabi_fd_t";
+			break;
+		case 4:
+			p = "const char *";
+			break;
+		case 5:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_stat_fget */
+	case 25:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_filestat_t *";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_stat_fput */
+	case 26:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const cloudabi_filestat_t *";
+			break;
+		case 2:
+			p = "cloudabi_fsflags_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_stat_get */
+	case 27:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_lookup_t";
+			break;
+		case 1:
+			p = "const char *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "cloudabi_filestat_t *";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_stat_put */
+	case 28:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_lookup_t";
+			break;
+		case 1:
+			p = "const char *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "const cloudabi_filestat_t *";
+			break;
+		case 4:
+			p = "cloudabi_fsflags_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_symlink */
+	case 29:
+		switch(ndx) {
+		case 0:
+			p = "const char *";
+			break;
+		case 1:
+			p = "size_t";
+			break;
+		case 2:
+			p = "cloudabi_fd_t";
+			break;
+		case 3:
+			p = "const char *";
+			break;
+		case 4:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_file_unlink */
+	case 30:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const char *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "cloudabi_ulflags_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_lock_unlock */
+	case 31:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_lock_t *";
+			break;
+		case 1:
+			p = "cloudabi_scope_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_mem_advise */
+	case 32:
+		switch(ndx) {
+		case 0:
+			p = "void *";
+			break;
+		case 1:
+			p = "size_t";
+			break;
+		case 2:
+			p = "cloudabi_advice_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_mem_lock */
+	case 33:
+		switch(ndx) {
+		case 0:
+			p = "const void *";
+			break;
+		case 1:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_mem_map */
+	case 34:
+		switch(ndx) {
+		case 0:
+			p = "void *";
+			break;
+		case 1:
+			p = "size_t";
+			break;
+		case 2:
+			p = "cloudabi_mprot_t";
+			break;
+		case 3:
+			p = "cloudabi_mflags_t";
+			break;
+		case 4:
+			p = "cloudabi_fd_t";
+			break;
+		case 5:
+			p = "cloudabi_filesize_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_mem_protect */
+	case 35:
+		switch(ndx) {
+		case 0:
+			p = "void *";
+			break;
+		case 1:
+			p = "size_t";
+			break;
+		case 2:
+			p = "cloudabi_mprot_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_mem_sync */
+	case 36:
+		switch(ndx) {
+		case 0:
+			p = "void *";
+			break;
+		case 1:
+			p = "size_t";
+			break;
+		case 2:
+			p = "cloudabi_msflags_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_mem_unlock */
+	case 37:
+		switch(ndx) {
+		case 0:
+			p = "const void *";
+			break;
+		case 1:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_mem_unmap */
+	case 38:
+		switch(ndx) {
+		case 0:
+			p = "void *";
+			break;
+		case 1:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi32_sys_poll */
+	case 39:
+		switch(ndx) {
+		case 0:
+			p = "const cloudabi32_subscription_t *";
+			break;
+		case 1:
+			p = "cloudabi32_event_t *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi32_sys_poll_fd */
+	case 40:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const cloudabi32_subscription_t *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "cloudabi32_event_t *";
+			break;
+		case 4:
+			p = "size_t";
+			break;
+		case 5:
+			p = "const cloudabi32_subscription_t *";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_proc_exec */
+	case 41:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const void *";
+			break;
+		case 2:
+			p = "size_t";
+			break;
+		case 3:
+			p = "const cloudabi_fd_t *";
+			break;
+		case 4:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_proc_exit */
+	case 42:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_exitcode_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_proc_fork */
+	case 43:
+		break;
+	/* cloudabi_sys_proc_raise */
+	case 44:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_signal_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_random_get */
+	case 45:
+		switch(ndx) {
+		case 0:
+			p = "void *";
+			break;
+		case 1:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_sock_accept */
+	case 46:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_sockstat_t *";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_sock_bind */
+	case 47:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_fd_t";
+			break;
+		case 2:
+			p = "const char *";
+			break;
+		case 3:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_sock_connect */
+	case 48:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_fd_t";
+			break;
+		case 2:
+			p = "const char *";
+			break;
+		case 3:
+			p = "size_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_sock_listen */
+	case 49:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_backlog_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi32_sys_sock_recv */
+	case 50:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const cloudabi32_recv_in_t *";
+			break;
+		case 2:
+			p = "cloudabi32_recv_out_t *";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi32_sys_sock_send */
+	case 51:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "const cloudabi32_send_in_t *";
+			break;
+		case 2:
+			p = "cloudabi32_send_out_t *";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_sock_shutdown */
+	case 52:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_sdflags_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_sock_stat_get */
+	case 53:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_fd_t";
+			break;
+		case 1:
+			p = "cloudabi_sockstat_t *";
+			break;
+		case 2:
+			p = "cloudabi_ssflags_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi32_sys_thread_create */
+	case 54:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi32_threadattr_t *";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_thread_exit */
+	case 55:
+		switch(ndx) {
+		case 0:
+			p = "cloudabi_lock_t *";
+			break;
+		case 1:
+			p = "cloudabi_scope_t";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* cloudabi_sys_thread_yield */
+	case 56:
+		break;
+	default:
+		break;
+	};
+	if (p != NULL)
+		strlcpy(desc, p, descsz);
+}
+static void
+systrace_return_setargdesc(int sysnum, int ndx, char *desc, size_t descsz)
+{
+	const char *p = NULL;
+	switch (sysnum) {
+	/* cloudabi_sys_clock_res_get */
+	case 0:
+		if (ndx == 0 || ndx == 1)
+			p = "cloudabi_timestamp_t";
+		break;
+	/* cloudabi_sys_clock_time_get */
+	case 1:
+		if (ndx == 0 || ndx == 1)
+			p = "cloudabi_timestamp_t";
+		break;
+	/* cloudabi_sys_condvar_signal */
+	case 2:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_fd_close */
+	case 3:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_fd_create1 */
+	case 4:
+		if (ndx == 0 || ndx == 1)
+			p = "cloudabi_fd_t";
+		break;
+	/* cloudabi_sys_fd_create2 */
+	case 5:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_fd_datasync */
+	case 6:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_fd_dup */
+	case 7:
+		if (ndx == 0 || ndx == 1)
+			p = "cloudabi_fd_t";
+		break;
+	/* cloudabi32_sys_fd_pread */
+	case 8:
+		if (ndx == 0 || ndx == 1)
+			p = "size_t";
+		break;
+	/* cloudabi32_sys_fd_pwrite */
+	case 9:
+		if (ndx == 0 || ndx == 1)
+			p = "size_t";
+		break;
+	/* cloudabi32_sys_fd_read */
+	case 10:
+		if (ndx == 0 || ndx == 1)
+			p = "size_t";
+		break;
+	/* cloudabi_sys_fd_replace */
+	case 11:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_fd_seek */
+	case 12:
+		if (ndx == 0 || ndx == 1)
+			p = "cloudabi_filesize_t";
+		break;
+	/* cloudabi_sys_fd_stat_get */
+	case 13:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_fd_stat_put */
+	case 14:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_fd_sync */
+	case 15:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi32_sys_fd_write */
+	case 16:
+		if (ndx == 0 || ndx == 1)
+			p = "size_t";
+		break;
+	/* cloudabi_sys_file_advise */
+	case 17:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_file_allocate */
+	case 18:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_file_create */
+	case 19:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_file_link */
+	case 20:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_file_open */
+	case 21:
+		if (ndx == 0 || ndx == 1)
+			p = "cloudabi_fd_t";
+		break;
+	/* cloudabi_sys_file_readdir */
+	case 22:
+		if (ndx == 0 || ndx == 1)
+			p = "size_t";
+		break;
+	/* cloudabi_sys_file_readlink */
+	case 23:
+		if (ndx == 0 || ndx == 1)
+			p = "size_t";
+		break;
+	/* cloudabi_sys_file_rename */
+	case 24:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_file_stat_fget */
+	case 25:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_file_stat_fput */
+	case 26:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_file_stat_get */
+	case 27:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_file_stat_put */
+	case 28:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_file_symlink */
+	case 29:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_file_unlink */
+	case 30:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_lock_unlock */
+	case 31:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_mem_advise */
+	case 32:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_mem_lock */
+	case 33:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_mem_map */
+	case 34:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_mem_protect */
+	case 35:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_mem_sync */
+	case 36:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_mem_unlock */
+	case 37:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_mem_unmap */
+	case 38:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi32_sys_poll */
+	case 39:
+		if (ndx == 0 || ndx == 1)
+			p = "size_t";
+		break;
+	/* cloudabi32_sys_poll_fd */
+	case 40:
+		if (ndx == 0 || ndx == 1)
+			p = "size_t";
+		break;
+	/* cloudabi_sys_proc_exec */
+	case 41:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_proc_exit */
+	case 42:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_proc_fork */
+	case 43:
+	/* cloudabi_sys_proc_raise */
+	case 44:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_random_get */
+	case 45:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_sock_accept */
+	case 46:
+		if (ndx == 0 || ndx == 1)
+			p = "cloudabi_fd_t";
+		break;
+	/* cloudabi_sys_sock_bind */
+	case 47:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_sock_connect */
+	case 48:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_sock_listen */
+	case 49:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi32_sys_sock_recv */
+	case 50:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi32_sys_sock_send */
+	case 51:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_sock_shutdown */
+	case 52:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_sock_stat_get */
+	case 53:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi32_sys_thread_create */
+	case 54:
+		if (ndx == 0 || ndx == 1)
+			p = "cloudabi_tid_t";
+		break;
+	/* cloudabi_sys_thread_exit */
+	case 55:
+		if (ndx == 0 || ndx == 1)
+			p = "void";
+		break;
+	/* cloudabi_sys_thread_yield */
+	case 56:
+	default:
+		break;
+	};
+	if (p != NULL)
+		strlcpy(desc, p, descsz);
+}
diff --git a/sys/compat/cloudabi32/cloudabi32_thread.c b/sys/compat/cloudabi32/cloudabi32_thread.c
new file mode 100644
index 0000000..50538d9
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_thread.c
@@ -0,0 +1,77 @@
+/*-
+ * Copyright (c) 2015 Nuxi, https://nuxi.nl/
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/proc.h>
+#include <sys/systm.h>
+
+#include <contrib/cloudabi/cloudabi32_types.h>
+
+#include <compat/cloudabi32/cloudabi32_proto.h>
+#include <compat/cloudabi32/cloudabi32_util.h>
+
+struct thread_create_args {
+	cloudabi32_threadattr_t attr;
+	uint32_t tcb;
+	lwpid_t tid;
+};
+
+static int
+initialize_thread(struct thread *td, void *thunk)
+{
+	struct thread_create_args *args = thunk;
+
+	/* Save the thread ID, so it can be returned. */
+	args->tid = td->td_tid;
+
+	/* Set up initial register contents. */
+	return (cloudabi32_thread_setregs(td, &args->attr, args->tcb));
+}
+
+int
+cloudabi32_sys_thread_create(struct thread *td,
+    struct cloudabi32_sys_thread_create_args *uap)
+{
+	struct thread_create_args args;
+	int error;
+
+	error = copyin(uap->attr, &args.attr, sizeof(args.attr));
+	if (error != 0)
+		return (error);
+
+	/* Remove some space on the top of the stack for the TCB. */
+	args.tcb = rounddown(args.attr.stack + args.attr.stack_size -
+	    sizeof(cloudabi32_tcb_t), _Alignof(cloudabi32_tcb_t));
+	args.attr.stack_size = args.tcb - args.attr.stack;
+
+	error = thread_create(td, NULL, initialize_thread, &args);
+	if (error != 0)
+		return (error);
+	td->td_retval[0] = args.tid;
+	return (0);
+}
diff --git a/sys/compat/cloudabi32/cloudabi32_util.h b/sys/compat/cloudabi32/cloudabi32_util.h
new file mode 100644
index 0000000..c08c91e
--- /dev/null
+++ b/sys/compat/cloudabi32/cloudabi32_util.h
@@ -0,0 +1,51 @@
+/*-
+ * Copyright (c) 2015 Nuxi, https://nuxi.nl/
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _CLOUDABI32_UTIL_H_
+#define	_CLOUDABI32_UTIL_H_
+
+#include <sys/types.h>
+#define	__ELF_WORD_SIZE	32
+#include <sys/imgact_elf.h>
+
+#include <contrib/cloudabi/cloudabi32_types.h>
+
+struct image_params;
+struct thread;
+
+extern Elf32_Brandinfo cloudabi32_brand;
+
+#define	TO_PTR(x)	((void *)(uintptr_t)(x))
+
+/* Stack initialization during process execution. */
+register_t *cloudabi32_copyout_strings(struct image_params *);
+int	cloudabi32_fixup(register_t **, struct image_params *);
+
+int	cloudabi32_thread_setregs(struct thread *,
+    const cloudabi32_threadattr_t *, uint32_t);
+
+#endif
diff --git a/sys/compat/cloudabi32/syscalls.conf b/sys/compat/cloudabi32/syscalls.conf
new file mode 100644
index 0000000..8e6522a
--- /dev/null
+++ b/sys/compat/cloudabi32/syscalls.conf
@@ -0,0 +1,15 @@
+# $FreeBSD$
+sysnames="cloudabi32_syscalls.c"
+sysproto="cloudabi32_proto.h"
+sysproto_h=_CLOUDABI32_SYSPROTO_H_
+syshdr="cloudabi32_syscall.h"
+syssw="cloudabi32_sysent.c"
+sysmk="/dev/null"
+syscallprefix="CLOUDABI32_SYS_"
+switchname="cloudabi32_sysent"
+namesname="cloudabi32_syscallnames"
+systrace="cloudabi32_systrace_args.c"
+
+# Allow all system calls in capabilities mode. Extract the names of the
+# system calls from syscalls.master.
+capenabled=`sed -n -e 's/.*\<\(cloudabi[0-9]*_sys_[a-z0-9_]*\)\>.*/\1/p' $1 | tr '\n' ','`