Adding upstream version 0.0~git20221206.8b7148f.upstream/0.0_git20221206.8b7148f

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

208 files changed, 9054 insertions, 0 deletions

diff --git a/libc-bottom-half/README.md b/libc-bottom-half/README.md
new file mode 100644
index 0000000..1e5401c
--- /dev/null
+++ b/libc-bottom-half/README.md
@@ -0,0 +1,19 @@
+# WASI libc "bottom half".
+
+The WASI libc "bottom half" is conceptually the lower half of a traditional libc
+implementation, consisting of C interfaces to the low-level WASI syscalls.
+
+This implementation is partially derived from the "bottom half" of [cloudlibc],
+revision 8835639f27fc42d32096d59d294a0bbb857dc368.
+
+[cloudlibc]: https://github.com/NuxiNL/cloudlibc
+
+This implementation includes preopen functionality, which emulates POSIX APIs
+accepting absolute paths by translating them into pre-opened directory handles
+and relative paths that can be opened with `openat`. This technique is inspired
+by [libpreopen], however the implementation here is designed to be built into
+libc rather than to be a layer on top of libc.
+
+[libpreopen]: https://github.com/musec/libpreopen
+
+The WASI libc lower half currently depends on the dlmalloc component.
diff --git a/libc-bottom-half/clocks/clock.c b/libc-bottom-half/clocks/clock.c
new file mode 100644
index 0000000..6767d73
--- /dev/null
+++ b/libc-bottom-half/clocks/clock.c
@@ -0,0 +1,35 @@
+#define _WASI_EMULATED_PROCESS_CLOCKS
+#include <time.h>
+#include <wasi/api.h>
+#include <common/time.h>
+
+_Static_assert(
+    CLOCKS_PER_SEC == NSEC_PER_SEC,
+    "This implementation assumes that `clock` is in nanoseconds"
+);
+
+// Snapshot of the monotonic clock at the start of the program.
+static __wasi_timestamp_t start;
+
+// Use a priority of 10 to run fairly early in the implementation-reserved
+// constructor priority range.
+__attribute__((constructor(10)))
+static void init(void) {
+    (void)__wasi_clock_time_get(__WASI_CLOCKID_MONOTONIC, 0, &start);
+}
+
+// Define the libc symbol as `__clock` so that we can reliably call it
+// from elsewhere in libc.
+clock_t __clock(void) {
+    // Use `MONOTONIC` instead of `PROCESS_CPUTIME_ID` since WASI doesn't have
+    // an inherent concept of a process. Note that this means we'll incorrectly
+    // include time from other processes, so this function is only declared by
+    // the headers if `_WASI_EMULATED_PROCESS_CLOCKS` is defined.
+    __wasi_timestamp_t now = 0;
+    (void)__wasi_clock_time_get(__WASI_CLOCKID_MONOTONIC, 0, &now);
+    return now - start;
+}
+
+// Define a user-visible alias as a weak symbol.
+__attribute__((__weak__, __alias__("__clock")))
+clock_t clock(void);
diff --git a/libc-bottom-half/clocks/getrusage.c b/libc-bottom-half/clocks/getrusage.c
new file mode 100644
index 0000000..d0113c5
--- /dev/null
+++ b/libc-bottom-half/clocks/getrusage.c
@@ -0,0 +1,28 @@
+#define _WASI_EMULATED_PROCESS_CLOCKS
+#include <sys/resource.h>
+#include <errno.h>
+#include <time.h>
+#include <wasi/api.h>
+#include <common/time.h>
+
+// `clock` is a weak symbol so that application code can override it.
+// We want to use the function in libc, so use the libc-internal name.
+clock_t __clock(void);
+
+int getrusage(int who, struct rusage *r_usage) {
+    switch (who) {
+    case RUSAGE_SELF: {
+        __wasi_timestamp_t usertime = __clock();
+        *r_usage = (struct rusage) {
+            .ru_utime = timestamp_to_timeval(usertime)
+	};
+        return 0;
+    }
+    case RUSAGE_CHILDREN:
+        *r_usage = (struct rusage) {};
+        return 0;
+    default:
+        errno = EINVAL;
+        return -1;
+    }
+}
diff --git a/libc-bottom-half/clocks/times.c b/libc-bottom-half/clocks/times.c
new file mode 100644
index 0000000..e245569
--- /dev/null
+++ b/libc-bottom-half/clocks/times.c
@@ -0,0 +1,26 @@
+#define _WASI_EMULATED_PROCESS_CLOCKS
+#include <time.h>
+#include <sys/times.h>
+#include <wasi/api.h>
+#include <common/time.h>
+
+_Static_assert(
+    CLOCKS_PER_SEC == NSEC_PER_SEC,
+    "This implementation assumes that `clock` is in nanoseconds"
+);
+
+// `clock` is a weak symbol so that application code can override it.
+// We want to use the function in libc, so use the libc-internal name.
+clock_t __clock(void);
+
+clock_t times(struct tms *buffer) {
+    __wasi_timestamp_t user = __clock();
+    *buffer = (struct tms){
+        .tms_utime = user,
+        .tms_cutime = user
+    };
+
+    __wasi_timestamp_t realtime = 0;
+    (void)__wasi_clock_time_get(__WASI_CLOCKID_MONOTONIC, 0, &realtime);
+    return realtime;
+}
diff --git a/libc-bottom-half/cloudlibc/LICENSE b/libc-bottom-half/cloudlibc/LICENSE
new file mode 100644
index 0000000..dd33b05
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/LICENSE
@@ -0,0 +1,22 @@
+Copyright (c) 2015-2017 Nuxi (https://nuxi.nl/) and contributors.
+
+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.
diff --git a/libc-bottom-half/cloudlibc/src/common/clock.h b/libc-bottom-half/cloudlibc/src/common/clock.h
new file mode 100644
index 0000000..58d40a1
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/common/clock.h
@@ -0,0 +1,19 @@
+// Copyright (c) 2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef COMMON_CLOCK_H
+#define COMMON_CLOCK_H
+
+#include <wasi/api.h>
+
+// In this implementation we define clockid_t as a pointer type, so that
+// we can implement them as full objects. Right now we only use those
+// objects to store the raw ABI-level clock identifier, but in the
+// future we can use this to provide support for pthread_getcpuclockid()
+// and clock file descriptors.
+struct __clockid {
+  __wasi_clockid_t id;
+};
+
+#endif
diff --git a/libc-bottom-half/cloudlibc/src/common/limits.h b/libc-bottom-half/cloudlibc/src/common/limits.h
new file mode 100644
index 0000000..67e2f07
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/common/limits.h
@@ -0,0 +1,35 @@
+// Copyright (c) 2015 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef COMMON_LIMITS_H
+#define COMMON_LIMITS_H
+
+#include <limits.h>
+
+#define NUMERIC_MIN(t)                                  \
+  _Generic((t)0, char                                   \
+           : CHAR_MIN, signed char                      \
+           : SCHAR_MIN, unsigned char : 0, short        \
+           : SHRT_MIN, unsigned short : 0, int          \
+           : INT_MIN, unsigned int : 0, long            \
+           : LONG_MIN, unsigned long : 0, long long     \
+           : LLONG_MIN, unsigned long long : 0, default \
+           : (void)0)
+
+#define NUMERIC_MAX(t)                     \
+  _Generic((t)0, char                      \
+           : CHAR_MAX, signed char         \
+           : SCHAR_MAX, unsigned char      \
+           : UCHAR_MAX, short              \
+           : SHRT_MAX, unsigned short      \
+           : USHRT_MAX, int                \
+           : INT_MAX, unsigned int         \
+           : UINT_MAX, long                \
+           : LONG_MAX, unsigned long       \
+           : ULONG_MAX, long long          \
+           : LLONG_MAX, unsigned long long \
+           : ULLONG_MAX, default           \
+           : (void)0)
+
+#endif
diff --git a/libc-bottom-half/cloudlibc/src/common/time.h b/libc-bottom-half/cloudlibc/src/common/time.h
new file mode 100644
index 0000000..08e2852
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/common/time.h
@@ -0,0 +1,63 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef COMMON_TIME_H
+#define COMMON_TIME_H
+
+#include <common/limits.h>
+
+#include <sys/time.h>
+
+#include <wasi/api.h>
+#include <stdbool.h>
+#include <time.h>
+
+#define NSEC_PER_SEC 1000000000
+
+static inline bool timespec_to_timestamp_exact(
+    const struct timespec *timespec, __wasi_timestamp_t *timestamp) {
+  // Invalid nanoseconds field.
+  if (timespec->tv_nsec < 0 || timespec->tv_nsec >= NSEC_PER_SEC)
+    return false;
+
+  // Timestamps before the Epoch are not supported.
+  if (timespec->tv_sec < 0)
+    return false;
+
+  // Make sure our timestamp does not overflow.
+  return !__builtin_mul_overflow(timespec->tv_sec, NSEC_PER_SEC, timestamp) &&
+         !__builtin_add_overflow(*timestamp, timespec->tv_nsec, timestamp);
+}
+
+static inline bool timespec_to_timestamp_clamp(
+    const struct timespec *timespec, __wasi_timestamp_t *timestamp) {
+  // Invalid nanoseconds field.
+  if (timespec->tv_nsec < 0 || timespec->tv_nsec >= NSEC_PER_SEC)
+    return false;
+
+  if (timespec->tv_sec < 0) {
+    // Timestamps before the Epoch are not supported.
+    *timestamp = 0;
+  } else if (__builtin_mul_overflow(timespec->tv_sec, NSEC_PER_SEC, timestamp) ||
+             __builtin_add_overflow(*timestamp, timespec->tv_nsec, timestamp)) {
+    // Make sure our timestamp does not overflow.
+    *timestamp = NUMERIC_MAX(__wasi_timestamp_t);
+  }
+  return true;
+}
+
+static inline struct timespec timestamp_to_timespec(
+    __wasi_timestamp_t timestamp) {
+  // Decompose timestamp into seconds and nanoseconds.
+  return (struct timespec){.tv_sec = timestamp / NSEC_PER_SEC,
+                           .tv_nsec = timestamp % NSEC_PER_SEC};
+}
+
+static inline struct timeval timestamp_to_timeval(
+    __wasi_timestamp_t timestamp) {
+  struct timespec ts = timestamp_to_timespec(timestamp);
+  return (struct timeval){.tv_sec = ts.tv_sec, ts.tv_nsec / 1000};
+}
+
+#endif
diff --git a/libc-bottom-half/cloudlibc/src/include/_/cdefs.h b/libc-bottom-half/cloudlibc/src/include/_/cdefs.h
new file mode 100644
index 0000000..d9a6f54
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/include/_/cdefs.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2015-2017 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.
+
+#ifndef ___CDEFS_H_
+#define ___CDEFS_H_
+
+// Compiler-independent annotations.
+
+#define __strong_reference(oldsym, newsym) \
+  extern __typeof__(oldsym) newsym __attribute__((__alias__(#oldsym)))
+
+// Convenience macros.
+
+#define __arraycount(x) (sizeof(x) / sizeof((x)[0]))
+
+#endif
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/closedir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/closedir.c
new file mode 100644
index 0000000..3585737
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/closedir.c
@@ -0,0 +1,10 @@
+// Copyright (c) 2015 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <dirent.h>
+#include <unistd.h>
+
+int closedir(DIR *dirp) {
+  return close(fdclosedir(dirp));
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/dirent_impl.h b/libc-bottom-half/cloudlibc/src/libc/dirent/dirent_impl.h
new file mode 100644
index 0000000..642400a
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/dirent_impl.h
@@ -0,0 +1,31 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef DIRENT_DIRENT_IMPL_H
+#define DIRENT_DIRENT_IMPL_H
+
+#include <wasi/api.h>
+#include <stddef.h>
+
+struct dirent;
+
+#define DIRENT_DEFAULT_BUFFER_SIZE 4096
+
+struct _DIR {
+  // Directory file descriptor and cookie.
+  int fd;
+  __wasi_dircookie_t cookie;
+
+  // Read buffer.
+  char *buffer;
+  size_t buffer_processed;
+  size_t buffer_size;
+  size_t buffer_used;
+
+  // Object returned by readdir().
+  struct dirent *dirent;
+  size_t dirent_size;
+};
+
+#endif
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/dirfd.c b/libc-bottom-half/cloudlibc/src/libc/dirent/dirfd.c
new file mode 100644
index 0000000..033157a
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/dirfd.c
@@ -0,0 +1,11 @@
+// Copyright (c) 2015 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <dirent.h>
+
+#include "dirent_impl.h"
+
+int dirfd(DIR *dirp) {
+  return dirp->fd;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/fdclosedir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/fdclosedir.c
new file mode 100644
index 0000000..cabe702
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/fdclosedir.c
@@ -0,0 +1,16 @@
+// Copyright (c) 2015 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <dirent.h>
+#include <stdlib.h>
+
+#include "dirent_impl.h"
+
+int fdclosedir(DIR *dirp) {
+  int fd = dirp->fd;
+  free(dirp->buffer);
+  free(dirp->dirent);
+  free(dirp);
+  return fd;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/fdopendir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/fdopendir.c
new file mode 100644
index 0000000..4a2136a
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/fdopendir.c
@@ -0,0 +1,44 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <dirent.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "dirent_impl.h"
+
+DIR *fdopendir(int fd) {
+  // Allocate new directory object and read buffer.
+  DIR *dirp = malloc(sizeof(*dirp));
+  if (dirp == NULL)
+    return NULL;
+  dirp->buffer = malloc(DIRENT_DEFAULT_BUFFER_SIZE);
+  if (dirp->buffer == NULL) {
+    free(dirp);
+    return NULL;
+  }
+
+  // Ensure that this is really a directory by already loading the first
+  // chunk of data.
+  __wasi_errno_t error =
+      // TODO: Remove the cast on `dirp->buffer` once the witx is updated with char8 support.
+      __wasi_fd_readdir(fd, (uint8_t *)dirp->buffer, DIRENT_DEFAULT_BUFFER_SIZE,
+                                __WASI_DIRCOOKIE_START, &dirp->buffer_used);
+  if (error != 0) {
+    free(dirp->buffer);
+    free(dirp);
+    errno = error;
+    return NULL;
+  }
+
+  // Initialize other members.
+  dirp->fd = fd;
+  dirp->cookie = __WASI_DIRCOOKIE_START;
+  dirp->buffer_processed = 0;
+  dirp->buffer_size = DIRENT_DEFAULT_BUFFER_SIZE;
+  dirp->dirent = NULL;
+  dirp->dirent_size = 1;
+  return dirp;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/opendirat.c b/libc-bottom-half/cloudlibc/src/libc/dirent/opendirat.c
new file mode 100644
index 0000000..e6d1c2a
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/opendirat.c
@@ -0,0 +1,23 @@
+// Copyright (c) 2015 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/libc.h>
+#include <wasi/libc-nocwd.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <stddef.h>
+#include <unistd.h>
+
+DIR *__wasilibc_nocwd_opendirat(int dir, const char *dirname) {
+  // Open directory.
+  int fd = __wasilibc_nocwd_openat_nomode(dir, dirname, O_RDONLY | O_NONBLOCK | O_DIRECTORY);
+  if (fd == -1)
+    return NULL;
+
+  // Create directory handle.
+  DIR *result = fdopendir(fd);
+  if (result == NULL)
+    close(fd);
+  return result;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/readdir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/readdir.c
new file mode 100644
index 0000000..bfd1921
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/readdir.c
@@ -0,0 +1,132 @@
+// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <dirent.h>
+#include <errno.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "dirent_impl.h"
+
+static_assert(DT_BLK == __WASI_FILETYPE_BLOCK_DEVICE, "Value mismatch");
+static_assert(DT_CHR == __WASI_FILETYPE_CHARACTER_DEVICE, "Value mismatch");
+static_assert(DT_DIR == __WASI_FILETYPE_DIRECTORY, "Value mismatch");
+static_assert(DT_FIFO == __WASI_FILETYPE_SOCKET_STREAM, "Value mismatch");
+static_assert(DT_LNK == __WASI_FILETYPE_SYMBOLIC_LINK, "Value mismatch");
+static_assert(DT_REG == __WASI_FILETYPE_REGULAR_FILE, "Value mismatch");
+static_assert(DT_UNKNOWN == __WASI_FILETYPE_UNKNOWN, "Value mismatch");
+
+// Grows a buffer to be large enough to hold a certain amount of data.
+#define GROW(buffer, buffer_size, target_size)      \
+  do {                                              \
+    if ((buffer_size) < (target_size)) {            \
+      size_t new_size = (buffer_size);              \
+      while (new_size < (target_size))              \
+        new_size *= 2;                              \
+      void *new_buffer = realloc(buffer, new_size); \
+      if (new_buffer == NULL)                       \
+        return NULL;                                \
+      (buffer) = new_buffer;                        \
+      (buffer_size) = new_size;                     \
+    }                                               \
+  } while (0)
+
+struct dirent *readdir(DIR *dirp) {
+  for (;;) {
+    // Extract the next dirent header.
+    size_t buffer_left = dirp->buffer_used - dirp->buffer_processed;
+    if (buffer_left < sizeof(__wasi_dirent_t)) {
+      // End-of-file.
+      if (dirp->buffer_used < dirp->buffer_size)
+        return NULL;
+      goto read_entries;
+    }
+    __wasi_dirent_t entry;
+    memcpy(&entry, dirp->buffer + dirp->buffer_processed, sizeof(entry));
+
+    size_t entry_size = sizeof(__wasi_dirent_t) + entry.d_namlen;
+    if (entry.d_namlen == 0) {
+      // Invalid pathname length. Skip the entry.
+      dirp->buffer_processed += entry_size;
+      continue;
+    }
+
+    // The entire entry must be present in buffer space. If not, read
+    // the entry another time. Ensure that the read buffer is large
+    // enough to fit at least this single entry.
+    if (buffer_left < entry_size) {
+      GROW(dirp->buffer, dirp->buffer_size, entry_size);
+      goto read_entries;
+    }
+
+    // Skip entries having null bytes in the filename.
+    const char *name = dirp->buffer + dirp->buffer_processed + sizeof(entry);
+    if (memchr(name, '\0', entry.d_namlen) != NULL) {
+      dirp->buffer_processed += entry_size;
+      continue;
+    }
+
+    // Return the next directory entry. Ensure that the dirent is large
+    // enough to fit the filename.
+    GROW(dirp->dirent, dirp->dirent_size,
+         offsetof(struct dirent, d_name) + entry.d_namlen + 1);
+    struct dirent *dirent = dirp->dirent;
+    dirent->d_type = entry.d_type;
+    memcpy(dirent->d_name, name, entry.d_namlen);
+    dirent->d_name[entry.d_namlen] = '\0';
+
+    // `fd_readdir` implementations may set the inode field to zero if the
+    // the inode number is unknown. In that case, do an `fstatat` to get the
+    // inode number.
+    off_t d_ino = entry.d_ino;
+    unsigned char d_type = entry.d_type;
+    if (d_ino == 0 && strcmp(dirent->d_name, "..") != 0) {
+      struct stat statbuf;
+      if (fstatat(dirp->fd, dirent->d_name, &statbuf, AT_SYMLINK_NOFOLLOW) != 0) {
+	if (errno == ENOENT) {
+	  // The file disappeared before we could read it, so skip it.
+	  dirp->buffer_processed += entry_size;
+	  continue;
+	}
+        return NULL;
+      }
+
+      // Fill in the inode.
+      d_ino = statbuf.st_ino;
+
+      // In case someone raced with us and replaced the object with this name
+      // with another of a different type, update the type too.
+      d_type = __wasilibc_iftodt(statbuf.st_mode & S_IFMT);
+    }
+    dirent->d_ino = d_ino;
+    dirent->d_type = d_type;
+
+    dirp->cookie = entry.d_next;
+    dirp->buffer_processed += entry_size;
+    return dirent;
+
+  read_entries:
+    // Discard data currently stored in the input buffer.
+    dirp->buffer_used = dirp->buffer_processed = dirp->buffer_size;
+
+    // Load more directory entries and continue.
+    __wasi_errno_t error =
+        // TODO: Remove the cast on `dirp->buffer` once the witx is updated with char8 support.
+        __wasi_fd_readdir(dirp->fd, (uint8_t *)dirp->buffer, dirp->buffer_size,
+                                  dirp->cookie, &dirp->buffer_used);
+    if (error != 0) {
+      errno = error;
+      return NULL;
+    }
+    dirp->buffer_processed = 0;
+  }
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/rewinddir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/rewinddir.c
new file mode 100644
index 0000000..8dd5882
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/rewinddir.c
@@ -0,0 +1,15 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <dirent.h>
+
+#include "dirent_impl.h"
+
+void rewinddir(DIR *dirp) {
+  // Update cookie.
+  dirp->cookie = __WASI_DIRCOOKIE_START;
+  // Mark entire buffer as processed to force a read of new data.
+  dirp->buffer_used = dirp->buffer_processed = dirp->buffer_size;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/scandirat.c b/libc-bottom-half/cloudlibc/src/libc/dirent/scandirat.c
new file mode 100644
index 0000000..079b3b3
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/scandirat.c
@@ -0,0 +1,168 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <wasi/libc.h>
+#include <wasi/libc-nocwd.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include "dirent_impl.h"
+
+static int sel_true(const struct dirent *de) {
+  return 1;
+}
+
+int __wasilibc_nocwd_scandirat(int dirfd, const char *dir, struct dirent ***namelist,
+                               int (*sel)(const struct dirent *),
+                               int (*compar)(const struct dirent **, const struct dirent **)) {
+  struct stat statbuf;
+
+  // Match all files if no select function is provided.
+  if (sel == NULL)
+    sel = sel_true;
+
+  // Open the directory.
+  int fd = __wasilibc_nocwd_openat_nomode(dirfd, dir, O_RDONLY | O_NONBLOCK | O_DIRECTORY);
+  if (fd == -1)
+    return -1;
+
+  // Allocate a read buffer for the directory entries.
+  size_t buffer_size = DIRENT_DEFAULT_BUFFER_SIZE;
+  char *buffer = malloc(buffer_size);
+  if (buffer == NULL) {
+    close(fd);
+    return -1;
+  }
+  size_t buffer_processed = buffer_size;
+  size_t buffer_used = buffer_size;
+
+  // Space for the array to return to the caller.
+  struct dirent **dirents = NULL;
+  size_t dirents_size = 0;
+  size_t dirents_used = 0;
+
+  __wasi_dircookie_t cookie = __WASI_DIRCOOKIE_START;
+  for (;;) {
+    // Extract the next dirent header.
+    size_t buffer_left = buffer_used - buffer_processed;
+    if (buffer_left < sizeof(__wasi_dirent_t)) {
+      // End-of-file.
+      if (buffer_used < buffer_size)
+        break;
+      goto read_entries;
+    }
+    __wasi_dirent_t entry;
+    memcpy(&entry, buffer + buffer_processed, sizeof(entry));
+
+    size_t entry_size = sizeof(__wasi_dirent_t) + entry.d_namlen;
+    if (entry.d_namlen == 0) {
+      // Invalid pathname length. Skip the entry.
+      buffer_processed += entry_size;
+      continue;
+    }
+
+    // The entire entry must be present in buffer space. If not, read
+    // the entry another time. Ensure that the read buffer is large
+    // enough to fit at least this single entry.
+    if (buffer_left < entry_size) {
+      while (buffer_size < entry_size)
+        buffer_size *= 2;
+      char *new_buffer = realloc(buffer, buffer_size);
+      if (new_buffer == NULL)
+        goto bad;
+      buffer = new_buffer;
+      goto read_entries;
+    }
+
+    // Skip entries having null bytes in the filename.
+    const char *name = buffer + buffer_processed + sizeof(entry);
+    buffer_processed += entry_size;
+    if (memchr(name, '\0', entry.d_namlen) != NULL)
+      continue;
+
+    // Create the new directory entry.
+    struct dirent *dirent =
+        malloc(offsetof(struct dirent, d_name) + entry.d_namlen + 1);
+    if (dirent == NULL)
+      goto bad;
+    dirent->d_type = entry.d_type;
+    memcpy(dirent->d_name, name, entry.d_namlen);
+    dirent->d_name[entry.d_namlen] = '\0';
+
+    // `fd_readdir` implementations may set the inode field to zero if the
+    // the inode number is unknown. In that case, do an `fstatat` to get the
+    // inode number.
+    off_t d_ino = entry.d_ino;
+    unsigned char d_type = entry.d_type;
+    if (d_ino == 0) {
+      if (fstatat(fd, dirent->d_name, &statbuf, AT_SYMLINK_NOFOLLOW) != 0) {
+        return -1;
+      }
+
+      // Fill in the inode.
+      d_ino = statbuf.st_ino;
+
+      // In case someone raced with us and replaced the object with this name
+      // with another of a different type, update the type too.
+      d_type = __wasilibc_iftodt(statbuf.st_mode & S_IFMT);
+    }
+    dirent->d_ino = d_ino;
+    dirent->d_type = d_type;
+
+    cookie = entry.d_next;
+
+    if (sel(dirent)) {
+      // Add the entry to the results.
+      if (dirents_used == dirents_size) {
+        dirents_size = dirents_size < 8 ? 8 : dirents_size * 2;
+        struct dirent **new_dirents =
+            realloc(dirents, dirents_size * sizeof(*dirents));
+        if (new_dirents == NULL) {
+          free(dirent);
+          goto bad;
+        }
+        dirents = new_dirents;
+      }
+      dirents[dirents_used++] = dirent;
+    } else {
+      // Discard the entry.
+      free(dirent);
+    }
+    continue;
+
+  read_entries:;
+    // Load more directory entries and continue.
+    // TODO: Remove the cast on `buffer` once the witx is updated with char8 support.
+    __wasi_errno_t error = __wasi_fd_readdir(fd, (uint8_t *)buffer, buffer_size,
+                                                       cookie, &buffer_used);
+    if (error != 0) {
+      errno = error;
+      goto bad;
+    }
+    buffer_processed = 0;
+  }
+
+  // Sort results and return them.
+  free(buffer);
+  close(fd);
+  (qsort)(dirents, dirents_used, sizeof(*dirents),
+          (int (*)(const void *, const void *))compar);
+  *namelist = dirents;
+  return dirents_used;
+
+bad:
+  // Deallocate partially created results.
+  for (size_t i = 0; i < dirents_used; ++i)
+    free(dirents[i]);
+  free(dirents);
+  free(buffer);
+  close(fd);
+  return -1;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/seekdir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/seekdir.c
new file mode 100644
index 0000000..a865d92
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/seekdir.c
@@ -0,0 +1,15 @@
+// Copyright (c) 2015 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <dirent.h>
+
+#include "dirent_impl.h"
+
+void seekdir(DIR *dirp, long loc) {
+  // Update cookie.
+  dirp->cookie = (unsigned long)loc;
+  // Mark entire buffer as processed to force a read of new data.
+  // TODO(ed): We could prevent a read if the offset is in the buffer.
+  dirp->buffer_used = dirp->buffer_processed = dirp->buffer_size;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/telldir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/telldir.c
new file mode 100644
index 0000000..05687ee
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/dirent/telldir.c
@@ -0,0 +1,11 @@
+// Copyright (c) 2015 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <dirent.h>
+
+#include "dirent_impl.h"
+
+long telldir(DIR *dirp) {
+  return dirp->cookie;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/errno/errno.c b/libc-bottom-half/cloudlibc/src/libc/errno/errno.c
new file mode 100644
index 0000000..d7a27f3
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/errno/errno.c
@@ -0,0 +1,87 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <errno.h>
+#include <threads.h>
+
+static_assert(E2BIG == __WASI_ERRNO_2BIG, "Value mismatch");
+static_assert(EACCES == __WASI_ERRNO_ACCES, "Value mismatch");
+static_assert(EADDRINUSE == __WASI_ERRNO_ADDRINUSE, "Value mismatch");
+static_assert(EADDRNOTAVAIL == __WASI_ERRNO_ADDRNOTAVAIL, "Value mismatch");
+static_assert(EAFNOSUPPORT == __WASI_ERRNO_AFNOSUPPORT, "Value mismatch");
+static_assert(EAGAIN == __WASI_ERRNO_AGAIN, "Value mismatch");
+static_assert(EALREADY == __WASI_ERRNO_ALREADY, "Value mismatch");
+static_assert(EBADF == __WASI_ERRNO_BADF, "Value mismatch");
+static_assert(EBADMSG == __WASI_ERRNO_BADMSG, "Value mismatch");
+static_assert(EBUSY == __WASI_ERRNO_BUSY, "Value mismatch");
+static_assert(ECANCELED == __WASI_ERRNO_CANCELED, "Value mismatch");
+static_assert(ECHILD == __WASI_ERRNO_CHILD, "Value mismatch");
+static_assert(ECONNABORTED == __WASI_ERRNO_CONNABORTED, "Value mismatch");
+static_assert(ECONNREFUSED == __WASI_ERRNO_CONNREFUSED, "Value mismatch");
+static_assert(ECONNRESET == __WASI_ERRNO_CONNRESET, "Value mismatch");
+static_assert(EDEADLK == __WASI_ERRNO_DEADLK, "Value mismatch");
+static_assert(EDESTADDRREQ == __WASI_ERRNO_DESTADDRREQ, "Value mismatch");
+static_assert(EDOM == __WASI_ERRNO_DOM, "Value mismatch");
+static_assert(EDQUOT == __WASI_ERRNO_DQUOT, "Value mismatch");
+static_assert(EEXIST == __WASI_ERRNO_EXIST, "Value mismatch");
+static_assert(EFAULT == __WASI_ERRNO_FAULT, "Value mismatch");
+static_assert(EFBIG == __WASI_ERRNO_FBIG, "Value mismatch");
+static_assert(EHOSTUNREACH == __WASI_ERRNO_HOSTUNREACH, "Value mismatch");
+static_assert(EIDRM == __WASI_ERRNO_IDRM, "Value mismatch");
+static_assert(EILSEQ == __WASI_ERRNO_ILSEQ, "Value mismatch");
+static_assert(EINPROGRESS == __WASI_ERRNO_INPROGRESS, "Value mismatch");
+static_assert(EINTR == __WASI_ERRNO_INTR, "Value mismatch");
+static_assert(EINVAL == __WASI_ERRNO_INVAL, "Value mismatch");
+static_assert(EIO == __WASI_ERRNO_IO, "Value mismatch");
+static_assert(EISCONN == __WASI_ERRNO_ISCONN, "Value mismatch");
+static_assert(EISDIR == __WASI_ERRNO_ISDIR, "Value mismatch");
+static_assert(ELOOP == __WASI_ERRNO_LOOP, "Value mismatch");
+static_assert(EMFILE == __WASI_ERRNO_MFILE, "Value mismatch");
+static_assert(EMLINK == __WASI_ERRNO_MLINK, "Value mismatch");
+static_assert(EMSGSIZE == __WASI_ERRNO_MSGSIZE, "Value mismatch");
+static_assert(EMULTIHOP == __WASI_ERRNO_MULTIHOP, "Value mismatch");
+static_assert(ENAMETOOLONG == __WASI_ERRNO_NAMETOOLONG, "Value mismatch");
+static_assert(ENETDOWN == __WASI_ERRNO_NETDOWN, "Value mismatch");
+static_assert(ENETRESET == __WASI_ERRNO_NETRESET, "Value mismatch");
+static_assert(ENETUNREACH == __WASI_ERRNO_NETUNREACH, "Value mismatch");
+static_assert(ENFILE == __WASI_ERRNO_NFILE, "Value mismatch");
+static_assert(ENOBUFS == __WASI_ERRNO_NOBUFS, "Value mismatch");
+static_assert(ENODEV == __WASI_ERRNO_NODEV, "Value mismatch");
+static_assert(ENOENT == __WASI_ERRNO_NOENT, "Value mismatch");
+static_assert(ENOEXEC == __WASI_ERRNO_NOEXEC, "Value mismatch");
+static_assert(ENOLCK == __WASI_ERRNO_NOLCK, "Value mismatch");
+static_assert(ENOLINK == __WASI_ERRNO_NOLINK, "Value mismatch");
+static_assert(ENOMEM == __WASI_ERRNO_NOMEM, "Value mismatch");
+static_assert(ENOMSG == __WASI_ERRNO_NOMSG, "Value mismatch");
+static_assert(ENOPROTOOPT == __WASI_ERRNO_NOPROTOOPT, "Value mismatch");
+static_assert(ENOSPC == __WASI_ERRNO_NOSPC, "Value mismatch");
+static_assert(ENOSYS == __WASI_ERRNO_NOSYS, "Value mismatch");
+static_assert(ENOTCAPABLE == __WASI_ERRNO_NOTCAPABLE, "Value mismatch");
+static_assert(ENOTCONN == __WASI_ERRNO_NOTCONN, "Value mismatch");
+static_assert(ENOTDIR == __WASI_ERRNO_NOTDIR, "Value mismatch");
+static_assert(ENOTEMPTY == __WASI_ERRNO_NOTEMPTY, "Value mismatch");
+static_assert(ENOTRECOVERABLE == __WASI_ERRNO_NOTRECOVERABLE, "Value mismatch");
+static_assert(ENOTSOCK == __WASI_ERRNO_NOTSOCK, "Value mismatch");
+static_assert(ENOTSUP == __WASI_ERRNO_NOTSUP, "Value mismatch");
+static_assert(ENOTTY == __WASI_ERRNO_NOTTY, "Value mismatch");
+static_assert(ENXIO == __WASI_ERRNO_NXIO, "Value mismatch");
+static_assert(EOVERFLOW == __WASI_ERRNO_OVERFLOW, "Value mismatch");
+static_assert(EOWNERDEAD == __WASI_ERRNO_OWNERDEAD, "Value mismatch");
+static_assert(EPERM == __WASI_ERRNO_PERM, "Value mismatch");
+static_assert(EPIPE == __WASI_ERRNO_PIPE, "Value mismatch");
+static_assert(EPROTO == __WASI_ERRNO_PROTO, "Value mismatch");
+static_assert(EPROTONOSUPPORT == __WASI_ERRNO_PROTONOSUPPORT, "Value mismatch");
+static_assert(EPROTOTYPE == __WASI_ERRNO_PROTOTYPE, "Value mismatch");
+static_assert(ERANGE == __WASI_ERRNO_RANGE, "Value mismatch");
+static_assert(EROFS == __WASI_ERRNO_ROFS, "Value mismatch");
+static_assert(ESPIPE == __WASI_ERRNO_SPIPE, "Value mismatch");
+static_assert(ESRCH == __WASI_ERRNO_SRCH, "Value mismatch");
+static_assert(ESTALE == __WASI_ERRNO_STALE, "Value mismatch");
+static_assert(ETIMEDOUT == __WASI_ERRNO_TIMEDOUT, "Value mismatch");
+static_assert(ETXTBSY == __WASI_ERRNO_TXTBSY, "Value mismatch");
+static_assert(EXDEV == __WASI_ERRNO_XDEV, "Value mismatch");
+
+thread_local int errno = 0;
diff --git a/libc-bottom-half/cloudlibc/src/libc/fcntl/fcntl.c b/libc-bottom-half/cloudlibc/src/libc/fcntl/fcntl.c
new file mode 100644
index 0000000..5d4055d
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/fcntl/fcntl.c
@@ -0,0 +1,62 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+
+int fcntl(int fildes, int cmd, ...) {
+  switch (cmd) {
+    case F_GETFD:
+      // Act as if the close-on-exec flag is always set.
+      return FD_CLOEXEC;
+    case F_SETFD:
+      // The close-on-exec flag is ignored.
+      return 0;
+    case F_GETFL: {
+      // Obtain the flags and the rights of the descriptor.
+      __wasi_fdstat_t fds;
+      __wasi_errno_t error = __wasi_fd_fdstat_get(fildes, &fds);
+      if (error != 0) {
+        errno = error;
+        return -1;
+      }
+
+      // Roughly approximate the access mode by converting the rights.
+      int oflags = fds.fs_flags;
+      if ((fds.fs_rights_base &
+           (__WASI_RIGHTS_FD_READ | __WASI_RIGHTS_FD_READDIR)) != 0) {
+        if ((fds.fs_rights_base & __WASI_RIGHTS_FD_WRITE) != 0)
+          oflags |= O_RDWR;
+        else
+          oflags |= O_RDONLY;
+      } else if ((fds.fs_rights_base & __WASI_RIGHTS_FD_WRITE) != 0) {
+        oflags |= O_WRONLY;
+      } else {
+        oflags |= O_SEARCH;
+      }
+      return oflags;
+    }
+    case F_SETFL: {
+      // Set new file descriptor flags.
+      va_list ap;
+      va_start(ap, cmd);
+      int flags = va_arg(ap, int);
+      va_end(ap);
+
+      __wasi_fdflags_t fs_flags = flags & 0xfff;
+      __wasi_errno_t error =
+          __wasi_fd_fdstat_set_flags(fildes, fs_flags);
+      if (error != 0) {
+        errno = error;
+        return -1;
+      }
+      return 0;
+    }
+    default:
+      errno = EINVAL;
+      return -1;
+  }
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/fcntl/openat.c b/libc-bottom-half/cloudlibc/src/libc/fcntl/openat.c
new file mode 100644
index 0000000..09cbbf8
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/fcntl/openat.c
@@ -0,0 +1,80 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <wasi/libc.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+
+static_assert(O_APPEND == __WASI_FDFLAGS_APPEND, "Value mismatch");
+static_assert(O_DSYNC == __WASI_FDFLAGS_DSYNC, "Value mismatch");
+static_assert(O_NONBLOCK == __WASI_FDFLAGS_NONBLOCK, "Value mismatch");
+static_assert(O_RSYNC == __WASI_FDFLAGS_RSYNC, "Value mismatch");
+static_assert(O_SYNC == __WASI_FDFLAGS_SYNC, "Value mismatch");
+
+static_assert(O_CREAT >> 12 == __WASI_OFLAGS_CREAT, "Value mismatch");
+static_assert(O_DIRECTORY >> 12 == __WASI_OFLAGS_DIRECTORY, "Value mismatch");
+static_assert(O_EXCL >> 12 == __WASI_OFLAGS_EXCL, "Value mismatch");
+static_assert(O_TRUNC >> 12 == __WASI_OFLAGS_TRUNC, "Value mismatch");
+
+int __wasilibc_nocwd_openat_nomode(int fd, const char *path, int oflag) {
+  // Compute rights corresponding with the access modes provided.
+  // Attempt to obtain all rights, except the ones that contradict the
+  // access mode provided to openat().
+  __wasi_rights_t max =
+      ~(__WASI_RIGHTS_FD_DATASYNC | __WASI_RIGHTS_FD_READ |
+        __WASI_RIGHTS_FD_WRITE | __WASI_RIGHTS_FD_ALLOCATE |
+        __WASI_RIGHTS_FD_READDIR | __WASI_RIGHTS_FD_FILESTAT_SET_SIZE);
+  switch (oflag & O_ACCMODE) {
+    case O_RDONLY:
+    case O_RDWR:
+    case O_WRONLY:
+      if ((oflag & O_RDONLY) != 0) {
+        max |= __WASI_RIGHTS_FD_READ | __WASI_RIGHTS_FD_READDIR;
+      }
+      if ((oflag & O_WRONLY) != 0) {
+        max |= __WASI_RIGHTS_FD_DATASYNC | __WASI_RIGHTS_FD_WRITE |
+               __WASI_RIGHTS_FD_ALLOCATE |
+               __WASI_RIGHTS_FD_FILESTAT_SET_SIZE;
+      }
+      break;
+    case O_EXEC:
+      break;
+    case O_SEARCH:
+      break;
+    default:
+      errno = EINVAL;
+      return -1;
+  }
+
+  // Ensure that we can actually obtain the minimal rights needed.
+  __wasi_fdstat_t fsb_cur;
+  __wasi_errno_t error = __wasi_fd_fdstat_get(fd, &fsb_cur);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+
+  // Path lookup properties.
+  __wasi_lookupflags_t lookup_flags = 0;
+  if ((oflag & O_NOFOLLOW) == 0)
+    lookup_flags |= __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW;
+
+  // Open file with appropriate rights.
+  __wasi_fdflags_t fs_flags = oflag & 0xfff;
+  __wasi_rights_t fs_rights_base = max & fsb_cur.fs_rights_inheriting;
+  __wasi_rights_t fs_rights_inheriting = fsb_cur.fs_rights_inheriting;
+  __wasi_fd_t newfd;
+  error = __wasi_path_open(fd, lookup_flags, path,
+                                 (oflag >> 12) & 0xfff,
+                                 fs_rights_base, fs_rights_inheriting, fs_flags,
+                                 &newfd);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return newfd;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fadvise.c b/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fadvise.c
new file mode 100644
index 0000000..d683d39
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fadvise.c
@@ -0,0 +1,24 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <errno.h>
+#include <fcntl.h>
+
+static_assert(POSIX_FADV_DONTNEED == __WASI_ADVICE_DONTNEED,
+              "Value mismatch");
+static_assert(POSIX_FADV_NOREUSE == __WASI_ADVICE_NOREUSE, "Value mismatch");
+static_assert(POSIX_FADV_NORMAL == __WASI_ADVICE_NORMAL, "Value mismatch");
+static_assert(POSIX_FADV_RANDOM == __WASI_ADVICE_RANDOM, "Value mismatch");
+static_assert(POSIX_FADV_SEQUENTIAL == __WASI_ADVICE_SEQUENTIAL,
+              "Value mismatch");
+static_assert(POSIX_FADV_WILLNEED == __WASI_ADVICE_WILLNEED,
+              "Value mismatch");
+
+int posix_fadvise(int fd, off_t offset, off_t len, int advice) {
+  if (offset < 0 || len < 0)
+    return EINVAL;
+  return __wasi_fd_advise(fd, offset, len, advice);
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fallocate.c b/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fallocate.c
new file mode 100644
index 0000000..4b41c4b
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fallocate.c
@@ -0,0 +1,13 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <fcntl.h>
+
+int posix_fallocate(int fd, off_t offset, off_t len) {
+  if (offset < 0 || len < 0)
+    return EINVAL;
+  return __wasi_fd_allocate(fd, offset, len);
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/poll/poll.c b/libc-bottom-half/cloudlibc/src/libc/poll/poll.c
new file mode 100644
index 0000000..cde4e81
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/poll/poll.c
@@ -0,0 +1,129 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <poll.h>
+#include <stdbool.h>
+
+int poll(struct pollfd *fds, size_t nfds, int timeout) {
+  // Construct events for poll().
+  size_t maxevents = 2 * nfds + 1;
+  __wasi_subscription_t subscriptions[maxevents];
+  size_t nsubscriptions = 0;
+  for (size_t i = 0; i < nfds; ++i) {
+    struct pollfd *pollfd = &fds[i];
+    if (pollfd->fd < 0)
+      continue;
+    bool created_events = false;
+    if ((pollfd->events & POLLRDNORM) != 0) {
+      __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++];
+      *subscription = (__wasi_subscription_t){
+          .userdata = (uintptr_t)pollfd,
+          .u.tag = __WASI_EVENTTYPE_FD_READ,
+          .u.u.fd_read.file_descriptor = pollfd->fd,
+      };
+      created_events = true;
+    }
+    if ((pollfd->events & POLLWRNORM) != 0) {
+      __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++];
+      *subscription = (__wasi_subscription_t){
+          .userdata = (uintptr_t)pollfd,
+          .u.tag = __WASI_EVENTTYPE_FD_WRITE,
+          .u.u.fd_write.file_descriptor = pollfd->fd,
+      };
+      created_events = true;
+    }
+
+    // As entries are decomposed into separate read/write subscriptions,
+    // we cannot detect POLLERR, POLLHUP and POLLNVAL if POLLRDNORM and
+    // POLLWRNORM are not specified. Disallow this for now.
+    if (!created_events) {
+      errno = ENOSYS;
+      return -1;
+    }
+  }
+
+  // Create extra event for the timeout.
+  if (timeout >= 0) {
+    __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++];
+    *subscription = (__wasi_subscription_t){
+        .u.tag = __WASI_EVENTTYPE_CLOCK,
+        .u.u.clock.id = __WASI_CLOCKID_REALTIME,
+        .u.u.clock.timeout = (__wasi_timestamp_t)timeout * 1000000,
+    };
+  }
+
+  // Execute poll().
+  size_t nevents;
+  __wasi_event_t events[nsubscriptions];
+  __wasi_errno_t error =
+      __wasi_poll_oneoff(subscriptions, events, nsubscriptions, &nevents);
+  if (error != 0) {
+    // WASI's poll requires at least one subscription, or else it returns
+    // `EINVAL`. Since a `poll` with nothing to wait for is valid in POSIX,
+    // return `ENOTSUP` to indicate that we don't support that case.
+    //
+    // Wasm has no signal handling, so if none of the user-provided `pollfd`
+    // elements, nor the timeout, led us to producing even one subscription
+    // to wait for, there would be no way for the poll to wake up. WASI
+    // returns `EINVAL` in this case, but for users of `poll`, `ENOTSUP` is
+    // more likely to be understood.
+    if (nsubscriptions == 0)
+      errno = ENOTSUP;
+    else
+      errno = error;
+    return -1;
+  }
+
+  // Clear revents fields.
+  for (size_t i = 0; i < nfds; ++i) {
+    struct pollfd *pollfd = &fds[i];
+    pollfd->revents = 0;
+  }
+
+  // Set revents fields.
+  for (size_t i = 0; i < nevents; ++i) {
+    const __wasi_event_t *event = &events[i];
+    if (event->type == __WASI_EVENTTYPE_FD_READ ||
+        event->type == __WASI_EVENTTYPE_FD_WRITE) {
+      struct pollfd *pollfd = (struct pollfd *)(uintptr_t)event->userdata;
+      if (event->error == __WASI_ERRNO_BADF) {
+        // Invalid file descriptor.
+        pollfd->revents |= POLLNVAL;
+      } else if (event->error == __WASI_ERRNO_PIPE) {
+        // Hangup on write side of pipe.
+        pollfd->revents |= POLLHUP;
+      } else if (event->error != 0) {
+        // Another error occurred.
+        pollfd->revents |= POLLERR;
+      } else {
+        // Data can be read or written.
+        if (event->type == __WASI_EVENTTYPE_FD_READ) {
+            pollfd->revents |= POLLRDNORM;
+            if (event->fd_readwrite.flags & __WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP) {
+              pollfd->revents |= POLLHUP;
+            }
+        } else if (event->type == __WASI_EVENTTYPE_FD_WRITE) {
+            pollfd->revents |= POLLWRNORM;
+            if (event->fd_readwrite.flags & __WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP) {
+              pollfd->revents |= POLLHUP;
+            }
+        }
+      }
+    }
+  }
+
+  // Return the number of events with a non-zero revents value.
+  int retval = 0;
+  for (size_t i = 0; i < nfds; ++i) {
+    struct pollfd *pollfd = &fds[i];
+    // POLLHUP contradicts with POLLWRNORM.
+    if ((pollfd->revents & POLLHUP) != 0)
+      pollfd->revents &= ~POLLWRNORM;
+    if (pollfd->revents != 0)
+      ++retval;
+  }
+  return retval;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sched/sched_yield.c b/libc-bottom-half/cloudlibc/src/libc/sched/sched_yield.c
new file mode 100644
index 0000000..6100ea5
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sched/sched_yield.c
@@ -0,0 +1,16 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <sched.h>
+
+int sched_yield(void) {
+  __wasi_errno_t error = __wasi_sched_yield();
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/stdio/renameat.c b/libc-bottom-half/cloudlibc/src/libc/stdio/renameat.c
new file mode 100644
index 0000000..c1706db
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/stdio/renameat.c
@@ -0,0 +1,17 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+int __wasilibc_nocwd_renameat(int oldfd, const char *old, int newfd, const char *new) {
+  __wasi_errno_t error = __wasi_path_rename(oldfd, old, newfd, new);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/stdlib/_Exit.c b/libc-bottom-half/cloudlibc/src/libc/stdlib/_Exit.c
new file mode 100644
index 0000000..5e266f0
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/stdlib/_Exit.c
@@ -0,0 +1,14 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <_/cdefs.h>
+#include <stdnoreturn.h>
+#include <unistd.h>
+
+noreturn void _Exit(int status) {
+  __wasi_proc_exit(status);
+}
+
+__strong_reference(_Exit, _exit);
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/ioctl/ioctl.c b/libc-bottom-half/cloudlibc/src/libc/sys/ioctl/ioctl.c
new file mode 100644
index 0000000..7d03cc6
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/ioctl/ioctl.c
@@ -0,0 +1,88 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/ioctl.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <stdarg.h>
+
+int ioctl(int fildes, int request, ...) {
+  switch (request) {
+    case FIONREAD: {
+      // Poll the file descriptor to determine how many bytes can be read.
+      __wasi_subscription_t subscriptions[2] = {
+          {
+              .u.tag = __WASI_EVENTTYPE_FD_READ,
+              .u.u.fd_read.file_descriptor = fildes,
+          },
+          {
+              .u.tag = __WASI_EVENTTYPE_CLOCK,
+              .u.u.clock.id = __WASI_CLOCKID_MONOTONIC,
+          },
+      };
+      __wasi_event_t events[__arraycount(subscriptions)];
+      size_t nevents;
+      __wasi_errno_t error = __wasi_poll_oneoff(
+          subscriptions, events, __arraycount(subscriptions), &nevents);
+      if (error != 0) {
+        errno = error;
+        return -1;
+      }
+
+      // Location where result should be written.
+      va_list ap;
+      va_start(ap, request);
+      int *result = va_arg(ap, int *);
+      va_end(ap);
+
+      // Extract number of bytes for reading from poll results.
+      for (size_t i = 0; i < nevents; ++i) {
+        __wasi_event_t *event = &events[i];
+        if (event->error != 0) {
+          errno = event->error;
+          return -1;
+        }
+        if (event->type == __WASI_EVENTTYPE_FD_READ) {
+          *result = event->fd_readwrite.nbytes;
+          return 0;
+        }
+      }
+
+      // No data available for reading.
+      *result = 0;
+      return 0;
+    }
+    case FIONBIO: {
+      // Obtain the current file descriptor flags.
+      __wasi_fdstat_t fds;
+      __wasi_errno_t error = __wasi_fd_fdstat_get(fildes, &fds);
+      if (error != 0) {
+        errno = error;
+        return -1;
+      }
+
+      // Toggle the non-blocking flag based on the argument.
+      va_list ap;
+      va_start(ap, request);
+      if (*va_arg(ap, const int *) != 0)
+        fds.fs_flags |= __WASI_FDFLAGS_NONBLOCK;
+      else
+        fds.fs_flags &= ~__WASI_FDFLAGS_NONBLOCK;
+      va_end(ap);
+
+      // Update the file descriptor flags.
+      error = __wasi_fd_fdstat_set_flags(fildes, fds.fs_flags);
+      if (error != 0) {
+        errno = error;
+        return -1;
+      }
+      return 0;
+    }
+    default:
+      // Invalid request.
+      errno = EINVAL;
+      return -1;
+  }
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/select/pselect.c b/libc-bottom-half/cloudlibc/src/libc/sys/select/pselect.c
new file mode 100644
index 0000000..fdc470e
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/select/pselect.c
@@ -0,0 +1,125 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <common/time.h>
+
+#include <sys/select.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+
+int pselect(int nfds, fd_set *restrict readfds, fd_set *restrict writefds,
+            fd_set *restrict errorfds, const struct timespec *restrict timeout,
+            const sigset_t *sigmask) {
+  // Negative file descriptor upperbound.
+  if (nfds < 0) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  // This implementation does not support polling for exceptional
+  // conditions, such as out-of-band data on TCP sockets.
+  if (errorfds != NULL && errorfds->__nfds > 0) {
+    errno = ENOSYS;
+    return -1;
+  }
+
+  // Replace NULL pointers by the empty set.
+  fd_set empty;
+  FD_ZERO(&empty);
+  if (readfds == NULL)
+    readfds = &empty;
+  if (writefds == NULL)
+    writefds = &empty;
+
+  // Determine the maximum number of events.
+  size_t maxevents = readfds->__nfds + writefds->__nfds + 1;
+  __wasi_subscription_t subscriptions[maxevents];
+  size_t nsubscriptions = 0;
+
+  // Convert the readfds set.
+  for (size_t i = 0; i < readfds->__nfds; ++i) {
+    int fd = readfds->__fds[i];
+    if (fd < nfds) {
+      __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++];
+      *subscription = (__wasi_subscription_t){
+          .userdata = fd,
+          .u.tag = __WASI_EVENTTYPE_FD_READ,
+          .u.u.fd_read.file_descriptor = fd,
+      };
+    }
+  }
+
+  // Convert the writefds set.
+  for (size_t i = 0; i < writefds->__nfds; ++i) {
+    int fd = writefds->__fds[i];
+    if (fd < nfds) {
+      __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++];
+      *subscription = (__wasi_subscription_t){
+          .userdata = fd,
+          .u.tag = __WASI_EVENTTYPE_FD_WRITE,
+          .u.u.fd_write.file_descriptor = fd,
+      };
+    }
+  }
+
+  // Create extra event for the timeout.
+  if (timeout != NULL) {
+    __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++];
+    *subscription = (__wasi_subscription_t){
+        .u.tag = __WASI_EVENTTYPE_CLOCK,
+        .u.u.clock.id = __WASI_CLOCKID_REALTIME,
+    };
+    if (!timespec_to_timestamp_clamp(timeout, &subscription->u.u.clock.timeout)) {
+      errno = EINVAL;
+      return -1;
+    }
+  }
+
+  // Execute poll().
+  size_t nevents;
+  __wasi_event_t events[nsubscriptions];
+  __wasi_errno_t error =
+      __wasi_poll_oneoff(subscriptions, events, nsubscriptions, &nevents);
+  if (error != 0) {
+    // WASI's poll requires at least one subscription, or else it returns
+    // `EINVAL`. Since a `pselect` with nothing to wait for is valid in POSIX,
+    // return `ENOTSUP` to indicate that we don't support that case.
+    //
+    // Wasm has no signal handling, so if none of the user-provided `pollfd`
+    // elements, nor the timeout, led us to producing even one subscription
+    // to wait for, there would be no way for the poll to wake up. WASI
+    // returns `EINVAL` in this case, but for users of `poll`, `ENOTSUP` is
+    // more likely to be understood.
+    if (nsubscriptions == 0)
+      errno = ENOTSUP;
+    else
+      errno = error;
+    return -1;
+  }
+
+  // Test for EBADF.
+  for (size_t i = 0; i < nevents; ++i) {
+    const __wasi_event_t *event = &events[i];
+    if ((event->type == __WASI_EVENTTYPE_FD_READ ||
+         event->type == __WASI_EVENTTYPE_FD_WRITE) &&
+        event->error == __WASI_ERRNO_BADF) {
+      errno = EBADF;
+      return -1;
+    }
+  }
+
+  // Clear and set entries in the result sets.
+  FD_ZERO(readfds);
+  FD_ZERO(writefds);
+  for (size_t i = 0; i < nevents; ++i) {
+    const __wasi_event_t *event = &events[i];
+    if (event->type == __WASI_EVENTTYPE_FD_READ) {
+      readfds->__fds[readfds->__nfds++] = event->userdata;
+    } else if (event->type == __WASI_EVENTTYPE_FD_WRITE) {
+      writefds->__fds[writefds->__nfds++] = event->userdata;
+    }
+  }
+  return readfds->__nfds + writefds->__nfds;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/select/select.c b/libc-bottom-half/cloudlibc/src/libc/sys/select/select.c
new file mode 100644
index 0000000..ebe5e8c
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/select/select.c
@@ -0,0 +1,25 @@
+// Copyright (c) 2015 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/select.h>
+
+#include <errno.h>
+#include <stddef.h>
+
+int select(int nfds, fd_set *restrict readfds, fd_set *restrict writefds,
+           fd_set *restrict errorfds, struct timeval *restrict timeout) {
+  if (timeout != NULL) {
+    // Timeout specified.
+    if (timeout->tv_usec < 0 || timeout->tv_usec >= 1000000) {
+      errno = EINVAL;
+      return -1;
+    }
+    struct timespec ts = {.tv_sec = timeout->tv_sec,
+                          .tv_nsec = (long)timeout->tv_usec * 1000};
+    return pselect(nfds, readfds, writefds, errorfds, &ts, NULL);
+  } else {
+    // No timeout specified.
+    return pselect(nfds, readfds, writefds, errorfds, NULL, NULL);
+  }
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/socket/getsockopt.c b/libc-bottom-half/cloudlibc/src/libc/sys/socket/getsockopt.c
new file mode 100644
index 0000000..1fe41c4
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/socket/getsockopt.c
@@ -0,0 +1,48 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/socket.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <string.h>
+
+int getsockopt(int socket, int level, int option_name,
+               void *restrict option_value, socklen_t *restrict option_len) {
+  // Only support SOL_SOCKET options for now.
+  if (level != SOL_SOCKET) {
+    errno = ENOPROTOOPT;
+    return -1;
+  }
+
+  int value;
+  switch (option_name) {
+    case SO_TYPE: {
+      // Return the type of the socket. This information can simply be
+      // obtained by looking at the file descriptor type.
+      __wasi_fdstat_t fsb;
+      if (__wasi_fd_fdstat_get(socket, &fsb) != 0) {
+        errno = EBADF;
+        return -1;
+      }
+      if (fsb.fs_filetype != __WASI_FILETYPE_SOCKET_DGRAM &&
+          fsb.fs_filetype != __WASI_FILETYPE_SOCKET_STREAM) {
+        errno = ENOTSOCK;
+        return -1;
+      }
+      value = fsb.fs_filetype;
+      break;
+    }
+    default: {
+      errno = ENOPROTOOPT;
+      return -1;
+    }
+  }
+
+  // Copy out integer value.
+  memcpy(option_value, &value,
+         *option_len < sizeof(int) ? *option_len : sizeof(int));
+  *option_len = sizeof(int);
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/socket/recv.c b/libc-bottom-half/cloudlibc/src/libc/sys/socket/recv.c
new file mode 100644
index 0000000..d35f889
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/socket/recv.c
@@ -0,0 +1,40 @@
+// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/socket.h>
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <errno.h>
+#include <stdint.h>
+
+static_assert(MSG_PEEK == __WASI_RIFLAGS_RECV_PEEK, "Value mismatch");
+static_assert(MSG_WAITALL == __WASI_RIFLAGS_RECV_WAITALL, "Value mismatch");
+
+ssize_t recv(int socket, void *restrict buffer, size_t length, int flags) {
+  // Validate flags.
+  if ((flags & ~(MSG_PEEK | MSG_WAITALL)) != 0) {
+    errno = EOPNOTSUPP;
+    return -1;
+  }
+
+  // Prepare input parameters.
+  __wasi_iovec_t iov = {.buf = buffer, .buf_len = length};
+  __wasi_iovec_t *ri_data = &iov;
+  size_t ri_data_len = 1;
+  __wasi_riflags_t ri_flags = flags;
+
+  // Perform system call.
+  size_t ro_datalen;
+  __wasi_roflags_t ro_flags;
+  __wasi_errno_t error = __wasi_sock_recv(socket,
+                                          ri_data, ri_data_len, ri_flags,
+                                          &ro_datalen,
+                                          &ro_flags);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return ro_datalen;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/socket/send.c b/libc-bottom-half/cloudlibc/src/libc/sys/socket/send.c
new file mode 100644
index 0000000..85a298a
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/socket/send.c
@@ -0,0 +1,32 @@
+// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/socket.h>
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <errno.h>
+
+ssize_t send(int socket, const void *buffer, size_t length, int flags) {
+  // This implementation does not support any flags.
+  if (flags != 0) {
+    errno = EOPNOTSUPP;
+    return -1;
+  }
+
+  // Prepare input parameters.
+  __wasi_ciovec_t iov = {.buf = buffer, .buf_len = length};
+  __wasi_ciovec_t *si_data = &iov;
+  size_t si_data_len = 1;
+  __wasi_siflags_t si_flags = 0;
+
+  // Perform system call.
+  size_t so_datalen;
+  __wasi_errno_t error = __wasi_sock_send(socket, si_data, si_data_len, si_flags, &so_datalen);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return so_datalen;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/socket/shutdown.c b/libc-bottom-half/cloudlibc/src/libc/sys/socket/shutdown.c
new file mode 100644
index 0000000..261fcb8
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/socket/shutdown.c
@@ -0,0 +1,27 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/socket.h>
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <errno.h>
+
+static_assert(SHUT_RD == __WASI_SDFLAGS_RD, "Value mismatch");
+static_assert(SHUT_WR == __WASI_SDFLAGS_WR, "Value mismatch");
+
+int shutdown(int socket, int how) {
+  // Validate shutdown flags.
+  if (how != SHUT_RD && how != SHUT_WR && how != SHUT_RDWR) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  __wasi_errno_t error = __wasi_sock_shutdown(socket, how);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return error;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/socket/socket_impl.h b/libc-bottom-half/cloudlibc/src/libc/sys/socket/socket_impl.h
new file mode 100644
index 0000000..7b1a366
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/socket/socket_impl.h
@@ -0,0 +1,57 @@
+// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef SYS_SOCKET_SOCKET_IMPL_H
+#define SYS_SOCKET_SOCKET_IMPL_H
+
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include <netinet/in.h>
+
+#include <assert.h>
+#include <stdalign.h>
+#include <stddef.h>
+#include <stdint.h>
+
+static_assert(sizeof(struct sockaddr_storage) >= sizeof(struct sockaddr),
+              "struct sockaddr_storage too small");
+static_assert(alignof(struct sockaddr_storage) == alignof(struct sockaddr),
+              "struct sockaddr alignment incorrect");
+static_assert(sizeof(struct sockaddr_storage) >= sizeof(struct sockaddr_in),
+              "struct sockaddr_storage too small");
+static_assert(alignof(struct sockaddr_storage) == alignof(struct sockaddr_in),
+              "struct sockaddr_in alignment incorrect");
+static_assert(sizeof(struct sockaddr_storage) >= sizeof(struct sockaddr_in6),
+              "struct sockaddr_storage too small");
+static_assert(alignof(struct sockaddr_storage) == alignof(struct sockaddr_in6),
+              "struct sockaddr_in6 alignment incorrect");
+static_assert(sizeof(struct sockaddr_storage) >= sizeof(struct sockaddr_un),
+              "struct sockaddr_storage too small");
+static_assert(alignof(struct sockaddr_storage) == alignof(struct sockaddr_un),
+              "struct sockaddr_un alignment incorrect");
+
+// Returns the control message header stored at a provided memory
+// address, ensuring that it is stored within the ancillary data buffer
+// of a message header.
+static inline struct cmsghdr *CMSG_GET(const struct msghdr *mhdr, void *cmsg) {
+  // Safety belt: require that the returned object is properly aligned.
+  assert((uintptr_t)cmsg % alignof(struct cmsghdr) == 0 &&
+         "Attempted to access unaligned control message header");
+
+  // Safety belt: the computed starting address of the control message
+  // header may only lie inside the ancillary data buffer, or right
+  // after it in case we've reached the end of the buffer.
+  const unsigned char *begin = mhdr->msg_control;
+  const unsigned char *end = begin + mhdr->msg_controllen;
+  assert((unsigned char *)cmsg >= begin &&
+         (unsigned char *)cmsg < end + alignof(struct cmsghdr) &&
+         "Computed object outside of buffer boundaries");
+
+  // Only return the control message header in case all of its fields
+  // lie within the ancillary data buffer.
+  return CMSG_DATA((struct cmsghdr *)cmsg) <= end ? cmsg : NULL;
+}
+
+#endif
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstat.c b/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstat.c
new file mode 100644
index 0000000..b8ffdb5
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstat.c
@@ -0,0 +1,21 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/stat.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+
+#include "stat_impl.h"
+
+int fstat(int fildes, struct stat *buf) {
+  __wasi_filestat_t internal_stat;
+  __wasi_errno_t error = __wasi_fd_filestat_get(fildes, &internal_stat);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  to_public_stat(&internal_stat, buf);
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstatat.c b/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstatat.c
new file mode 100644
index 0000000..25b29ac
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstatat.c
@@ -0,0 +1,31 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/stat.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include "stat_impl.h"
+
+int __wasilibc_nocwd_fstatat(int fd, const char *restrict path, struct stat *restrict buf,
+                             int flag) {
+  // Create lookup properties.
+  __wasi_lookupflags_t lookup_flags = 0;
+  if ((flag & AT_SYMLINK_NOFOLLOW) == 0)
+    lookup_flags |= __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW;
+
+  // Perform system call.
+  __wasi_filestat_t internal_stat;
+  __wasi_errno_t error =
+      __wasi_path_filestat_get(fd, lookup_flags, path, &internal_stat);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  to_public_stat(&internal_stat, buf);
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/futimens.c b/libc-bottom-half/cloudlibc/src/libc/sys/stat/futimens.c
new file mode 100644
index 0000000..13357fc
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/futimens.c
@@ -0,0 +1,29 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/stat.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+
+#include "stat_impl.h"
+
+int futimens(int fd, const struct timespec *times) {
+  // Convert timestamps and extract NOW/OMIT flags.
+  __wasi_timestamp_t st_atim;
+  __wasi_timestamp_t st_mtim;
+  __wasi_fstflags_t flags;
+  if (!utimens_get_timestamps(times, &st_atim, &st_mtim, &flags)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  // Perform system call.
+  __wasi_errno_t error = __wasi_fd_filestat_set_times(fd, st_atim, st_mtim, flags);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/mkdirat.c b/libc-bottom-half/cloudlibc/src/libc/sys/stat/mkdirat.c
new file mode 100644
index 0000000..fd27d5e
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/mkdirat.c
@@ -0,0 +1,18 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/stat.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <string.h>
+
+int __wasilibc_nocwd_mkdirat_nomode(int fd, const char *path) {
+  __wasi_errno_t error = __wasi_path_create_directory(fd, path);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/stat_impl.h b/libc-bottom-half/cloudlibc/src/libc/sys/stat/stat_impl.h
new file mode 100644
index 0000000..9726b51
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/stat_impl.h
@@ -0,0 +1,116 @@
+// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef SYS_STAT_STAT_IMPL_H
+#define SYS_STAT_STAT_IMPL_H
+
+#include <common/time.h>
+
+#include <sys/stat.h>
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <stdbool.h>
+
+static_assert(S_ISBLK(S_IFBLK), "Value mismatch");
+static_assert(S_ISCHR(S_IFCHR), "Value mismatch");
+static_assert(S_ISDIR(S_IFDIR), "Value mismatch");
+static_assert(S_ISFIFO(S_IFIFO), "Value mismatch");
+static_assert(S_ISLNK(S_IFLNK), "Value mismatch");
+static_assert(S_ISREG(S_IFREG), "Value mismatch");
+static_assert(S_ISSOCK(S_IFSOCK), "Value mismatch");
+
+static inline void to_public_stat(const __wasi_filestat_t *in,
+                                  struct stat *out) {
+  // Ensure that we don't truncate any values.
+  static_assert(sizeof(in->dev) == sizeof(out->st_dev), "Size mismatch");
+  static_assert(sizeof(in->ino) == sizeof(out->st_ino), "Size mismatch");
+  /*
+   * The non-standard __st_filetype field appears to only be used for shared
+   * memory, which we don't currently support.
+   */
+  /* nlink_t is 64-bit on wasm32, following the x32 ABI. */
+  static_assert(sizeof(in->nlink) <= sizeof(out->st_nlink), "Size shortfall");
+  static_assert(sizeof(in->size) == sizeof(out->st_size), "Size mismatch");
+
+  *out = (struct stat){
+      .st_dev = in->dev,
+      .st_ino = in->ino,
+      .st_nlink = in->nlink,
+      .st_size = in->size,
+      .st_atim = timestamp_to_timespec(in->atim),
+      .st_mtim = timestamp_to_timespec(in->mtim),
+      .st_ctim = timestamp_to_timespec(in->ctim),
+  };
+
+  // Convert file type to legacy types encoded in st_mode.
+  switch (in->filetype) {
+    case __WASI_FILETYPE_BLOCK_DEVICE:
+      out->st_mode |= S_IFBLK;
+      break;
+    case __WASI_FILETYPE_CHARACTER_DEVICE:
+      out->st_mode |= S_IFCHR;
+      break;
+    case __WASI_FILETYPE_DIRECTORY:
+      out->st_mode |= S_IFDIR;
+      break;
+    case __WASI_FILETYPE_REGULAR_FILE:
+      out->st_mode |= S_IFREG;
+      break;
+    case __WASI_FILETYPE_SOCKET_DGRAM:
+    case __WASI_FILETYPE_SOCKET_STREAM:
+      out->st_mode |= S_IFSOCK;
+      break;
+    case __WASI_FILETYPE_SYMBOLIC_LINK:
+      out->st_mode |= S_IFLNK;
+      break;
+  }
+}
+
+static inline bool utimens_get_timestamps(const struct timespec *times,
+                                          __wasi_timestamp_t *st_atim,
+                                          __wasi_timestamp_t *st_mtim,
+                                          __wasi_fstflags_t *flags) {
+  if (times == NULL) {
+    // Update both timestamps.
+    *flags = __WASI_FSTFLAGS_ATIM_NOW | __WASI_FSTFLAGS_MTIM_NOW;
+    *st_atim = (__wasi_timestamp_t) { 0 };
+    *st_mtim = (__wasi_timestamp_t) { 0 };
+  } else {
+    // Set individual timestamps.
+    *flags = 0;
+    switch (times[0].tv_nsec) {
+      case UTIME_NOW:
+        *flags |= __WASI_FSTFLAGS_ATIM_NOW;
+        *st_atim = (__wasi_timestamp_t) { 0 };
+        break;
+      case UTIME_OMIT:
+        *st_atim = (__wasi_timestamp_t) { 0 };
+        break;
+      default:
+        *flags |= __WASI_FSTFLAGS_ATIM;
+        if (!timespec_to_timestamp_exact(&times[0], st_atim))
+          return false;
+        break;
+    }
+
+    switch (times[1].tv_nsec) {
+      case UTIME_NOW:
+        *flags |= __WASI_FSTFLAGS_MTIM_NOW;
+        *st_mtim = (__wasi_timestamp_t) { 0 };
+        break;
+      case UTIME_OMIT:
+        *st_mtim = (__wasi_timestamp_t) { 0 };
+        break;
+      default:
+        *flags |= __WASI_FSTFLAGS_MTIM;
+        if (!timespec_to_timestamp_exact(&times[1], st_mtim))
+          return false;
+        break;
+    }
+  }
+  return true;
+}
+
+#endif
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/utimensat.c b/libc-bottom-half/cloudlibc/src/libc/sys/stat/utimensat.c
new file mode 100644
index 0000000..19508a1
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/utimensat.c
@@ -0,0 +1,38 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/stat.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include "stat_impl.h"
+
+int __wasilibc_nocwd_utimensat(int fd, const char *path, const struct timespec times[2],
+                               int flag) {
+  // Convert timestamps and extract NOW/OMIT flags.
+  __wasi_timestamp_t st_atim;
+  __wasi_timestamp_t st_mtim;
+  __wasi_fstflags_t flags;
+  if (!utimens_get_timestamps(times, &st_atim, &st_mtim, &flags)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  // Create lookup properties.
+  __wasi_lookupflags_t lookup_flags = 0;
+  if ((flag & AT_SYMLINK_NOFOLLOW) == 0)
+    lookup_flags |= __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW;
+
+  // Perform system call.
+  __wasi_errno_t error =
+      __wasi_path_filestat_set_times(fd, lookup_flags, path, st_atim, st_mtim, flags);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/time/gettimeofday.c b/libc-bottom-half/cloudlibc/src/libc/sys/time/gettimeofday.c
new file mode 100644
index 0000000..596bdff
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/time/gettimeofday.c
@@ -0,0 +1,18 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <common/time.h>
+
+#include <sys/time.h>
+
+#include <wasi/api.h>
+
+int gettimeofday(struct timeval *restrict tp, void *tz) {
+  if (tp != NULL) {
+    __wasi_timestamp_t ts = 0;
+    (void)__wasi_clock_time_get(__WASI_CLOCKID_REALTIME, 1000, &ts);
+    *tp = timestamp_to_timeval(ts);
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/uio/preadv.c b/libc-bottom-half/cloudlibc/src/libc/sys/uio/preadv.c
new file mode 100644
index 0000000..36f882d
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/uio/preadv.c
@@ -0,0 +1,24 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/types.h>
+#include <sys/uio.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+
+ssize_t preadv(int fildes, const struct iovec *iov, int iovcnt, off_t offset) {
+  if (iovcnt < 0 || offset < 0) {
+    errno = EINVAL;
+    return -1;
+  }
+  size_t bytes_read;
+  __wasi_errno_t error = __wasi_fd_pread(
+      fildes, (const __wasi_iovec_t *)iov, iovcnt, offset, &bytes_read);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return bytes_read;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/uio/pwritev.c b/libc-bottom-half/cloudlibc/src/libc/sys/uio/pwritev.c
new file mode 100644
index 0000000..d6f8851
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/uio/pwritev.c
@@ -0,0 +1,24 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/types.h>
+#include <sys/uio.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+
+ssize_t pwritev(int fildes, const struct iovec *iov, int iovcnt, off_t offset) {
+  if (iovcnt < 0 || offset < 0) {
+    errno = EINVAL;
+    return -1;
+  }
+  size_t bytes_written;
+  __wasi_errno_t error = __wasi_fd_pwrite(
+      fildes, (const __wasi_ciovec_t *)iov, iovcnt, offset, &bytes_written);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return bytes_written;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/uio/readv.c b/libc-bottom-half/cloudlibc/src/libc/sys/uio/readv.c
new file mode 100644
index 0000000..e3eaebe
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/uio/readv.c
@@ -0,0 +1,40 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/uio.h>
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <errno.h>
+#include <stddef.h>
+
+static_assert(offsetof(struct iovec, iov_base) ==
+                  offsetof(__wasi_iovec_t, buf),
+              "Offset mismatch");
+static_assert(sizeof(((struct iovec *)0)->iov_base) ==
+                  sizeof(((__wasi_iovec_t *)0)->buf),
+              "Size mismatch");
+static_assert(offsetof(struct iovec, iov_len) ==
+                  offsetof(__wasi_iovec_t, buf_len),
+              "Offset mismatch");
+static_assert(sizeof(((struct iovec *)0)->iov_len) ==
+                  sizeof(((__wasi_iovec_t *)0)->buf_len),
+              "Size mismatch");
+static_assert(sizeof(struct iovec) == sizeof(__wasi_iovec_t),
+              "Size mismatch");
+
+ssize_t readv(int fildes, const struct iovec *iov, int iovcnt) {
+  if (iovcnt < 0) {
+    errno = EINVAL;
+    return -1;
+  }
+  size_t bytes_read;
+  __wasi_errno_t error = __wasi_fd_read(
+      fildes, (const __wasi_iovec_t *)iov, iovcnt, &bytes_read);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return bytes_read;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/uio/writev.c b/libc-bottom-half/cloudlibc/src/libc/sys/uio/writev.c
new file mode 100644
index 0000000..459b152
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/sys/uio/writev.c
@@ -0,0 +1,40 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/uio.h>
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <errno.h>
+#include <stddef.h>
+
+static_assert(offsetof(struct iovec, iov_base) ==
+                  offsetof(__wasi_ciovec_t, buf),
+              "Offset mismatch");
+static_assert(sizeof(((struct iovec *)0)->iov_base) ==
+                  sizeof(((__wasi_ciovec_t *)0)->buf),
+              "Size mismatch");
+static_assert(offsetof(struct iovec, iov_len) ==
+                  offsetof(__wasi_ciovec_t, buf_len),
+              "Offset mismatch");
+static_assert(sizeof(((struct iovec *)0)->iov_len) ==
+                  sizeof(((__wasi_ciovec_t *)0)->buf_len),
+              "Size mismatch");
+static_assert(sizeof(struct iovec) == sizeof(__wasi_ciovec_t),
+              "Size mismatch");
+
+ssize_t writev(int fildes, const struct iovec *iov, int iovcnt) {
+  if (iovcnt < 0) {
+    errno = EINVAL;
+    return -1;
+  }
+  size_t bytes_written;
+  __wasi_errno_t error = __wasi_fd_write(
+      fildes, (const __wasi_ciovec_t *)iov, iovcnt, &bytes_written);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return bytes_written;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_MONOTONIC.c b/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_MONOTONIC.c
new file mode 100644
index 0000000..a4c4a62
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_MONOTONIC.c
@@ -0,0 +1,12 @@
+// Copyright (c) 2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <common/clock.h>
+
+#include <wasi/api.h>
+#include <time.h>
+
+const struct __clockid _CLOCK_MONOTONIC = {
+    .id = __WASI_CLOCKID_MONOTONIC,
+};
diff --git a/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_REALTIME.c b/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_REALTIME.c
new file mode 100644
index 0000000..9523754
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_REALTIME.c
@@ -0,0 +1,12 @@
+// Copyright (c) 2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <common/clock.h>
+
+#include <wasi/api.h>
+#include <time.h>
+
+const struct __clockid _CLOCK_REALTIME = {
+    .id = __WASI_CLOCKID_REALTIME,
+};
diff --git a/libc-bottom-half/cloudlibc/src/libc/time/clock_getres.c b/libc-bottom-half/cloudlibc/src/libc/time/clock_getres.c
new file mode 100644
index 0000000..8030d4b
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/time/clock_getres.c
@@ -0,0 +1,21 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <common/clock.h>
+#include <common/time.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <time.h>
+
+int clock_getres(clockid_t clock_id, struct timespec *res) {
+  __wasi_timestamp_t ts;
+  __wasi_errno_t error = __wasi_clock_res_get(clock_id->id, &ts);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  *res = timestamp_to_timespec(ts);
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/time/clock_gettime.c b/libc-bottom-half/cloudlibc/src/libc/time/clock_gettime.c
new file mode 100644
index 0000000..c7e1a60
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/time/clock_gettime.c
@@ -0,0 +1,22 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <common/clock.h>
+#include <common/time.h>
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <time.h>
+
+int __clock_gettime(clockid_t clock_id, struct timespec *tp) {
+  __wasi_timestamp_t ts;
+  __wasi_errno_t error = __wasi_clock_time_get(clock_id->id, 1, &ts);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  *tp = timestamp_to_timespec(ts);
+  return 0;
+}
+weak_alias(__clock_gettime, clock_gettime);
diff --git a/libc-bottom-half/cloudlibc/src/libc/time/clock_nanosleep.c b/libc-bottom-half/cloudlibc/src/libc/time/clock_nanosleep.c
new file mode 100644
index 0000000..d375056
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/time/clock_nanosleep.c
@@ -0,0 +1,37 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <common/clock.h>
+#include <common/time.h>
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <errno.h>
+#include <time.h>
+
+static_assert(TIMER_ABSTIME == __WASI_SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME,
+              "Value mismatch");
+
+int clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *rqtp,
+                    struct timespec *rmtp) {
+  if ((flags & ~TIMER_ABSTIME) != 0)
+    return EINVAL;
+
+  // Prepare polling subscription.
+  __wasi_subscription_t sub = {
+      .u.tag = __WASI_EVENTTYPE_CLOCK,
+      .u.u.clock.id = clock_id->id,
+      .u.u.clock.flags = flags,
+  };
+  if (!timespec_to_timestamp_clamp(rqtp, &sub.u.u.clock.timeout))
+    return EINVAL;
+
+  // Block until polling event is triggered.
+  size_t nevents;
+  __wasi_event_t ev;
+  __wasi_errno_t error = __wasi_poll_oneoff(&sub, &ev, 1, &nevents);
+  return error == 0 && ev.error == 0 ? 0 : ENOTSUP;
+}
+
+weak_alias(clock_nanosleep, __clock_nanosleep);
diff --git a/libc-bottom-half/cloudlibc/src/libc/time/nanosleep.c b/libc-bottom-half/cloudlibc/src/libc/time/nanosleep.c
new file mode 100644
index 0000000..5f26c5c
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/time/nanosleep.c
@@ -0,0 +1,15 @@
+// Copyright (c) 2015 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <errno.h>
+#include <time.h>
+
+int nanosleep(const struct timespec *rqtp, struct timespec *rem) {
+  int error = clock_nanosleep(CLOCK_REALTIME, 0, rqtp, rem);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/time/time.c b/libc-bottom-half/cloudlibc/src/libc/time/time.c
new file mode 100644
index 0000000..52bc0e4
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/time/time.c
@@ -0,0 +1,16 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <common/time.h>
+
+#include <wasi/api.h>
+#include <time.h>
+
+time_t time(time_t *tloc) {
+  __wasi_timestamp_t ts = 0;
+  (void)__wasi_clock_time_get(__WASI_CLOCKID_REALTIME, NSEC_PER_SEC, &ts);
+  if (tloc != NULL)
+    *tloc = ts / NSEC_PER_SEC;
+  return ts / NSEC_PER_SEC;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/close.c b/libc-bottom-half/cloudlibc/src/libc/unistd/close.c
new file mode 100644
index 0000000..2f5814b
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/close.c
@@ -0,0 +1,16 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <unistd.h>
+
+int close(int fildes) {
+  __wasi_errno_t error = __wasi_fd_close(fildes);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/faccessat.c b/libc-bottom-half/cloudlibc/src/libc/unistd/faccessat.c
new file mode 100644
index 0000000..ffaef6e
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/faccessat.c
@@ -0,0 +1,53 @@
+// Copyright (c) 2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+int __wasilibc_nocwd_faccessat(int fd, const char *path, int amode, int flag) {
+  // Validate function parameters.
+  if ((amode & ~(F_OK | R_OK | W_OK | X_OK)) != 0 ||
+      (flag & ~AT_EACCESS) != 0) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  // Check for target file existence and obtain the file type.
+  __wasi_lookupflags_t lookup_flags = __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW;
+  __wasi_filestat_t file;
+  __wasi_errno_t error =
+      __wasi_path_filestat_get(fd, lookup_flags, path, &file);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+
+  // Test whether the requested access rights are present on the
+  // directory file descriptor.
+  if (amode != 0) {
+    __wasi_fdstat_t directory;
+    error = __wasi_fd_fdstat_get(fd, &directory);
+    if (error != 0) {
+      errno = error;
+      return -1;
+    }
+
+    __wasi_rights_t min = 0;
+    if ((amode & R_OK) != 0)
+      min |= file.filetype == __WASI_FILETYPE_DIRECTORY
+                 ? __WASI_RIGHTS_FD_READDIR
+                 : __WASI_RIGHTS_FD_READ;
+    if ((amode & W_OK) != 0)
+      min |= __WASI_RIGHTS_FD_WRITE;
+
+    if ((min & directory.fs_rights_inheriting) != min) {
+      errno = EACCES;
+      return -1;
+    }
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/fdatasync.c b/libc-bottom-half/cloudlibc/src/libc/unistd/fdatasync.c
new file mode 100644
index 0000000..b821b06
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/fdatasync.c
@@ -0,0 +1,16 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <unistd.h>
+
+int fdatasync(int fildes) {
+  __wasi_errno_t error = __wasi_fd_datasync(fildes);
+  if (error != 0) {
+    errno = error == ENOTCAPABLE ? EBADF : error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/fsync.c b/libc-bottom-half/cloudlibc/src/libc/unistd/fsync.c
new file mode 100644
index 0000000..733e294
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/fsync.c
@@ -0,0 +1,16 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <unistd.h>
+
+int fsync(int fildes) {
+  __wasi_errno_t error = __wasi_fd_sync(fildes);
+  if (error != 0) {
+    errno = error == ENOTCAPABLE ? EINVAL : error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/ftruncate.c b/libc-bottom-half/cloudlibc/src/libc/unistd/ftruncate.c
new file mode 100644
index 0000000..7792597
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/ftruncate.c
@@ -0,0 +1,22 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <unistd.h>
+
+int ftruncate(int fildes, off_t length) {
+  if (length < 0) {
+    errno = EINVAL;
+    return -1;
+  }
+  __wasi_filesize_t st_size = length;
+  __wasi_errno_t error =
+      __wasi_fd_filestat_set_size(fildes, st_size);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/linkat.c b/libc-bottom-half/cloudlibc/src/libc/unistd/linkat.c
new file mode 100644
index 0000000..d57f562
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/linkat.c
@@ -0,0 +1,24 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+int __wasilibc_nocwd_linkat(int fd1, const char *path1, int fd2, const char *path2, int flag) {
+  // Create lookup properties.
+  __wasi_lookupflags_t lookup1_flags = 0;
+  if ((flag & AT_SYMLINK_FOLLOW) != 0)
+    lookup1_flags |= __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW;
+
+  // Perform system call.
+  __wasi_errno_t error = __wasi_path_link(fd1, lookup1_flags, path1, fd2, path2);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/lseek.c b/libc-bottom-half/cloudlibc/src/libc/unistd/lseek.c
new file mode 100644
index 0000000..3e0429f
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/lseek.c
@@ -0,0 +1,25 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <errno.h>
+#include <unistd.h>
+
+static_assert(SEEK_CUR == __WASI_WHENCE_CUR, "Value mismatch");
+static_assert(SEEK_END == __WASI_WHENCE_END, "Value mismatch");
+static_assert(SEEK_SET == __WASI_WHENCE_SET, "Value mismatch");
+
+off_t __lseek(int fildes, off_t offset, int whence) {
+  __wasi_filesize_t new_offset;
+  __wasi_errno_t error =
+      __wasi_fd_seek(fildes, offset, whence, &new_offset);
+  if (error != 0) {
+    errno = error == ENOTCAPABLE ? ESPIPE : error;
+    return -1;
+  }
+  return new_offset;
+}
+
+weak_alias(__lseek, lseek);
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/pread.c b/libc-bottom-half/cloudlibc/src/libc/unistd/pread.c
new file mode 100644
index 0000000..c9944bc
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/pread.c
@@ -0,0 +1,31 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <unistd.h>
+
+ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset) {
+  if (offset < 0) {
+    errno = EINVAL;
+    return -1;
+  }
+  __wasi_iovec_t iov = {.buf = buf, .buf_len = nbyte};
+  size_t bytes_read;
+  __wasi_errno_t error =
+      __wasi_fd_pread(fildes, &iov, 1, offset, &bytes_read);
+  if (error != 0) {
+    __wasi_fdstat_t fds;
+    if (error == ENOTCAPABLE && __wasi_fd_fdstat_get(fildes, &fds) == 0) {
+      // Determine why we got ENOTCAPABLE.
+      if ((fds.fs_rights_base & __WASI_RIGHTS_FD_READ) == 0)
+        error = EBADF;
+      else
+        error = ESPIPE;
+    }
+    errno = error;
+    return -1;
+  }
+  return bytes_read;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/pwrite.c b/libc-bottom-half/cloudlibc/src/libc/unistd/pwrite.c
new file mode 100644
index 0000000..f80bc40
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/pwrite.c
@@ -0,0 +1,31 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <unistd.h>
+
+ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset) {
+  if (offset < 0) {
+    errno = EINVAL;
+    return -1;
+  }
+  __wasi_ciovec_t iov = {.buf = buf, .buf_len = nbyte};
+  size_t bytes_written;
+  __wasi_errno_t error =
+      __wasi_fd_pwrite(fildes, &iov, 1, offset, &bytes_written);
+  if (error != 0) {
+    __wasi_fdstat_t fds;
+    if (error == ENOTCAPABLE && __wasi_fd_fdstat_get(fildes, &fds) == 0) {
+      // Determine why we got ENOTCAPABLE.
+      if ((fds.fs_rights_base & __WASI_RIGHTS_FD_WRITE) == 0)
+        error = EBADF;
+      else
+        error = ESPIPE;
+    }
+    errno = error;
+    return -1;
+  }
+  return bytes_written;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/read.c b/libc-bottom-half/cloudlibc/src/libc/unistd/read.c
new file mode 100644
index 0000000..1582126
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/read.c
@@ -0,0 +1,18 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <unistd.h>
+
+ssize_t read(int fildes, void *buf, size_t nbyte) {
+  __wasi_iovec_t iov = {.buf = buf, .buf_len = nbyte};
+  size_t bytes_read;
+  __wasi_errno_t error = __wasi_fd_read(fildes, &iov, 1, &bytes_read);
+  if (error != 0) {
+    errno = error == ENOTCAPABLE ? EBADF : error;
+    return -1;
+  }
+  return bytes_read;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/readlinkat.c b/libc-bottom-half/cloudlibc/src/libc/unistd/readlinkat.c
new file mode 100644
index 0000000..7a3bce2
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/readlinkat.c
@@ -0,0 +1,21 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+ssize_t __wasilibc_nocwd_readlinkat(int fd, const char *restrict path, char *restrict buf,
+                                    size_t bufsize) {
+  size_t bufused;
+  // TODO: Remove the cast on `buf` once the witx is updated with char8 support.
+  __wasi_errno_t error = __wasi_path_readlink(fd, path,
+                                                      (uint8_t*)buf, bufsize, &bufused);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return bufused;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/sleep.c b/libc-bottom-half/cloudlibc/src/libc/unistd/sleep.c
new file mode 100644
index 0000000..970287b
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/sleep.c
@@ -0,0 +1,13 @@
+// Copyright (c) 2015 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <time.h>
+#include <unistd.h>
+
+unsigned int sleep(unsigned int seconds) {
+  struct timespec ts = {.tv_sec = seconds, .tv_nsec = 0};
+  if (clock_nanosleep(CLOCK_REALTIME, 0, &ts, NULL) != 0)
+    return seconds;
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/symlinkat.c b/libc-bottom-half/cloudlibc/src/libc/unistd/symlinkat.c
new file mode 100644
index 0000000..0aa38be
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/symlinkat.c
@@ -0,0 +1,17 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+int __wasilibc_nocwd_symlinkat(const char *path1, int fd, const char *path2) {
+  __wasi_errno_t error = __wasi_path_symlink(path1, fd, path2);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/unlinkat.c b/libc-bottom-half/cloudlibc/src/libc/unistd/unlinkat.c
new file mode 100644
index 0000000..351bf92
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/unlinkat.c
@@ -0,0 +1,17 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <wasi/libc.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+int unlinkat(int fd, const char *path, int flag) {
+  if ((flag & AT_REMOVEDIR) != 0) {
+    return __wasilibc_rmdirat(fd, path);
+  }
+  return __wasilibc_unlinkat(fd, path);
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/usleep.c b/libc-bottom-half/cloudlibc/src/libc/unistd/usleep.c
new file mode 100644
index 0000000..8005f17
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/usleep.c
@@ -0,0 +1,18 @@
+// Copyright (c) 2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <errno.h>
+#include <time.h>
+#include <unistd.h>
+
+int usleep(useconds_t useconds) {
+  struct timespec ts = {.tv_sec = useconds / 1000000,
+                        .tv_nsec = useconds % 1000000 * 1000};
+  int error = clock_nanosleep(CLOCK_REALTIME, 0, &ts, NULL);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+  return 0;
+}
diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/write.c b/libc-bottom-half/cloudlibc/src/libc/unistd/write.c
new file mode 100644
index 0000000..a6567e8
--- /dev/null
+++ b/libc-bottom-half/cloudlibc/src/libc/unistd/write.c
@@ -0,0 +1,19 @@
+// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+//
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <wasi/api.h>
+#include <errno.h>
+#include <unistd.h>
+
+ssize_t write(int fildes, const void *buf, size_t nbyte) {
+  __wasi_ciovec_t iov = {.buf = buf, .buf_len = nbyte};
+  size_t bytes_written;
+  __wasi_errno_t error =
+      __wasi_fd_write(fildes, &iov, 1, &bytes_written);
+  if (error != 0) {
+    errno = error == ENOTCAPABLE ? EBADF : error;
+    return -1;
+  }
+  return bytes_written;
+}
diff --git a/libc-bottom-half/crt/crt1-command.c b/libc-bottom-half/crt/crt1-command.c
new file mode 100644
index 0000000..fb9ee71
--- /dev/null
+++ b/libc-bottom-half/crt/crt1-command.c
@@ -0,0 +1,53 @@
+#ifdef _REENTRANT
+#include <stdatomic.h>
+extern void __wasi_init_tp(void);
+#endif
+#include <wasi/api.h>
+extern void __wasm_call_ctors(void);
+extern int __main_void(void);
+extern void __wasm_call_dtors(void);
+
+__attribute__((export_name("_start")))
+void _start(void) {
+    // Commands should only be called once per instance. This simple check
+    // ensures that the `_start` function isn't started more than once.
+    //
+    // We use `volatile` here to prevent the store to `started` from being
+    // sunk past any subsequent code, and to prevent any compiler from
+    // optimizing based on the knowledge that `_start` is the program
+    // entrypoint.
+#ifdef _REENTRANT
+    static volatile _Atomic int started = 0;
+    int expected = 0;
+    if (!atomic_compare_exchange_strong(&started, &expected, 1)) {
+	__builtin_trap();
+    }
+#else
+    static volatile int started = 0;
+    if (started != 0) {
+	__builtin_trap();
+    }
+    started = 1;
+#endif
+
+#ifdef _REENTRANT
+	__wasi_init_tp();
+#endif
+
+    // The linker synthesizes this to call constructors.
+    __wasm_call_ctors();
+
+    // Call `__main_void` which will either be the application's zero-argument
+    // `__main_void` function or a libc routine which obtains the command-line
+    // arguments and calls `__main_argv_argc`.
+    int r = __main_void();
+
+    // Call atexit functions, destructors, stdio cleanup, etc.
+    __wasm_call_dtors();
+
+    // If main exited successfully, just return, otherwise call
+    // `__wasi_proc_exit`.
+    if (r != 0) {
+        __wasi_proc_exit(r);
+    }
+}
diff --git a/libc-bottom-half/crt/crt1-reactor.c b/libc-bottom-half/crt/crt1-reactor.c
new file mode 100644
index 0000000..f507c9e
--- /dev/null
+++ b/libc-bottom-half/crt/crt1-reactor.c
@@ -0,0 +1,7 @@
+extern void __wasm_call_ctors(void);
+
+__attribute__((export_name("_initialize")))
+void _initialize(void) {
+    // The linker synthesizes this to call constructors.
+    __wasm_call_ctors();
+}
diff --git a/libc-bottom-half/crt/crt1.c b/libc-bottom-half/crt/crt1.c
new file mode 100644
index 0000000..cbbe073
--- /dev/null
+++ b/libc-bottom-half/crt/crt1.c
@@ -0,0 +1,3 @@
+// We compile a plain crt1.o for toolchain compatibility, but it's
+// identical to crt1-command.o.
+#include "crt1-command.c"
diff --git a/libc-bottom-half/getpid/getpid.c b/libc-bottom-half/getpid/getpid.c
new file mode 100644
index 0000000..d2920ac
--- /dev/null
+++ b/libc-bottom-half/getpid/getpid.c
@@ -0,0 +1,6 @@
+#include <unistd.h>
+
+pid_t getpid(void) {
+    // Return an arbitrary value, greater than 1 which is special.
+    return 42;
+}
diff --git a/libc-bottom-half/headers/private/_/limits.h b/libc-bottom-half/headers/private/_/limits.h
new file mode 100644
index 0000000..1e189a1
--- /dev/null
+++ b/libc-bottom-half/headers/private/_/limits.h
@@ -0,0 +1 @@
+#include <limits.h>
diff --git a/libc-bottom-half/headers/private/_/struct/timespec.h b/libc-bottom-half/headers/private/_/struct/timespec.h
new file mode 100644
index 0000000..fbe602a
--- /dev/null
+++ b/libc-bottom-half/headers/private/_/struct/timespec.h
@@ -0,0 +1 @@
+#include <__struct_timespec.h>
diff --git a/libc-bottom-half/headers/private/_/struct/timeval.h b/libc-bottom-half/headers/private/_/struct/timeval.h
new file mode 100644
index 0000000..9cabfd7
--- /dev/null
+++ b/libc-bottom-half/headers/private/_/struct/timeval.h
@@ -0,0 +1 @@
+#include <__struct_timeval.h>
diff --git a/libc-bottom-half/headers/private/_/types.h b/libc-bottom-half/headers/private/_/types.h
new file mode 100644
index 0000000..42b17e5
--- /dev/null
+++ b/libc-bottom-half/headers/private/_/types.h
@@ -0,0 +1,9 @@
+#include <_/cdefs.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <sys/types.h>
+
+typedef uint64_t __uint64_t;
+#define _UINT64_C UINT64_C
diff --git a/libc-bottom-half/headers/private/assert.h b/libc-bottom-half/headers/private/assert.h
new file mode 100644
index 0000000..8e19ff4
--- /dev/null
+++ b/libc-bottom-half/headers/private/assert.h
@@ -0,0 +1,7 @@
+#include <stdlib.h>
+
+#ifndef __cplusplus
+#define static_assert _Static_assert
+#endif
+
+#define assert(x) ((void)((x) || (abort(), 0)))
diff --git a/libc-bottom-half/headers/private/common/crt.h b/libc-bottom-half/headers/private/common/crt.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/libc-bottom-half/headers/private/common/crt.h
diff --git a/libc-bottom-half/headers/private/errno.h b/libc-bottom-half/headers/private/errno.h
new file mode 100644
index 0000000..3b37313
--- /dev/null
+++ b/libc-bottom-half/headers/private/errno.h
@@ -0,0 +1,2 @@
+#include_next <errno.h>
+#define EOPNOTSUPP ENOTSUP
diff --git a/libc-bottom-half/headers/private/fcntl.h b/libc-bottom-half/headers/private/fcntl.h
new file mode 100644
index 0000000..3210418
--- /dev/null
+++ b/libc-bottom-half/headers/private/fcntl.h
@@ -0,0 +1,2 @@
+#include_next <fcntl.h>
+#include <_/types.h>
diff --git a/libc-bottom-half/headers/private/sched.h b/libc-bottom-half/headers/private/sched.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/libc-bottom-half/headers/private/sched.h
diff --git a/libc-bottom-half/headers/private/stdarg.h b/libc-bottom-half/headers/private/stdarg.h
new file mode 100644
index 0000000..e019608
--- /dev/null
+++ b/libc-bottom-half/headers/private/stdarg.h
@@ -0,0 +1,2 @@
+#include_next <stdarg.h>
+#include <_/cdefs.h>
diff --git a/libc-bottom-half/headers/private/stdint.h b/libc-bottom-half/headers/private/stdint.h
new file mode 100644
index 0000000..1fed338
--- /dev/null
+++ b/libc-bottom-half/headers/private/stdint.h
@@ -0,0 +1,12 @@
+#include_next <stdint.h>
+
+#define __need_size_t
+#include <stddef.h>
+
+#include <__typedef_clock_t.h>
+#include <__typedef_time_t.h>
+#include <__typedef_blksize_t.h>
+#include <__typedef_off_t.h>
+#include <__typedef_ssize_t.h>
+#include <__typedef_suseconds_t.h>
+#include <__typedef_nlink_t.h>
diff --git a/libc-bottom-half/headers/private/stdio.h b/libc-bottom-half/headers/private/stdio.h
new file mode 100644
index 0000000..b135b6a
--- /dev/null
+++ b/libc-bottom-half/headers/private/stdio.h
@@ -0,0 +1,3 @@
+#include <_/cdefs.h>
+int snprintf(char *str, size_t size, const char *format, ...);
+int rename(const char *oldpath, const char *newpath);
diff --git a/libc-bottom-half/headers/private/stdlib.h b/libc-bottom-half/headers/private/stdlib.h
new file mode 100644
index 0000000..8c2b395
--- /dev/null
+++ b/libc-bottom-half/headers/private/stdlib.h
@@ -0,0 +1,8 @@
+#define __need_size_t
+#define __need_wchar_t
+#define __need_NULL
+#include <stddef.h>
+
+#include_next <stdlib.h>
+
+int clearenv(void);
diff --git a/libc-bottom-half/headers/private/string.h b/libc-bottom-half/headers/private/string.h
new file mode 100644
index 0000000..1c4ce19
--- /dev/null
+++ b/libc-bottom-half/headers/private/string.h
@@ -0,0 +1,2 @@
+#include_next <string.h>
+#include <_/cdefs.h>
diff --git a/libc-bottom-half/headers/private/sys/mman.h b/libc-bottom-half/headers/private/sys/mman.h
new file mode 100644
index 0000000..bdd5401
--- /dev/null
+++ b/libc-bottom-half/headers/private/sys/mman.h
@@ -0,0 +1,2 @@
+#include_next <sys/mman.h>
+#include <_/types.h>
diff --git a/libc-bottom-half/headers/private/threads.h b/libc-bottom-half/headers/private/threads.h
new file mode 100644
index 0000000..b51ef0d
--- /dev/null
+++ b/libc-bottom-half/headers/private/threads.h
@@ -0,0 +1,3 @@
+#ifndef __cplusplus
+#define thread_local _Thread_local
+#endif
diff --git a/libc-bottom-half/headers/public/__errno.h b/libc-bottom-half/headers/public/__errno.h
new file mode 100644
index 0000000..4fd983a
--- /dev/null
+++ b/libc-bottom-half/headers/public/__errno.h
@@ -0,0 +1,20 @@
+#ifndef __wasilibc___errno_h
+#define __wasilibc___errno_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+extern thread_local int errno;
+#else
+extern _Thread_local int errno;
+#endif
+
+#define errno errno
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__errno_values.h b/libc-bottom-half/headers/public/__errno_values.h
new file mode 100644
index 0000000..6d6d412
--- /dev/null
+++ b/libc-bottom-half/headers/public/__errno_values.h
@@ -0,0 +1,86 @@
+#ifndef __wasilibc___errno_values_h
+#define __wasilibc___errno_values_h
+
+#include <wasi/api.h>
+
+#define E2BIG __WASI_ERRNO_2BIG
+#define EACCES __WASI_ERRNO_ACCES
+#define EADDRINUSE __WASI_ERRNO_ADDRINUSE
+#define EADDRNOTAVAIL __WASI_ERRNO_ADDRNOTAVAIL
+#define EAFNOSUPPORT __WASI_ERRNO_AFNOSUPPORT
+#define EAGAIN __WASI_ERRNO_AGAIN
+#define EALREADY __WASI_ERRNO_ALREADY
+#define EBADF __WASI_ERRNO_BADF
+#define EBADMSG __WASI_ERRNO_BADMSG
+#define EBUSY __WASI_ERRNO_BUSY
+#define ECANCELED __WASI_ERRNO_CANCELED
+#define ECHILD __WASI_ERRNO_CHILD
+#define ECONNABORTED __WASI_ERRNO_CONNABORTED
+#define ECONNREFUSED __WASI_ERRNO_CONNREFUSED
+#define ECONNRESET __WASI_ERRNO_CONNRESET
+#define EDEADLK __WASI_ERRNO_DEADLK
+#define EDESTADDRREQ __WASI_ERRNO_DESTADDRREQ
+#define EDOM __WASI_ERRNO_DOM
+#define EDQUOT __WASI_ERRNO_DQUOT
+#define EEXIST __WASI_ERRNO_EXIST
+#define EFAULT __WASI_ERRNO_FAULT
+#define EFBIG __WASI_ERRNO_FBIG
+#define EHOSTUNREACH __WASI_ERRNO_HOSTUNREACH
+#define EIDRM __WASI_ERRNO_IDRM
+#define EILSEQ __WASI_ERRNO_ILSEQ
+#define EINPROGRESS __WASI_ERRNO_INPROGRESS
+#define EINTR __WASI_ERRNO_INTR
+#define EINVAL __WASI_ERRNO_INVAL
+#define EIO __WASI_ERRNO_IO
+#define EISCONN __WASI_ERRNO_ISCONN
+#define EISDIR __WASI_ERRNO_ISDIR
+#define ELOOP __WASI_ERRNO_LOOP
+#define EMFILE __WASI_ERRNO_MFILE
+#define EMLINK __WASI_ERRNO_MLINK
+#define EMSGSIZE __WASI_ERRNO_MSGSIZE
+#define EMULTIHOP __WASI_ERRNO_MULTIHOP
+#define ENAMETOOLONG __WASI_ERRNO_NAMETOOLONG
+#define ENETDOWN __WASI_ERRNO_NETDOWN
+#define ENETRESET __WASI_ERRNO_NETRESET
+#define ENETUNREACH __WASI_ERRNO_NETUNREACH
+#define ENFILE __WASI_ERRNO_NFILE
+#define ENOBUFS __WASI_ERRNO_NOBUFS
+#define ENODEV __WASI_ERRNO_NODEV
+#define ENOENT __WASI_ERRNO_NOENT
+#define ENOEXEC __WASI_ERRNO_NOEXEC
+#define ENOLCK __WASI_ERRNO_NOLCK
+#define ENOLINK __WASI_ERRNO_NOLINK
+#define ENOMEM __WASI_ERRNO_NOMEM
+#define ENOMSG __WASI_ERRNO_NOMSG
+#define ENOPROTOOPT __WASI_ERRNO_NOPROTOOPT
+#define ENOSPC __WASI_ERRNO_NOSPC
+#define ENOSYS __WASI_ERRNO_NOSYS
+#define ENOTCONN __WASI_ERRNO_NOTCONN
+#define ENOTDIR __WASI_ERRNO_NOTDIR
+#define ENOTEMPTY __WASI_ERRNO_NOTEMPTY
+#define ENOTRECOVERABLE __WASI_ERRNO_NOTRECOVERABLE
+#define ENOTSOCK __WASI_ERRNO_NOTSOCK
+#define ENOTSUP __WASI_ERRNO_NOTSUP
+#define ENOTTY __WASI_ERRNO_NOTTY
+#define ENXIO __WASI_ERRNO_NXIO
+#define EOVERFLOW __WASI_ERRNO_OVERFLOW
+#define EOWNERDEAD __WASI_ERRNO_OWNERDEAD
+#define EPERM __WASI_ERRNO_PERM
+#define EPIPE __WASI_ERRNO_PIPE
+#define EPROTO __WASI_ERRNO_PROTO
+#define EPROTONOSUPPORT __WASI_ERRNO_PROTONOSUPPORT
+#define EPROTOTYPE __WASI_ERRNO_PROTOTYPE
+#define ERANGE __WASI_ERRNO_RANGE
+#define EROFS __WASI_ERRNO_ROFS
+#define ESPIPE __WASI_ERRNO_SPIPE
+#define ESRCH __WASI_ERRNO_SRCH
+#define ESTALE __WASI_ERRNO_STALE
+#define ETIMEDOUT __WASI_ERRNO_TIMEDOUT
+#define ETXTBSY __WASI_ERRNO_TXTBSY
+#define EXDEV __WASI_ERRNO_XDEV
+#define ENOTCAPABLE __WASI_ERRNO_NOTCAPABLE
+
+#define EOPNOTSUPP ENOTSUP
+#define EWOULDBLOCK EAGAIN
+
+#endif
diff --git a/libc-bottom-half/headers/public/__fd_set.h b/libc-bottom-half/headers/public/__fd_set.h
new file mode 100644
index 0000000..7be0b9f
--- /dev/null
+++ b/libc-bottom-half/headers/public/__fd_set.h
@@ -0,0 +1,76 @@
+#ifndef __wasilibc___fd_set_h
+#define __wasilibc___fd_set_h
+
+#include <__typedef_fd_set.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static __inline void FD_CLR(int __fd, fd_set *__set) {
+    size_t __n = __set->__nfds;
+    for (int *__p = __set->__fds, *__e = __p + __n;
+         __p < __e; ++__p)
+    {
+        if (*__p == __fd) {
+            *__p = __e[-1];
+            __set->__nfds = __n - 1;
+            return;
+        }
+    }
+}
+
+static __inline
+#ifdef __cplusplus
+bool
+#else
+_Bool
+#endif
+FD_ISSET(int __fd, const fd_set *__set)
+{
+    size_t __n = __set->__nfds;
+    for (const int *__p = __set->__fds, *__e = __p + __n;
+         __p < __e; ++__p)
+    {
+        if (*__p == __fd) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static __inline void FD_SET(int __fd, fd_set *__set) {
+    size_t __n = __set->__nfds;
+    for (const int *__p = __set->__fds, *__e = __p + __n;
+         __p < __e; ++__p)
+    {
+        if (*__p == __fd) {
+            return;
+        }
+    }
+    __set->__nfds = __n + 1;
+    __set->__fds[__n] = __fd;
+}
+
+static __inline void FD_ZERO(fd_set *__set) {
+    __set->__nfds = 0;
+}
+
+static __inline void FD_COPY(const fd_set *__restrict __from,
+                             fd_set *__restrict __to) {
+    size_t __n = __from->__nfds;
+    __to->__nfds = __n;
+    __builtin_memcpy(__to->__fds, __from->__fds, __n * sizeof(int));
+}
+
+#define FD_CLR(fd, set)   (FD_CLR((fd), (set)))
+#define FD_ISSET(fd, set) (FD_ISSET((fd), (set)))
+#define FD_SET(fd, set)   (FD_SET((fd), (set)))
+#define FD_ZERO(set)      (FD_ZERO((set)))
+#define FD_COPY(from, to) (FD_COPY((from), (to)))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__function___isatty.h b/libc-bottom-half/headers/public/__function___isatty.h
new file mode 100644
index 0000000..7c04645
--- /dev/null
+++ b/libc-bottom-half/headers/public/__function___isatty.h
@@ -0,0 +1,14 @@
+#ifndef __wasilibc___function___isatty_h
+#define __wasilibc___function___isatty_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int __isatty(int fd);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__functions_malloc.h b/libc-bottom-half/headers/public/__functions_malloc.h
new file mode 100644
index 0000000..d516bc3
--- /dev/null
+++ b/libc-bottom-half/headers/public/__functions_malloc.h
@@ -0,0 +1,26 @@
+#ifndef __wasilibc___functions_malloc_h
+#define __wasilibc___functions_malloc_h
+
+#define __need_size_t
+#define __need_wchar_t
+#define __need_NULL
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void *malloc(size_t __size) __attribute__((__malloc__, __warn_unused_result__));
+void free(void *__ptr);
+void *calloc(size_t __nmemb, size_t __size) __attribute__((__malloc__, __warn_unused_result__));
+void *realloc(void *__ptr, size_t __size) __attribute__((__warn_unused_result__));
+
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+void *reallocarray(void *__ptr, size_t __nmemb, size_t __size) __attribute__((__warn_unused_result__));
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__functions_memcpy.h b/libc-bottom-half/headers/public/__functions_memcpy.h
new file mode 100644
index 0000000..253b065
--- /dev/null
+++ b/libc-bottom-half/headers/public/__functions_memcpy.h
@@ -0,0 +1,20 @@
+#ifndef __wasilibc___functions_memcpy_h
+#define __wasilibc___functions_memcpy_h
+
+#define __need_size_t
+#define __need_NULL
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void *memcpy(void *__restrict__ __dst, const void *__restrict__ __src, size_t __n) __attribute__((__nothrow__, __leaf__, __nonnull__(1, 2)));
+void *memmove(void *__dst, const void *__src, size_t __n) __attribute__((__nothrow__, __leaf__, __nonnull__(1, 2)));
+void *memset(void *__dst, int __c, size_t __n) __attribute__((__nothrow__, __leaf__, __nonnull__(1)));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_dirent.h b/libc-bottom-half/headers/public/__header_dirent.h
new file mode 100644
index 0000000..ccf3def
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_dirent.h
@@ -0,0 +1,45 @@
+#ifndef __wasilibc___header_dirent_h
+#define __wasilibc___header_dirent_h
+
+#include <wasi/api.h>
+
+#define DT_BLK __WASI_FILETYPE_BLOCK_DEVICE
+#define DT_CHR __WASI_FILETYPE_CHARACTER_DEVICE
+#define DT_DIR __WASI_FILETYPE_DIRECTORY
+#define DT_FIFO __WASI_FILETYPE_SOCKET_STREAM
+#define DT_LNK __WASI_FILETYPE_SYMBOLIC_LINK
+#define DT_REG __WASI_FILETYPE_REGULAR_FILE
+#define DT_UNKNOWN __WASI_FILETYPE_UNKNOWN
+
+#define IFTODT(x) (__wasilibc_iftodt(x))
+#define DTTOIF(x) (__wasilibc_dttoif(x))
+
+int __wasilibc_iftodt(int x);
+int __wasilibc_dttoif(int x);
+
+#include <__struct_dirent.h>
+#include <__typedef_DIR.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int closedir(DIR *);
+DIR *opendir(const char *);
+DIR *fdopendir(int);
+int fdclosedir(DIR *);
+struct dirent *readdir(DIR *);
+void rewinddir(DIR *);
+void seekdir(DIR *, long);
+long telldir(DIR *);
+DIR *opendirat(int, const char *);
+void rewinddir(DIR *);
+int scandirat(int, const char *, struct dirent ***,
+              int (*)(const struct dirent *),
+              int (*)(const struct dirent **, const struct dirent **));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_fcntl.h b/libc-bottom-half/headers/public/__header_fcntl.h
new file mode 100644
index 0000000..04252ac
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_fcntl.h
@@ -0,0 +1,61 @@
+#ifndef __wasilibc___header_fcntl_h
+#define __wasilibc___header_fcntl_h
+
+#include <wasi/api.h>
+#include <__seek.h>
+#include <__mode_t.h>
+
+#define O_APPEND __WASI_FDFLAGS_APPEND
+#define O_DSYNC __WASI_FDFLAGS_DSYNC
+#define O_NONBLOCK __WASI_FDFLAGS_NONBLOCK
+#define O_RSYNC __WASI_FDFLAGS_RSYNC
+#define O_SYNC __WASI_FDFLAGS_SYNC
+#define O_CREAT (__WASI_OFLAGS_CREAT << 12)
+#define O_DIRECTORY (__WASI_OFLAGS_DIRECTORY << 12)
+#define O_EXCL (__WASI_OFLAGS_EXCL << 12)
+#define O_TRUNC (__WASI_OFLAGS_TRUNC << 12)
+
+#define O_NOFOLLOW (0x01000000)
+#define O_EXEC     (0x02000000)
+#define O_RDONLY   (0x04000000)
+#define O_SEARCH   (0x08000000)
+#define O_WRONLY   (0x10000000)
+
+/*
+ * O_CLOEXEC is defined to be zero, as WASI has no exec-style functions.
+ */
+#define O_CLOEXEC  (0)
+
+/*
+ * O_TTY_INIT is defined to be zero, meaning that WASI implementations are
+ * expected to always initialize a terminal the first time it's opened.
+ */
+#define O_TTY_INIT (0)
+
+#define O_NOCTTY   (0)
+
+#define O_RDWR (O_RDONLY | O_WRONLY)
+#define O_ACCMODE (O_EXEC | O_RDWR | O_SEARCH)
+
+#define POSIX_FADV_DONTNEED __WASI_ADVICE_DONTNEED
+#define POSIX_FADV_NOREUSE __WASI_ADVICE_NOREUSE
+#define POSIX_FADV_NORMAL __WASI_ADVICE_NORMAL
+#define POSIX_FADV_RANDOM __WASI_ADVICE_RANDOM
+#define POSIX_FADV_SEQUENTIAL __WASI_ADVICE_SEQUENTIAL
+#define POSIX_FADV_WILLNEED __WASI_ADVICE_WILLNEED
+
+#define F_GETFD (1)
+#define F_SETFD (2)
+#define F_GETFL (3)
+#define F_SETFL (4)
+
+#define FD_CLOEXEC (1)
+
+#define AT_EACCESS          (0x0)
+#define AT_SYMLINK_NOFOLLOW (0x1)
+#define AT_SYMLINK_FOLLOW   (0x2)
+#define AT_REMOVEDIR        (0x4)
+
+#define AT_FDCWD (-2)
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_inttypes.h b/libc-bottom-half/headers/public/__header_inttypes.h
new file mode 100644
index 0000000..47c5c9b
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_inttypes.h
@@ -0,0 +1,182 @@
+#ifndef __wasilibc___include_inttypes_h
+#define __wasilibc___include_inttypes_h
+
+#include <stdint.h>
+
+#define __need_wchar_t
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct { intmax_t quot, rem; } imaxdiv_t;
+
+intmax_t  imaxabs(intmax_t);
+imaxdiv_t imaxdiv(intmax_t, intmax_t);
+intmax_t  strtoimax(const char *__restrict, char **__restrict, int);
+uintmax_t strtoumax(const char *__restrict, char **__restrict, int);
+intmax_t  wcstoimax(const wchar_t *__restrict, wchar_t **__restrict, int);
+uintmax_t wcstoumax(const wchar_t *__restrict, wchar_t **__restrict, int);
+
+#define PRId16 __INT16_FMTd__
+#define PRIi16 __INT16_FMTi__
+#define PRId32 __INT32_FMTd__
+#define PRIi32 __INT32_FMTi__
+#define PRId64 __INT64_FMTd__
+#define PRIi64 __INT64_FMTi__
+#define PRId8 __INT8_FMTd__
+#define PRIi8 __INT8_FMTi__
+#define PRIdMAX __INTMAX_FMTd__
+#define PRIiMAX __INTMAX_FMTi__
+#define PRIdPTR __INTPTR_FMTd__
+#define PRIiPTR __INTPTR_FMTi__
+#define PRIdFAST16 __INT_FAST16_FMTd__
+#define PRIiFAST16 __INT_FAST16_FMTi__
+#define PRIdFAST32 __INT_FAST32_FMTd__
+#define PRIiFAST32 __INT_FAST32_FMTi__
+#define PRIdFAST64 __INT_FAST64_FMTd__
+#define PRIiFAST64 __INT_FAST64_FMTi__
+#define PRIdFAST8 __INT_FAST8_FMTd__
+#define PRIiFAST8 __INT_FAST8_FMTi__
+#define PRIdLEAST16 __INT_LEAST16_FMTd__
+#define PRIiLEAST16 __INT_LEAST16_FMTi__
+#define PRIdLEAST32 __INT_LEAST32_FMTd__
+#define PRIiLEAST32 __INT_LEAST32_FMTi__
+#define PRIdLEAST64 __INT_LEAST64_FMTd__
+#define PRIiLEAST64 __INT_LEAST64_FMTi__
+#define PRIdLEAST8 __INT_LEAST8_FMTd__
+#define PRIiLEAST8 __INT_LEAST8_FMTi__
+#define PRIX16 __UINT16_FMTX__
+#define PRIo16 __UINT16_FMTo__
+#define PRIu16 __UINT16_FMTu__
+#define PRIx16 __UINT16_FMTx__
+#define PRIX32 __UINT32_FMTX__
+#define PRIo32 __UINT32_FMTo__
+#define PRIu32 __UINT32_FMTu__
+#define PRIx32 __UINT32_FMTx__
+#define PRIX64 __UINT64_FMTX__
+#define PRIo64 __UINT64_FMTo__
+#define PRIu64 __UINT64_FMTu__
+#define PRIx64 __UINT64_FMTx__
+#define PRIX8 __UINT8_FMTX__
+#define PRIo8 __UINT8_FMTo__
+#define PRIu8 __UINT8_FMTu__
+#define PRIx8 __UINT8_FMTx__
+#define PRIXMAX __UINTMAX_FMTX__
+#define PRIoMAX __UINTMAX_FMTo__
+#define PRIuMAX __UINTMAX_FMTu__
+#define PRIxMAX __UINTMAX_FMTx__
+#define PRIXPTR __UINTPTR_FMTX__
+#define PRIoPTR __UINTPTR_FMTo__
+#define PRIuPTR __UINTPTR_FMTu__
+#define PRIxPTR __UINTPTR_FMTx__
+#define PRIXFAST16 __UINT_FAST16_FMTX__
+#define PRIoFAST16 __UINT_FAST16_FMTo__
+#define PRIuFAST16 __UINT_FAST16_FMTu__
+#define PRIxFAST16 __UINT_FAST16_FMTx__
+#define PRIXFAST32 __UINT_FAST32_FMTX__
+#define PRIoFAST32 __UINT_FAST32_FMTo__
+#define PRIuFAST32 __UINT_FAST32_FMTu__
+#define PRIxFAST32 __UINT_FAST32_FMTx__
+#define PRIXFAST64 __UINT_FAST64_FMTX__
+#define PRIoFAST64 __UINT_FAST64_FMTo__
+#define PRIuFAST64 __UINT_FAST64_FMTu__
+#define PRIxFAST64 __UINT_FAST64_FMTx__
+#define PRIXFAST8 __UINT_FAST8_FMTX__
+#define PRIoFAST8 __UINT_FAST8_FMTo__
+#define PRIuFAST8 __UINT_FAST8_FMTu__
+#define PRIxFAST8 __UINT_FAST8_FMTx__
+#define PRIXLEAST16 __UINT_LEAST16_FMTX__
+#define PRIoLEAST16 __UINT_LEAST16_FMTo__
+#define PRIuLEAST16 __UINT_LEAST16_FMTu__
+#define PRIxLEAST16 __UINT_LEAST16_FMTx__
+#define PRIXLEAST32 __UINT_LEAST32_FMTX__
+#define PRIoLEAST32 __UINT_LEAST32_FMTo__
+#define PRIuLEAST32 __UINT_LEAST32_FMTu__
+#define PRIxLEAST32 __UINT_LEAST32_FMTx__
+#define PRIXLEAST64 __UINT_LEAST64_FMTX__
+#define PRIoLEAST64 __UINT_LEAST64_FMTo__
+#define PRIuLEAST64 __UINT_LEAST64_FMTu__
+#define PRIxLEAST64 __UINT_LEAST64_FMTx__
+#define PRIXLEAST8 __UINT_LEAST8_FMTX__
+#define PRIoLEAST8 __UINT_LEAST8_FMTo__
+#define PRIuLEAST8 __UINT_LEAST8_FMTu__
+#define PRIxLEAST8 __UINT_LEAST8_FMTx__
+
+#define SCNd16 __INT16_FMTd__
+#define SCNi16 __INT16_FMTi__
+#define SCNd32 __INT32_FMTd__
+#define SCNi32 __INT32_FMTi__
+#define SCNd64 __INT64_FMTd__
+#define SCNi64 __INT64_FMTi__
+#define SCNd8 __INT8_FMTd__
+#define SCNi8 __INT8_FMTi__
+#define SCNdMAX __INTMAX_FMTd__
+#define SCNiMAX __INTMAX_FMTi__
+#define SCNdPTR __INTPTR_FMTd__
+#define SCNiPTR __INTPTR_FMTi__
+#define SCNdFAST16 __INT_FAST16_FMTd__
+#define SCNiFAST16 __INT_FAST16_FMTi__
+#define SCNdFAST32 __INT_FAST32_FMTd__
+#define SCNiFAST32 __INT_FAST32_FMTi__
+#define SCNdFAST64 __INT_FAST64_FMTd__
+#define SCNiFAST64 __INT_FAST64_FMTi__
+#define SCNdFAST8 __INT_FAST8_FMTd__
+#define SCNiFAST8 __INT_FAST8_FMTi__
+#define SCNdLEAST16 __INT_LEAST16_FMTd__
+#define SCNiLEAST16 __INT_LEAST16_FMTi__
+#define SCNdLEAST32 __INT_LEAST32_FMTd__
+#define SCNiLEAST32 __INT_LEAST32_FMTi__
+#define SCNdLEAST64 __INT_LEAST64_FMTd__
+#define SCNiLEAST64 __INT_LEAST64_FMTi__
+#define SCNdLEAST8 __INT_LEAST8_FMTd__
+#define SCNiLEAST8 __INT_LEAST8_FMTi__
+#define SCNo16 __UINT16_FMTo__
+#define SCNu16 __UINT16_FMTu__
+#define SCNx16 __UINT16_FMTx__
+#define SCNo32 __UINT32_FMTo__
+#define SCNu32 __UINT32_FMTu__
+#define SCNx32 __UINT32_FMTx__
+#define SCNo64 __UINT64_FMTo__
+#define SCNu64 __UINT64_FMTu__
+#define SCNx64 __UINT64_FMTx__
+#define SCNo8 __UINT8_FMTo__
+#define SCNu8 __UINT8_FMTu__
+#define SCNx8 __UINT8_FMTx__
+#define SCNoMAX __UINTMAX_FMTo__
+#define SCNuMAX __UINTMAX_FMTu__
+#define SCNxMAX __UINTMAX_FMTx__
+#define SCNoPTR __UINTPTR_FMTo__
+#define SCNuPTR __UINTPTR_FMTu__
+#define SCNxPTR __UINTPTR_FMTx__
+#define SCNoFAST16 __UINT_FAST16_FMTo__
+#define SCNuFAST16 __UINT_FAST16_FMTu__
+#define SCNxFAST16 __UINT_FAST16_FMTx__
+#define SCNoFAST32 __UINT_FAST32_FMTo__
+#define SCNuFAST32 __UINT_FAST32_FMTu__
+#define SCNxFAST32 __UINT_FAST32_FMTx__
+#define SCNoFAST64 __UINT_FAST64_FMTo__
+#define SCNuFAST64 __UINT_FAST64_FMTu__
+#define SCNxFAST64 __UINT_FAST64_FMTx__
+#define SCNoFAST8 __UINT_FAST8_FMTo__
+#define SCNuFAST8 __UINT_FAST8_FMTu__
+#define SCNxFAST8 __UINT_FAST8_FMTx__
+#define SCNoLEAST16 __UINT_LEAST16_FMTo__
+#define SCNuLEAST16 __UINT_LEAST16_FMTu__
+#define SCNxLEAST16 __UINT_LEAST16_FMTx__
+#define SCNoLEAST32 __UINT_LEAST32_FMTo__
+#define SCNuLEAST32 __UINT_LEAST32_FMTu__
+#define SCNxLEAST32 __UINT_LEAST32_FMTx__
+#define SCNoLEAST64 __UINT_LEAST64_FMTo__
+#define SCNuLEAST64 __UINT_LEAST64_FMTu__
+#define SCNxLEAST64 __UINT_LEAST64_FMTx__
+#define SCNoLEAST8 __UINT_LEAST8_FMTo__
+#define SCNuLEAST8 __UINT_LEAST8_FMTu__
+#define SCNxLEAST8 __UINT_LEAST8_FMTx__
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_netinet_in.h b/libc-bottom-half/headers/public/__header_netinet_in.h
new file mode 100644
index 0000000..30359c8
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_netinet_in.h
@@ -0,0 +1,30 @@
+#ifndef __wasilibc___header_netinet_in_h
+#define __wasilibc___header_netinet_in_h
+
+#include <__struct_in_addr.h>
+#include <__struct_in6_addr.h>
+#include <__struct_sockaddr_in.h>
+#include <__struct_sockaddr_in6.h>
+
+#define IPPROTO_IP 0
+#define IPPROTO_ICMP 1
+#define IPPROTO_TCP 6
+#define IPPROTO_UDP 17
+#define IPPROTO_IPV6 41
+#define IPPROTO_RAW 255
+
+#define IN6ADDR_ANY_INIT { { \
+    0x00, 0x00, 0x00, 0x00, \
+    0x00, 0x00, 0x00, 0x00, \
+    0x00, 0x00, 0x00, 0x00, \
+    0x00, 0x00, 0x00, 0x00  \
+} }
+
+#define IN6ADDR_LOOPBACK_INIT { { \
+    0x00, 0x00, 0x00, 0x00, \
+    0x00, 0x00, 0x00, 0x00, \
+    0x00, 0x00, 0x00, 0x00, \
+    0x00, 0x00, 0x00, 0x01  \
+} }
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_poll.h b/libc-bottom-half/headers/public/__header_poll.h
new file mode 100644
index 0000000..23b36f2
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_poll.h
@@ -0,0 +1,27 @@
+#ifndef __wasilibc___header_poll_h
+#define __wasilibc___header_poll_h
+
+#include <__struct_pollfd.h>
+#include <__typedef_nfds_t.h>
+
+#define POLLRDNORM 0x1
+#define POLLWRNORM 0x2
+
+#define POLLIN POLLRDNORM
+#define POLLOUT POLLWRNORM
+
+#define POLLERR 0x1000
+#define POLLHUP 0x2000
+#define POLLNVAL 0x4000
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int poll(struct pollfd[], nfds_t, int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_stdlib.h b/libc-bottom-half/headers/public/__header_stdlib.h
new file mode 100644
index 0000000..a6c49a5
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_stdlib.h
@@ -0,0 +1,21 @@
+#ifndef __wasilibc___header_stdlib_h
+#define __wasilibc___header_stdlib_h
+
+#define __need_size_t
+#include <stddef.h>
+
+#include <__functions_malloc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void abort(void) __attribute__((__noreturn__));
+void qsort(void *, size_t, size_t, int (*)(const void *, const void *));
+void _Exit(int) __attribute__((__noreturn__));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_string.h b/libc-bottom-half/headers/public/__header_string.h
new file mode 100644
index 0000000..eb98a8a
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_string.h
@@ -0,0 +1,23 @@
+#ifndef __wasilibc___header_string_h
+#define __wasilibc___header_string_h
+
+#define __need_size_t
+#define __need_NULL
+#include <stddef.h>
+
+#include <__functions_memcpy.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+size_t strlen(const char *) __attribute__((__nothrow__, __leaf__, __pure__, __nonnull__(1)));
+char *strdup(const char *) __attribute__((__nothrow__, __nonnull__(1)));
+int strcmp(const char *, const char *) __attribute__((__nothrow__, __pure__, __nonnull__(1, 2)));
+void *memchr(const void *, int, size_t) __attribute__((__nothrow__, __pure__, __nonnull__(1)));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_sys_ioctl.h b/libc-bottom-half/headers/public/__header_sys_ioctl.h
new file mode 100644
index 0000000..f2cf4ee
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_sys_ioctl.h
@@ -0,0 +1,17 @@
+#ifndef __wasilibc___header_sys_ioctl_h
+#define __wasilibc___header_sys_ioctl_h
+
+#define FIONREAD 1
+#define FIONBIO 2
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int ioctl(int, int, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_sys_resource.h b/libc-bottom-half/headers/public/__header_sys_resource.h
new file mode 100644
index 0000000..bae9d5a
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_sys_resource.h
@@ -0,0 +1,19 @@
+#ifndef __wasilibc___header_sys_resource_h
+#define __wasilibc___header_sys_resource_h
+
+#include <__struct_rusage.h>
+
+#define RUSAGE_SELF 1
+#define RUSAGE_CHILDREN 2
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int getrusage(int who, struct rusage *usage);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_sys_socket.h b/libc-bottom-half/headers/public/__header_sys_socket.h
new file mode 100644
index 0000000..9fa8684
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_sys_socket.h
@@ -0,0 +1,41 @@
+#ifndef __wasilibc___header_sys_socket_h
+#define __wasilibc___header_sys_socket_h
+
+#include <__struct_msghdr.h>
+#include <__struct_sockaddr.h>
+#include <__struct_sockaddr_storage.h>
+
+#include <wasi/api.h>
+
+#define SHUT_RD __WASI_SDFLAGS_RD
+#define SHUT_WR __WASI_SDFLAGS_WR
+#define SHUT_RDWR (SHUT_RD | SHUT_WR)
+
+#define MSG_PEEK __WASI_RIFLAGS_RECV_PEEK
+#define MSG_WAITALL __WASI_RIFLAGS_RECV_WAITALL
+#define MSG_TRUNC __WASI_RIFLAGS_RECV_DATA_TRUNCATED
+
+#define SOCK_DGRAM __WASI_FILETYPE_SOCKET_DGRAM
+#define SOCK_STREAM __WASI_FILETYPE_SOCKET_STREAM
+
+#define SOCK_NONBLOCK (0x00004000)
+#define SOCK_CLOEXEC (0x00002000)
+
+#define SOL_SOCKET 0x7fffffff
+
+#define SO_TYPE 3
+
+#define AF_UNSPEC 0
+#define AF_INET 1
+#define AF_INET6 2
+#define AF_UNIX 3
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_sys_stat.h b/libc-bottom-half/headers/public/__header_sys_stat.h
new file mode 100644
index 0000000..f965cf3
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_sys_stat.h
@@ -0,0 +1,15 @@
+#ifndef __wasilibc___header_sys_stat_h
+#define __wasilibc___header_sys_stat_h
+
+#include <__struct_stat.h>
+
+#define st_atime st_atim.tv_sec
+#define st_mtime st_mtim.tv_sec
+#define st_ctime st_ctim.tv_sec
+
+#include <__mode_t.h>
+
+#define UTIME_NOW (-1)
+#define UTIME_OMIT (-2)
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_time.h b/libc-bottom-half/headers/public/__header_time.h
new file mode 100644
index 0000000..2a2ff91
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_time.h
@@ -0,0 +1,33 @@
+#ifndef __wasilibc___header_time_h
+#define __wasilibc___header_time_h
+
+#define __need_size_t
+#define __need_NULL
+#include <stddef.h>
+
+#include <__typedef_time_t.h>
+#include <__struct_timespec.h>
+#include <__struct_tm.h>
+#include <__typedef_clockid_t.h>
+
+#include <wasi/api.h>
+
+#define TIMER_ABSTIME __WASI_SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME
+
+extern const struct __clockid _CLOCK_MONOTONIC;
+#define CLOCK_MONOTONIC (&_CLOCK_MONOTONIC)
+extern const struct __clockid _CLOCK_REALTIME;
+#define CLOCK_REALTIME (&_CLOCK_REALTIME)
+
+/*
+ * TIME_UTC is the only standardized time base value.
+ */
+#define TIME_UTC 1
+
+/*
+ * Note that XSI specifies CLOCKS_PER_SEC to be 1000000, rather than
+ * 1000000000; the clock API is providing more precision than XSI specifies.
+ */
+#define CLOCKS_PER_SEC ((clock_t)1000000000)
+
+#endif
diff --git a/libc-bottom-half/headers/public/__header_unistd.h b/libc-bottom-half/headers/public/__header_unistd.h
new file mode 100644
index 0000000..6b80d63
--- /dev/null
+++ b/libc-bottom-half/headers/public/__header_unistd.h
@@ -0,0 +1,28 @@
+#ifndef __wasilibc___header_unistd_h
+#define __wasilibc___header_unistd_h
+
+struct stat;
+
+#include <__seek.h>
+
+#define F_OK (0)
+#define X_OK (1)
+#define W_OK (2)
+#define R_OK (4)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int close(int fd);
+int faccessat(int, const char *, int, int);
+int fstatat(int, const char *__restrict, struct stat *__restrict, int);
+int renameat(int, const char *, int, const char *);
+int openat(int, const char *, int, ...);
+void *sbrk(intptr_t increment);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/__macro_FD_SETSIZE.h b/libc-bottom-half/headers/public/__macro_FD_SETSIZE.h
new file mode 100644
index 0000000..bb88e45
--- /dev/null
+++ b/libc-bottom-half/headers/public/__macro_FD_SETSIZE.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___macro_FD_SETSIZE_h
+#define __wasilibc___macro_FD_SETSIZE_h
+
+#define FD_SETSIZE 1024
+
+#endif
diff --git a/libc-bottom-half/headers/public/__macro_PAGESIZE.h b/libc-bottom-half/headers/public/__macro_PAGESIZE.h
new file mode 100644
index 0000000..d892220
--- /dev/null
+++ b/libc-bottom-half/headers/public/__macro_PAGESIZE.h
@@ -0,0 +1,16 @@
+#ifndef __wasilibc___macro_PAGESIZE_h
+#define __wasilibc___macro_PAGESIZE_h
+
+/*
+ * The page size in WebAssembly is fixed at 64 KiB. If this ever changes,
+ * it's expected that applications will need to opt in, so we can change
+ * this.
+ *
+ * If this ever needs to be a value outside the range of an `int`, the
+ * `getpagesize` function which returns this value will need special
+ * consideration. POSIX has deprecated `getpagesize` in favor of
+ * `sysconf(_SC_PAGESIZE)` which does not have this problem.
+ */
+#define PAGESIZE (0x10000)
+
+#endif
diff --git a/libc-bottom-half/headers/public/__mode_t.h b/libc-bottom-half/headers/public/__mode_t.h
new file mode 100644
index 0000000..c0beef5
--- /dev/null
+++ b/libc-bottom-half/headers/public/__mode_t.h
@@ -0,0 +1,38 @@
+#ifndef __wasilibc___mode_t_h
+#define __wasilibc___mode_t_h
+
+#define S_IFMT \
+    (S_IFBLK | S_IFCHR | S_IFDIR | S_IFIFO | S_IFLNK | S_IFREG | S_IFSOCK)
+#define S_IFBLK (0x6000)
+#define S_IFCHR (0x2000)
+#define S_IFDIR (0x4000)
+#define S_IFLNK (0xa000)
+#define S_IFREG (0x8000)
+#define S_IFSOCK (0xc000)
+#define S_IFIFO (0xc000)
+
+#define S_ISBLK(m) (((m)&S_IFMT) == S_IFBLK)
+#define S_ISCHR(m) (((m)&S_IFMT) == S_IFCHR)
+#define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR)
+#define S_ISFIFO(m) (((m)&S_IFMT) == S_IFIFO)
+#define S_ISLNK(m) (((m)&S_IFMT) == S_IFLNK)
+#define S_ISREG(m) (((m)&S_IFMT) == S_IFREG)
+#define S_ISSOCK(m) (((m)&S_IFMT) == S_IFSOCK)
+
+#define S_IXOTH (0x1)
+#define S_IWOTH (0x2)
+#define S_IROTH (0x4)
+#define S_IRWXO (S_IXOTH | S_IWOTH | S_IROTH)
+#define S_IXGRP (0x8)
+#define S_IWGRP (0x10)
+#define S_IRGRP (0x20)
+#define S_IRWXG (S_IXGRP | S_IWGRP | S_IRGRP)
+#define S_IXUSR (0x40)
+#define S_IWUSR (0x80)
+#define S_IRUSR (0x100)
+#define S_IRWXU (S_IXUSR | S_IWUSR | S_IRUSR)
+#define S_ISVTX (0x200)
+#define S_ISGID (0x400)
+#define S_ISUID (0x800)
+
+#endif
diff --git a/libc-bottom-half/headers/public/__seek.h b/libc-bottom-half/headers/public/__seek.h
new file mode 100644
index 0000000..8824adb
--- /dev/null
+++ b/libc-bottom-half/headers/public/__seek.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc___seek_h
+#define __wasilibc___seek_h
+
+#include <wasi/api.h>
+
+#define SEEK_CUR __WASI_WHENCE_CUR
+#define SEEK_END __WASI_WHENCE_END
+#define SEEK_SET __WASI_WHENCE_SET
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_dirent.h b/libc-bottom-half/headers/public/__struct_dirent.h
new file mode 100644
index 0000000..9d2ece8
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_dirent.h
@@ -0,0 +1,14 @@
+#ifndef __wasilibc___struct_dirent_h
+#define __wasilibc___struct_dirent_h
+
+#include <__typedef_ino_t.h>
+
+#define _DIRENT_HAVE_D_TYPE
+
+struct dirent {
+    ino_t d_ino;
+    unsigned char d_type;
+    char d_name[];
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_in6_addr.h b/libc-bottom-half/headers/public/__struct_in6_addr.h
new file mode 100644
index 0000000..cf2fafe
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_in6_addr.h
@@ -0,0 +1,8 @@
+#ifndef __wasilibc___struct_in6_addr_h
+#define __wasilibc___struct_in6_addr_h
+
+struct in6_addr {
+    _Alignas(int32_t) unsigned char s6_addr[16];
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_in_addr.h b/libc-bottom-half/headers/public/__struct_in_addr.h
new file mode 100644
index 0000000..881ffa6
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_in_addr.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc___struct_in_addr_h
+#define __wasilibc___struct_in_addr_h
+
+#include <__typedef_in_addr_t.h>
+
+struct in_addr {
+    in_addr_t s_addr;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_iovec.h b/libc-bottom-half/headers/public/__struct_iovec.h
new file mode 100644
index 0000000..da3e1c7
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_iovec.h
@@ -0,0 +1,12 @@
+#ifndef __wasilibc___struct_iovec_h
+#define __wasilibc___struct_iovec_h
+
+#define __need_size_t
+#include <stddef.h>
+
+struct iovec {
+    void *iov_base;
+    size_t iov_len;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_msghdr.h b/libc-bottom-half/headers/public/__struct_msghdr.h
new file mode 100644
index 0000000..0c0877d
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_msghdr.h
@@ -0,0 +1,16 @@
+#ifndef __wasilibc___struct_msghdr_h
+#define __wasilibc___struct_msghdr_h
+
+#include <__typedef_socklen_t.h>
+
+struct msghdr {
+    void *msg_name;
+    socklen_t msg_namelen;
+    struct iovec *msg_iov;
+    int msg_iovlen;
+    void *msg_control;
+    socklen_t msg_controllen;
+    int msg_flags;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_pollfd.h b/libc-bottom-half/headers/public/__struct_pollfd.h
new file mode 100644
index 0000000..45874c5
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_pollfd.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc___struct_pollfd_h
+#define __wasilibc___struct_pollfd_h
+
+struct pollfd {
+    int fd;
+    short events;
+    short revents;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_rusage.h b/libc-bottom-half/headers/public/__struct_rusage.h
new file mode 100644
index 0000000..69fe2fe
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_rusage.h
@@ -0,0 +1,12 @@
+#ifndef __wasilibc___struct_rusage_h
+#define __wasilibc___struct_rusage_h
+
+#include <__struct_timeval.h>
+
+/* TODO: Add more features here. */
+struct rusage {
+    struct timeval ru_utime;
+    struct timeval ru_stime;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_sockaddr.h b/libc-bottom-half/headers/public/__struct_sockaddr.h
new file mode 100644
index 0000000..9891b90
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_sockaddr.h
@@ -0,0 +1,14 @@
+#ifndef __wasilibc___struct_sockaddr_h
+#define __wasilibc___struct_sockaddr_h
+
+#define __need_STDDEF_H_misc
+#include <stddef.h>
+
+#include <__typedef_sa_family_t.h>
+
+struct sockaddr {
+    __attribute__((aligned(__BIGGEST_ALIGNMENT__))) sa_family_t sa_family;
+    char sa_data[0];
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_sockaddr_in.h b/libc-bottom-half/headers/public/__struct_sockaddr_in.h
new file mode 100644
index 0000000..73dc5c6
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_sockaddr_in.h
@@ -0,0 +1,17 @@
+#ifndef __wasilibc___struct_sockaddr_in_h
+#define __wasilibc___struct_sockaddr_in_h
+
+#define __need_STDDEF_H_misc
+#include <stddef.h>
+
+#include <__typedef_sa_family_t.h>
+#include <__typedef_in_port_t.h>
+#include <__struct_in_addr.h>
+
+struct sockaddr_in {
+    _Alignas(max_align_t) sa_family_t sin_family;
+    in_port_t sin_port;
+    struct in_addr sin_addr;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_sockaddr_in6.h b/libc-bottom-half/headers/public/__struct_sockaddr_in6.h
new file mode 100644
index 0000000..a220f91
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_sockaddr_in6.h
@@ -0,0 +1,19 @@
+#ifndef __wasilibc___struct_sockaddr_in6_h
+#define __wasilibc___struct_sockaddr_in6_h
+
+#define __need_STDDEF_H_misc
+#include <stddef.h>
+
+#include <__typedef_sa_family_t.h>
+#include <__typedef_in_port_t.h>
+#include <__struct_in6_addr.h>
+
+struct sockaddr_in6 {
+    _Alignas(max_align_t) sa_family_t sin6_family;
+    in_port_t sin6_port;
+    unsigned sin6_flowinfo;
+    struct in6_addr sin6_addr;
+    unsigned sin6_scope_id;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_sockaddr_storage.h b/libc-bottom-half/headers/public/__struct_sockaddr_storage.h
new file mode 100644
index 0000000..1ae26a7
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_sockaddr_storage.h
@@ -0,0 +1,14 @@
+#ifndef __wasilibc___struct_sockaddr_storage_h
+#define __wasilibc___struct_sockaddr_storage_h
+
+#define __need_STDDEF_H_misc
+#include <stddef.h>
+
+#include <__typedef_sa_family_t.h>
+
+struct sockaddr_storage {
+    _Alignas(max_align_t) sa_family_t ss_family;
+    char __ss_data[32];
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_sockaddr_un.h b/libc-bottom-half/headers/public/__struct_sockaddr_un.h
new file mode 100644
index 0000000..a5be6e5
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_sockaddr_un.h
@@ -0,0 +1,13 @@
+#ifndef __wasilibc___struct_sockaddr_un_h
+#define __wasilibc___struct_sockaddr_un_h
+
+#define __need_STDDEF_H_misc
+#include <stddef.h>
+
+#include <__typedef_sa_family_t.h>
+
+struct sockaddr_un {
+    _Alignas(max_align_t) sa_family_t sun_family;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_stat.h b/libc-bottom-half/headers/public/__struct_stat.h
new file mode 100644
index 0000000..5e345da
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_stat.h
@@ -0,0 +1,35 @@
+#ifndef __wasilibc___struct_stat_h
+#define __wasilibc___struct_stat_h
+
+#include <__typedef_dev_t.h>
+#include <__typedef_ino_t.h>
+#include <__typedef_nlink_t.h>
+#include <__typedef_mode_t.h>
+#include <__typedef_uid_t.h>
+#include <__typedef_gid_t.h>
+#include <__typedef_off_t.h>
+#include <__typedef_blksize_t.h>
+#include <__typedef_blkcnt_t.h>
+#include <__struct_timespec.h>
+
+struct stat {
+    dev_t st_dev;
+    ino_t st_ino;
+    nlink_t st_nlink;
+
+    mode_t st_mode;
+    uid_t st_uid;
+    gid_t st_gid;
+    unsigned int __pad0;
+    dev_t st_rdev;
+    off_t st_size;
+    blksize_t st_blksize;
+    blkcnt_t st_blocks;
+
+    struct timespec st_atim;
+    struct timespec st_mtim;
+    struct timespec st_ctim;
+    long long __reserved[3];
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_timespec.h b/libc-bottom-half/headers/public/__struct_timespec.h
new file mode 100644
index 0000000..10d83f9
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_timespec.h
@@ -0,0 +1,12 @@
+#ifndef __wasilibc___struct_timespec_h
+#define __wasilibc___struct_timespec_h
+
+#include <__typedef_time_t.h>
+
+/* As specified in POSIX. */
+struct timespec {
+    time_t tv_sec;
+    long tv_nsec;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_timeval.h b/libc-bottom-half/headers/public/__struct_timeval.h
new file mode 100644
index 0000000..b09f1a9
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_timeval.h
@@ -0,0 +1,13 @@
+#ifndef __wasilibc___struct_timeval_h
+#define __wasilibc___struct_timeval_h
+
+#include <__typedef_time_t.h>
+#include <__typedef_suseconds_t.h>
+
+/* As specified in POSIX. */
+struct timeval {
+    time_t tv_sec;
+    suseconds_t tv_usec;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_tm.h b/libc-bottom-half/headers/public/__struct_tm.h
new file mode 100644
index 0000000..3c83dc5
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_tm.h
@@ -0,0 +1,19 @@
+#ifndef __wasilibc___struct_tm_h
+#define __wasilibc___struct_tm_h
+
+struct tm {
+    int tm_sec;
+    int tm_min;
+    int tm_hour;
+    int tm_mday;
+    int tm_mon;
+    int tm_year;
+    int tm_wday;
+    int tm_yday;
+    int tm_isdst;
+    int __tm_gmtoff;
+    const char *__tm_zone;
+    int __tm_nsec;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__struct_tms.h b/libc-bottom-half/headers/public/__struct_tms.h
new file mode 100644
index 0000000..9914097
--- /dev/null
+++ b/libc-bottom-half/headers/public/__struct_tms.h
@@ -0,0 +1,13 @@
+#ifndef __wasilibc___struct_tms_h
+#define __wasilibc___struct_tms_h
+
+#include <__typedef_clock_t.h>
+
+struct tms {
+    clock_t tms_utime;
+    clock_t tms_stime;
+    clock_t tms_cutime;
+    clock_t tms_cstime;
+};
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_DIR.h b/libc-bottom-half/headers/public/__typedef_DIR.h
new file mode 100644
index 0000000..f07cfc1
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_DIR.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_DIR_h
+#define __wasilibc___typedef_DIR_h
+
+typedef struct _DIR DIR;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_blkcnt_t.h b/libc-bottom-half/headers/public/__typedef_blkcnt_t.h
new file mode 100644
index 0000000..e8d7b3d
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_blkcnt_t.h
@@ -0,0 +1,7 @@
+#ifndef __wasilibc___typedef_blkcnt_t_h
+#define __wasilibc___typedef_blkcnt_t_h
+
+/* Define these as 64-bit signed integers to support files larger than 2 GiB. */
+typedef long long blkcnt_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_blksize_t.h b/libc-bottom-half/headers/public/__typedef_blksize_t.h
new file mode 100644
index 0000000..8816e0a
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_blksize_t.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_blksize_t_h
+#define __wasilibc___typedef_blksize_t_h
+
+typedef long blksize_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_clock_t.h b/libc-bottom-half/headers/public/__typedef_clock_t.h
new file mode 100644
index 0000000..68cb588
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_clock_t.h
@@ -0,0 +1,7 @@
+#ifndef __wasilibc___typedef_clock_t_h
+#define __wasilibc___typedef_clock_t_h
+
+/* Define this as a 64-bit signed integer to avoid wraparounds. */
+typedef long long clock_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_clockid_t.h b/libc-bottom-half/headers/public/__typedef_clockid_t.h
new file mode 100644
index 0000000..6de4244
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_clockid_t.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_clockid_t_h
+#define __wasilibc___typedef_clockid_t_h
+
+typedef const struct __clockid *clockid_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_dev_t.h b/libc-bottom-half/headers/public/__typedef_dev_t.h
new file mode 100644
index 0000000..353e94f
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_dev_t.h
@@ -0,0 +1,7 @@
+#ifndef __wasilibc___typedef_dev_t_h
+#define __wasilibc___typedef_dev_t_h
+
+/* Define these as 64-bit integers to support billions of devices. */
+typedef unsigned long long dev_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_fd_set.h b/libc-bottom-half/headers/public/__typedef_fd_set.h
new file mode 100644
index 0000000..35ea958
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_fd_set.h
@@ -0,0 +1,14 @@
+#ifndef __wasilibc___typedef_fd_set_h
+#define __wasilibc___typedef_fd_set_h
+
+#define __need_size_t
+#include <stddef.h>
+
+#include <__macro_FD_SETSIZE.h>
+
+typedef struct {
+    size_t __nfds;
+    int __fds[FD_SETSIZE];
+} fd_set;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_gid_t.h b/libc-bottom-half/headers/public/__typedef_gid_t.h
new file mode 100644
index 0000000..6eb82f2
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_gid_t.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_gid_t_h
+#define __wasilibc___typedef_gid_t_h
+
+typedef unsigned gid_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_in_addr_t.h b/libc-bottom-half/headers/public/__typedef_in_addr_t.h
new file mode 100644
index 0000000..68ab512
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_in_addr_t.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_in_addr_t_h
+#define __wasilibc___typedef_in_addr_t_h
+
+typedef unsigned in_addr_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_in_port_t.h b/libc-bottom-half/headers/public/__typedef_in_port_t.h
new file mode 100644
index 0000000..890a2c8
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_in_port_t.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_in_port_t_h
+#define __wasilibc___typedef_in_port_t_h
+
+typedef unsigned short in_port_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_ino_t.h b/libc-bottom-half/headers/public/__typedef_ino_t.h
new file mode 100644
index 0000000..f3e11e4
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_ino_t.h
@@ -0,0 +1,7 @@
+#ifndef __wasilibc___typedef_ino_t_h
+#define __wasilibc___typedef_ino_t_h
+
+/* Define these as 64-bit integers to support billions of inodes. */
+typedef unsigned long long ino_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_mode_t.h b/libc-bottom-half/headers/public/__typedef_mode_t.h
new file mode 100644
index 0000000..51b927d
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_mode_t.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_mode_t_h
+#define __wasilibc___typedef_mode_t_h
+
+typedef unsigned mode_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_nfds_t.h b/libc-bottom-half/headers/public/__typedef_nfds_t.h
new file mode 100644
index 0000000..ea0a93e
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_nfds_t.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_nfds_t_h
+#define __wasilibc___typedef_nfds_t_h
+
+typedef unsigned long nfds_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_nlink_t.h b/libc-bottom-half/headers/public/__typedef_nlink_t.h
new file mode 100644
index 0000000..ae34c79
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_nlink_t.h
@@ -0,0 +1,7 @@
+#ifndef __wasilibc___typedef_nlink_t_h
+#define __wasilibc___typedef_nlink_t_h
+
+/* Define these as 64-bit unsigned integers to support billions of links. */
+typedef unsigned long long nlink_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_off_t.h b/libc-bottom-half/headers/public/__typedef_off_t.h
new file mode 100644
index 0000000..115ffdd
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_off_t.h
@@ -0,0 +1,7 @@
+#ifndef __wasilibc___typedef_off_t_h
+#define __wasilibc___typedef_off_t_h
+
+/* Define these as 64-bit signed integers to support files larger than 2 GiB. */
+typedef long long off_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_sa_family_t.h b/libc-bottom-half/headers/public/__typedef_sa_family_t.h
new file mode 100644
index 0000000..0ad18c9
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_sa_family_t.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_sa_family_t_h
+#define __wasilibc___typedef_sa_family_t_h
+
+typedef unsigned short sa_family_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_sigset_t.h b/libc-bottom-half/headers/public/__typedef_sigset_t.h
new file mode 100644
index 0000000..f7e4867
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_sigset_t.h
@@ -0,0 +1,7 @@
+#ifndef __wasilibc___typedef_sigset_t_h
+#define __wasilibc___typedef_sigset_t_h
+
+/* TODO: This is just a placeholder for now. Keep this in sync with musl. */
+typedef unsigned char sigset_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_socklen_t.h b/libc-bottom-half/headers/public/__typedef_socklen_t.h
new file mode 100644
index 0000000..bd68e55
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_socklen_t.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_socklen_t_h
+#define __wasilibc___typedef_socklen_t_h
+
+typedef unsigned socklen_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_ssize_t.h b/libc-bottom-half/headers/public/__typedef_ssize_t.h
new file mode 100644
index 0000000..25dc15a
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_ssize_t.h
@@ -0,0 +1,7 @@
+#ifndef __wasilibc___typedef_ssize_t_h
+#define __wasilibc___typedef_ssize_t_h
+
+/* This is defined to be the same size as size_t. */
+typedef long ssize_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_suseconds_t.h b/libc-bottom-half/headers/public/__typedef_suseconds_t.h
new file mode 100644
index 0000000..92667e2
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_suseconds_t.h
@@ -0,0 +1,8 @@
+#ifndef __wasilibc___typedef_suseconds_t_h
+#define __wasilibc___typedef_suseconds_t_h
+
+/* Define this to be 64-bit as its main use is in struct timeval where the
+   extra space would otherwise be padding. */
+typedef long long suseconds_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_time_t.h b/libc-bottom-half/headers/public/__typedef_time_t.h
new file mode 100644
index 0000000..6ee0f86
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_time_t.h
@@ -0,0 +1,7 @@
+#ifndef __wasilibc___typedef_time_t_h
+#define __wasilibc___typedef_time_t_h
+
+/* Define this as a 64-bit signed integer to avoid the 2038 bug. */
+typedef long long time_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/__typedef_uid_t.h b/libc-bottom-half/headers/public/__typedef_uid_t.h
new file mode 100644
index 0000000..c9da300
--- /dev/null
+++ b/libc-bottom-half/headers/public/__typedef_uid_t.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc___typedef_uid_t_h
+#define __wasilibc___typedef_uid_t_h
+
+typedef unsigned uid_t;
+
+#endif
diff --git a/libc-bottom-half/headers/public/dirent.h b/libc-bottom-half/headers/public/dirent.h
new file mode 100644
index 0000000..ce1364a
--- /dev/null
+++ b/libc-bottom-half/headers/public/dirent.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_dirent_h
+#define __wasilibc_dirent_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc dirent implementations.
+ */
+#include <__header_dirent.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/errno.h b/libc-bottom-half/headers/public/errno.h
new file mode 100644
index 0000000..f3914ee
--- /dev/null
+++ b/libc-bottom-half/headers/public/errno.h
@@ -0,0 +1,7 @@
+#ifndef __wasilibc_errno_h
+#define __wasilibc_errno_h
+
+#include <__errno.h>
+#include <__errno_values.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/fcntl.h b/libc-bottom-half/headers/public/fcntl.h
new file mode 100644
index 0000000..0ca3e86
--- /dev/null
+++ b/libc-bottom-half/headers/public/fcntl.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_fcntl_h
+#define __wasilibc_fcntl_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc fcntl implementations.
+ */
+#include <__header_fcntl.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/inttypes.h b/libc-bottom-half/headers/public/inttypes.h
new file mode 100644
index 0000000..a237857
--- /dev/null
+++ b/libc-bottom-half/headers/public/inttypes.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_inttypes_h
+#define __wasilibc_inttypes_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc stdlib implementations.
+ */
+#include <__header_inttypes.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/netinet/in.h b/libc-bottom-half/headers/public/netinet/in.h
new file mode 100644
index 0000000..b27bffe
--- /dev/null
+++ b/libc-bottom-half/headers/public/netinet/in.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc_netinet_in_h
+#define __wasilibc_netinet_in_h
+
+#include <__header_netinet_in.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/poll.h b/libc-bottom-half/headers/public/poll.h
new file mode 100644
index 0000000..22f4b6c
--- /dev/null
+++ b/libc-bottom-half/headers/public/poll.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_poll_h
+#define __wasilibc_poll_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc poll implementations.
+ */
+#include <__header_poll.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/stdlib.h b/libc-bottom-half/headers/public/stdlib.h
new file mode 100644
index 0000000..8425cb8
--- /dev/null
+++ b/libc-bottom-half/headers/public/stdlib.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_stdlib_h
+#define __wasilibc_stdlib_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc stdlib implementations.
+ */
+#include <__functions_malloc.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/string.h b/libc-bottom-half/headers/public/string.h
new file mode 100644
index 0000000..fee51ef
--- /dev/null
+++ b/libc-bottom-half/headers/public/string.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_string_h
+#define __wasilibc_string_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc string implementations.
+ */
+#include <__header_string.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/sys/ioctl.h b/libc-bottom-half/headers/public/sys/ioctl.h
new file mode 100644
index 0000000..085b314
--- /dev/null
+++ b/libc-bottom-half/headers/public/sys/ioctl.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_sys_ioctl_h
+#define __wasilibc_sys_ioctl_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc ioctl implementations.
+ */
+#include <__header_sys_ioctl.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/sys/resource.h b/libc-bottom-half/headers/public/sys/resource.h
new file mode 100644
index 0000000..5896861
--- /dev/null
+++ b/libc-bottom-half/headers/public/sys/resource.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_sys_resource_h
+#define __wasilibc_sys_resource_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc resource implementations.
+ */
+#include <__header_sys_resource.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/sys/select.h b/libc-bottom-half/headers/public/sys/select.h
new file mode 100644
index 0000000..7570f14
--- /dev/null
+++ b/libc-bottom-half/headers/public/sys/select.h
@@ -0,0 +1,18 @@
+#ifndef __wasilibc_sys_select_h
+#define __wasilibc_sys_select_h
+
+#include <__fd_set.h>
+#include <__struct_timespec.h>
+#include <__struct_timeval.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int pselect(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/sys/socket.h b/libc-bottom-half/headers/public/sys/socket.h
new file mode 100644
index 0000000..874f605
--- /dev/null
+++ b/libc-bottom-half/headers/public/sys/socket.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc_sys_socket_h
+#define __wasilibc_sys_socket_h
+
+#include <__header_sys_socket.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/sys/stat.h b/libc-bottom-half/headers/public/sys/stat.h
new file mode 100644
index 0000000..586b41f
--- /dev/null
+++ b/libc-bottom-half/headers/public/sys/stat.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_sys_stat_h
+#define __wasilibc_sys_stat_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc stat implementations.
+ */
+#include <__header_sys_stat.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/sys/time.h b/libc-bottom-half/headers/public/sys/time.h
new file mode 100644
index 0000000..3ee0b3b
--- /dev/null
+++ b/libc-bottom-half/headers/public/sys/time.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc_sys_time_h
+#define __wasilibc_sys_time_h
+
+#include <__struct_timeval.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/sys/times.h b/libc-bottom-half/headers/public/sys/times.h
new file mode 100644
index 0000000..986bc0d
--- /dev/null
+++ b/libc-bottom-half/headers/public/sys/times.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc_sys_times_h
+#define __wasilibc_sys_times_h
+
+#include <__struct_tms.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/sys/types.h b/libc-bottom-half/headers/public/sys/types.h
new file mode 100644
index 0000000..3bce96f
--- /dev/null
+++ b/libc-bottom-half/headers/public/sys/types.h
@@ -0,0 +1,16 @@
+#ifndef __wasilibc_sys_types_h
+#define __wasilibc_sys_types_h
+
+#define __need_size_t
+#include <stddef.h>
+
+#include <__typedef_clock_t.h>
+#include <__typedef_time_t.h>
+#include <__typedef_blksize_t.h>
+#include <__typedef_off_t.h>
+#include <__typedef_ssize_t.h>
+#include <__typedef_suseconds_t.h>
+#include <__typedef_nlink_t.h>
+#include <__typedef_clockid_t.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/sys/uio.h b/libc-bottom-half/headers/public/sys/uio.h
new file mode 100644
index 0000000..bb502a1
--- /dev/null
+++ b/libc-bottom-half/headers/public/sys/uio.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc_sys_uio_h
+#define __wasilibc_sys_uio_h
+
+#include <__struct_iovec.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/sys/un.h b/libc-bottom-half/headers/public/sys/un.h
new file mode 100644
index 0000000..997e613
--- /dev/null
+++ b/libc-bottom-half/headers/public/sys/un.h
@@ -0,0 +1,6 @@
+#ifndef __wasilibc_sys_un_h
+#define __wasilibc_sys_un_h
+
+#include <__struct_sockaddr_un.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/time.h b/libc-bottom-half/headers/public/time.h
new file mode 100644
index 0000000..646e599
--- /dev/null
+++ b/libc-bottom-half/headers/public/time.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_time_h
+#define __wasilibc_time_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc time implementations.
+ */
+#include <__header_time.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/unistd.h b/libc-bottom-half/headers/public/unistd.h
new file mode 100644
index 0000000..5f8edfa
--- /dev/null
+++ b/libc-bottom-half/headers/public/unistd.h
@@ -0,0 +1,10 @@
+#ifndef __wasilibc_unistd_h
+#define __wasilibc_unistd_h
+
+/*
+ * Include the real implementation, which is factored into a separate file so
+ * that it can be reused by other libc unistd implementations.
+ */
+#include <__header_unistd.h>
+
+#endif
diff --git a/libc-bottom-half/headers/public/wasi/api.h b/libc-bottom-half/headers/public/wasi/api.h
new file mode 100644
index 0000000..1ab7699
--- /dev/null
+++ b/libc-bottom-half/headers/public/wasi/api.h
@@ -0,0 +1,2115 @@
+/**
+ * <wasi/api.h>. This file contains declarations describing the WASI ABI
+ * as of "snapshot preview1". It was originally auto-generated from
+ * wasi_snapshot_preview1.witx, however WASI is in the process of
+ * transitioning to a new IDL and header file generator, and this file
+ * is temporarily being manually maintained.
+ *
+ * @file
+ * This file describes the [WASI] interface, consisting of functions, types,
+ * and defined values (macros).
+ *
+ * The interface described here is greatly inspired by [CloudABI]'s clean,
+ * thoughtfully-designed, capability-oriented, POSIX-style API.
+ *
+ * [CloudABI]: https://github.com/NuxiNL/cloudlibc
+ * [WASI]: https://github.com/WebAssembly/WASI/
+ */
+
+#ifndef __wasi_api_h
+#define __wasi_api_h
+
+#ifndef __wasi__
+#error <wasi/api.h> is only supported on WASI platforms.
+#endif
+
+#ifndef __wasm32__
+#error <wasi/api.h> only supports wasm32; doesn't yet support wasm64
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+_Static_assert(_Alignof(int8_t) == 1, "non-wasi data layout");
+_Static_assert(_Alignof(uint8_t) == 1, "non-wasi data layout");
+_Static_assert(_Alignof(int16_t) == 2, "non-wasi data layout");
+_Static_assert(_Alignof(uint16_t) == 2, "non-wasi data layout");
+_Static_assert(_Alignof(int32_t) == 4, "non-wasi data layout");
+_Static_assert(_Alignof(uint32_t) == 4, "non-wasi data layout");
+_Static_assert(_Alignof(int64_t) == 8, "non-wasi data layout");
+_Static_assert(_Alignof(uint64_t) == 8, "non-wasi data layout");
+_Static_assert(_Alignof(void*) == 4, "non-wasi data layout");
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// TODO: Encoding this in witx.
+#define __WASI_DIRCOOKIE_START (UINT64_C(0))
+typedef __SIZE_TYPE__ __wasi_size_t;
+
+_Static_assert(sizeof(__wasi_size_t) == 4, "witx calculated size");
+_Static_assert(_Alignof(__wasi_size_t) == 4, "witx calculated align");
+
+/**
+ * Non-negative file size or length of a region within a file.
+ */
+typedef uint64_t __wasi_filesize_t;
+
+_Static_assert(sizeof(__wasi_filesize_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_filesize_t) == 8, "witx calculated align");
+
+/**
+ * Timestamp in nanoseconds.
+ */
+typedef uint64_t __wasi_timestamp_t;
+
+_Static_assert(sizeof(__wasi_timestamp_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_timestamp_t) == 8, "witx calculated align");
+
+/**
+ * Identifiers for clocks.
+ */
+typedef uint32_t __wasi_clockid_t;
+
+/**
+ * The clock measuring real time. Time value zero corresponds with
+ * 1970-01-01T00:00:00Z.
+ */
+#define __WASI_CLOCKID_REALTIME (UINT32_C(0))
+
+/**
+ * The store-wide monotonic clock, which is defined as a clock measuring
+ * real time, whose value cannot be adjusted and which cannot have negative
+ * clock jumps. The epoch of this clock is undefined. The absolute time
+ * value of this clock therefore has no meaning.
+ */
+#define __WASI_CLOCKID_MONOTONIC (UINT32_C(1))
+
+/**
+ * The CPU-time clock associated with the current process.
+ */
+#define __WASI_CLOCKID_PROCESS_CPUTIME_ID (UINT32_C(2))
+
+/**
+ * The CPU-time clock associated with the current thread.
+ */
+#define __WASI_CLOCKID_THREAD_CPUTIME_ID (UINT32_C(3))
+
+_Static_assert(sizeof(__wasi_clockid_t) == 4, "witx calculated size");
+_Static_assert(_Alignof(__wasi_clockid_t) == 4, "witx calculated align");
+
+/**
+ * Error codes returned by functions.
+ * Not all of these error codes are returned by the functions provided by this
+ * API; some are used in higher-level library layers, and others are provided
+ * merely for alignment with POSIX.
+ */
+typedef uint16_t __wasi_errno_t;
+
+/**
+ * No error occurred. System call completed successfully.
+ */
+#define __WASI_ERRNO_SUCCESS (UINT16_C(0))
+
+/**
+ * Argument list too long.
+ */
+#define __WASI_ERRNO_2BIG (UINT16_C(1))
+
+/**
+ * Permission denied.
+ */
+#define __WASI_ERRNO_ACCES (UINT16_C(2))
+
+/**
+ * Address in use.
+ */
+#define __WASI_ERRNO_ADDRINUSE (UINT16_C(3))
+
+/**
+ * Address not available.
+ */
+#define __WASI_ERRNO_ADDRNOTAVAIL (UINT16_C(4))
+
+/**
+ * Address family not supported.
+ */
+#define __WASI_ERRNO_AFNOSUPPORT (UINT16_C(5))
+
+/**
+ * Resource unavailable, or operation would block.
+ */
+#define __WASI_ERRNO_AGAIN (UINT16_C(6))
+
+/**
+ * Connection already in progress.
+ */
+#define __WASI_ERRNO_ALREADY (UINT16_C(7))
+
+/**
+ * Bad file descriptor.
+ */
+#define __WASI_ERRNO_BADF (UINT16_C(8))
+
+/**
+ * Bad message.
+ */
+#define __WASI_ERRNO_BADMSG (UINT16_C(9))
+
+/**
+ * Device or resource busy.
+ */
+#define __WASI_ERRNO_BUSY (UINT16_C(10))
+
+/**
+ * Operation canceled.
+ */
+#define __WASI_ERRNO_CANCELED (UINT16_C(11))
+
+/**
+ * No child processes.
+ */
+#define __WASI_ERRNO_CHILD (UINT16_C(12))
+
+/**
+ * Connection aborted.
+ */
+#define __WASI_ERRNO_CONNABORTED (UINT16_C(13))
+
+/**
+ * Connection refused.
+ */
+#define __WASI_ERRNO_CONNREFUSED (UINT16_C(14))
+
+/**
+ * Connection reset.
+ */
+#define __WASI_ERRNO_CONNRESET (UINT16_C(15))
+
+/**
+ * Resource deadlock would occur.
+ */
+#define __WASI_ERRNO_DEADLK (UINT16_C(16))
+
+/**
+ * Destination address required.
+ */
+#define __WASI_ERRNO_DESTADDRREQ (UINT16_C(17))
+
+/**
+ * Mathematics argument out of domain of function.
+ */
+#define __WASI_ERRNO_DOM (UINT16_C(18))
+
+/**
+ * Reserved.
+ */
+#define __WASI_ERRNO_DQUOT (UINT16_C(19))
+
+/**
+ * File exists.
+ */
+#define __WASI_ERRNO_EXIST (UINT16_C(20))
+
+/**
+ * Bad address.
+ */
+#define __WASI_ERRNO_FAULT (UINT16_C(21))
+
+/**
+ * File too large.
+ */
+#define __WASI_ERRNO_FBIG (UINT16_C(22))
+
+/**
+ * Host is unreachable.
+ */
+#define __WASI_ERRNO_HOSTUNREACH (UINT16_C(23))
+
+/**
+ * Identifier removed.
+ */
+#define __WASI_ERRNO_IDRM (UINT16_C(24))
+
+/**
+ * Illegal byte sequence.
+ */
+#define __WASI_ERRNO_ILSEQ (UINT16_C(25))
+
+/**
+ * Operation in progress.
+ */
+#define __WASI_ERRNO_INPROGRESS (UINT16_C(26))
+
+/**
+ * Interrupted function.
+ */
+#define __WASI_ERRNO_INTR (UINT16_C(27))
+
+/**
+ * Invalid argument.
+ */
+#define __WASI_ERRNO_INVAL (UINT16_C(28))
+
+/**
+ * I/O error.
+ */
+#define __WASI_ERRNO_IO (UINT16_C(29))
+
+/**
+ * Socket is connected.
+ */
+#define __WASI_ERRNO_ISCONN (UINT16_C(30))
+
+/**
+ * Is a directory.
+ */
+#define __WASI_ERRNO_ISDIR (UINT16_C(31))
+
+/**
+ * Too many levels of symbolic links.
+ */
+#define __WASI_ERRNO_LOOP (UINT16_C(32))
+
+/**
+ * File descriptor value too large.
+ */
+#define __WASI_ERRNO_MFILE (UINT16_C(33))
+
+/**
+ * Too many links.
+ */
+#define __WASI_ERRNO_MLINK (UINT16_C(34))
+
+/**
+ * Message too large.
+ */
+#define __WASI_ERRNO_MSGSIZE (UINT16_C(35))
+
+/**
+ * Reserved.
+ */
+#define __WASI_ERRNO_MULTIHOP (UINT16_C(36))
+
+/**
+ * Filename too long.
+ */
+#define __WASI_ERRNO_NAMETOOLONG (UINT16_C(37))
+
+/**
+ * Network is down.
+ */
+#define __WASI_ERRNO_NETDOWN (UINT16_C(38))
+
+/**
+ * Connection aborted by network.
+ */
+#define __WASI_ERRNO_NETRESET (UINT16_C(39))
+
+/**
+ * Network unreachable.
+ */
+#define __WASI_ERRNO_NETUNREACH (UINT16_C(40))
+
+/**
+ * Too many files open in system.
+ */
+#define __WASI_ERRNO_NFILE (UINT16_C(41))
+
+/**
+ * No buffer space available.
+ */
+#define __WASI_ERRNO_NOBUFS (UINT16_C(42))
+
+/**
+ * No such device.
+ */
+#define __WASI_ERRNO_NODEV (UINT16_C(43))
+
+/**
+ * No such file or directory.
+ */
+#define __WASI_ERRNO_NOENT (UINT16_C(44))
+
+/**
+ * Executable file format error.
+ */
+#define __WASI_ERRNO_NOEXEC (UINT16_C(45))
+
+/**
+ * No locks available.
+ */
+#define __WASI_ERRNO_NOLCK (UINT16_C(46))
+
+/**
+ * Reserved.
+ */
+#define __WASI_ERRNO_NOLINK (UINT16_C(47))
+
+/**
+ * Not enough space.
+ */
+#define __WASI_ERRNO_NOMEM (UINT16_C(48))
+
+/**
+ * No message of the desired type.
+ */
+#define __WASI_ERRNO_NOMSG (UINT16_C(49))
+
+/**
+ * Protocol not available.
+ */
+#define __WASI_ERRNO_NOPROTOOPT (UINT16_C(50))
+
+/**
+ * No space left on device.
+ */
+#define __WASI_ERRNO_NOSPC (UINT16_C(51))
+
+/**
+ * Function not supported.
+ */
+#define __WASI_ERRNO_NOSYS (UINT16_C(52))
+
+/**
+ * The socket is not connected.
+ */
+#define __WASI_ERRNO_NOTCONN (UINT16_C(53))
+
+/**
+ * Not a directory or a symbolic link to a directory.
+ */
+#define __WASI_ERRNO_NOTDIR (UINT16_C(54))
+
+/**
+ * Directory not empty.
+ */
+#define __WASI_ERRNO_NOTEMPTY (UINT16_C(55))
+
+/**
+ * State not recoverable.
+ */
+#define __WASI_ERRNO_NOTRECOVERABLE (UINT16_C(56))
+
+/**
+ * Not a socket.
+ */
+#define __WASI_ERRNO_NOTSOCK (UINT16_C(57))
+
+/**
+ * Not supported, or operation not supported on socket.
+ */
+#define __WASI_ERRNO_NOTSUP (UINT16_C(58))
+
+/**
+ * Inappropriate I/O control operation.
+ */
+#define __WASI_ERRNO_NOTTY (UINT16_C(59))
+
+/**
+ * No such device or address.
+ */
+#define __WASI_ERRNO_NXIO (UINT16_C(60))
+
+/**
+ * Value too large to be stored in data type.
+ */
+#define __WASI_ERRNO_OVERFLOW (UINT16_C(61))
+
+/**
+ * Previous owner died.
+ */
+#define __WASI_ERRNO_OWNERDEAD (UINT16_C(62))
+
+/**
+ * Operation not permitted.
+ */
+#define __WASI_ERRNO_PERM (UINT16_C(63))
+
+/**
+ * Broken pipe.
+ */
+#define __WASI_ERRNO_PIPE (UINT16_C(64))
+
+/**
+ * Protocol error.
+ */
+#define __WASI_ERRNO_PROTO (UINT16_C(65))
+
+/**
+ * Protocol not supported.
+ */
+#define __WASI_ERRNO_PROTONOSUPPORT (UINT16_C(66))
+
+/**
+ * Protocol wrong type for socket.
+ */
+#define __WASI_ERRNO_PROTOTYPE (UINT16_C(67))
+
+/**
+ * Result too large.
+ */
+#define __WASI_ERRNO_RANGE (UINT16_C(68))
+
+/**
+ * Read-only file system.
+ */
+#define __WASI_ERRNO_ROFS (UINT16_C(69))
+
+/**
+ * Invalid seek.
+ */
+#define __WASI_ERRNO_SPIPE (UINT16_C(70))
+
+/**
+ * No such process.
+ */
+#define __WASI_ERRNO_SRCH (UINT16_C(71))
+
+/**
+ * Reserved.
+ */
+#define __WASI_ERRNO_STALE (UINT16_C(72))
+
+/**
+ * Connection timed out.
+ */
+#define __WASI_ERRNO_TIMEDOUT (UINT16_C(73))
+
+/**
+ * Text file busy.
+ */
+#define __WASI_ERRNO_TXTBSY (UINT16_C(74))
+
+/**
+ * Cross-device link.
+ */
+#define __WASI_ERRNO_XDEV (UINT16_C(75))
+
+/**
+ * Extension: Capabilities insufficient.
+ */
+#define __WASI_ERRNO_NOTCAPABLE (UINT16_C(76))
+
+_Static_assert(sizeof(__wasi_errno_t) == 2, "witx calculated size");
+_Static_assert(_Alignof(__wasi_errno_t) == 2, "witx calculated align");
+
+/**
+ * File descriptor rights, determining which actions may be performed.
+ */
+typedef uint64_t __wasi_rights_t;
+
+/**
+ * The right to invoke `fd_datasync`.
+ * If `path_open` is set, includes the right to invoke
+ * `path_open` with `fdflags::dsync`.
+ */
+#define __WASI_RIGHTS_FD_DATASYNC ((__wasi_rights_t)(1 << 0))
+
+/**
+ * The right to invoke `fd_read` and `sock_recv`.
+ * If `rights::fd_seek` is set, includes the right to invoke `fd_pread`.
+ */
+#define __WASI_RIGHTS_FD_READ ((__wasi_rights_t)(1 << 1))
+
+/**
+ * The right to invoke `fd_seek`. This flag implies `rights::fd_tell`.
+ */
+#define __WASI_RIGHTS_FD_SEEK ((__wasi_rights_t)(1 << 2))
+
+/**
+ * The right to invoke `fd_fdstat_set_flags`.
+ */
+#define __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS ((__wasi_rights_t)(1 << 3))
+
+/**
+ * The right to invoke `fd_sync`.
+ * If `path_open` is set, includes the right to invoke
+ * `path_open` with `fdflags::rsync` and `fdflags::dsync`.
+ */
+#define __WASI_RIGHTS_FD_SYNC ((__wasi_rights_t)(1 << 4))
+
+/**
+ * The right to invoke `fd_seek` in such a way that the file offset
+ * remains unaltered (i.e., `whence::cur` with offset zero), or to
+ * invoke `fd_tell`.
+ */
+#define __WASI_RIGHTS_FD_TELL ((__wasi_rights_t)(1 << 5))
+
+/**
+ * The right to invoke `fd_write` and `sock_send`.
+ * If `rights::fd_seek` is set, includes the right to invoke `fd_pwrite`.
+ */
+#define __WASI_RIGHTS_FD_WRITE ((__wasi_rights_t)(1 << 6))
+
+/**
+ * The right to invoke `fd_advise`.
+ */
+#define __WASI_RIGHTS_FD_ADVISE ((__wasi_rights_t)(1 << 7))
+
+/**
+ * The right to invoke `fd_allocate`.
+ */
+#define __WASI_RIGHTS_FD_ALLOCATE ((__wasi_rights_t)(1 << 8))
+
+/**
+ * The right to invoke `path_create_directory`.
+ */
+#define __WASI_RIGHTS_PATH_CREATE_DIRECTORY ((__wasi_rights_t)(1 << 9))
+
+/**
+ * If `path_open` is set, the right to invoke `path_open` with `oflags::creat`.
+ */
+#define __WASI_RIGHTS_PATH_CREATE_FILE ((__wasi_rights_t)(1 << 10))
+
+/**
+ * The right to invoke `path_link` with the file descriptor as the
+ * source directory.
+ */
+#define __WASI_RIGHTS_PATH_LINK_SOURCE ((__wasi_rights_t)(1 << 11))
+
+/**
+ * The right to invoke `path_link` with the file descriptor as the
+ * target directory.
+ */
+#define __WASI_RIGHTS_PATH_LINK_TARGET ((__wasi_rights_t)(1 << 12))
+
+/**
+ * The right to invoke `path_open`.
+ */
+#define __WASI_RIGHTS_PATH_OPEN ((__wasi_rights_t)(1 << 13))
+
+/**
+ * The right to invoke `fd_readdir`.
+ */
+#define __WASI_RIGHTS_FD_READDIR ((__wasi_rights_t)(1 << 14))
+
+/**
+ * The right to invoke `path_readlink`.
+ */
+#define __WASI_RIGHTS_PATH_READLINK ((__wasi_rights_t)(1 << 15))
+
+/**
+ * The right to invoke `path_rename` with the file descriptor as the source directory.
+ */
+#define __WASI_RIGHTS_PATH_RENAME_SOURCE ((__wasi_rights_t)(1 << 16))
+
+/**
+ * The right to invoke `path_rename` with the file descriptor as the target directory.
+ */
+#define __WASI_RIGHTS_PATH_RENAME_TARGET ((__wasi_rights_t)(1 << 17))
+
+/**
+ * The right to invoke `path_filestat_get`.
+ */
+#define __WASI_RIGHTS_PATH_FILESTAT_GET ((__wasi_rights_t)(1 << 18))
+
+/**
+ * The right to change a file's size (there is no `path_filestat_set_size`).
+ * If `path_open` is set, includes the right to invoke `path_open` with `oflags::trunc`.
+ */
+#define __WASI_RIGHTS_PATH_FILESTAT_SET_SIZE ((__wasi_rights_t)(1 << 19))
+
+/**
+ * The right to invoke `path_filestat_set_times`.
+ */
+#define __WASI_RIGHTS_PATH_FILESTAT_SET_TIMES ((__wasi_rights_t)(1 << 20))
+
+/**
+ * The right to invoke `fd_filestat_get`.
+ */
+#define __WASI_RIGHTS_FD_FILESTAT_GET ((__wasi_rights_t)(1 << 21))
+
+/**
+ * The right to invoke `fd_filestat_set_size`.
+ */
+#define __WASI_RIGHTS_FD_FILESTAT_SET_SIZE ((__wasi_rights_t)(1 << 22))
+
+/**
+ * The right to invoke `fd_filestat_set_times`.
+ */
+#define __WASI_RIGHTS_FD_FILESTAT_SET_TIMES ((__wasi_rights_t)(1 << 23))
+
+/**
+ * The right to invoke `path_symlink`.
+ */
+#define __WASI_RIGHTS_PATH_SYMLINK ((__wasi_rights_t)(1 << 24))
+
+/**
+ * The right to invoke `path_remove_directory`.
+ */
+#define __WASI_RIGHTS_PATH_REMOVE_DIRECTORY ((__wasi_rights_t)(1 << 25))
+
+/**
+ * The right to invoke `path_unlink_file`.
+ */
+#define __WASI_RIGHTS_PATH_UNLINK_FILE ((__wasi_rights_t)(1 << 26))
+
+/**
+ * If `rights::fd_read` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_read`.
+ * If `rights::fd_write` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_write`.
+ */
+#define __WASI_RIGHTS_POLL_FD_READWRITE ((__wasi_rights_t)(1 << 27))
+
+/**
+ * The right to invoke `sock_shutdown`.
+ */
+#define __WASI_RIGHTS_SOCK_SHUTDOWN ((__wasi_rights_t)(1 << 28))
+
+/**
+ * The right to invoke `sock_accept`.
+ */
+#define __WASI_RIGHTS_SOCK_ACCEPT ((__wasi_rights_t)(1 << 29))
+
+/**
+ * A file descriptor handle.
+ */
+typedef int __wasi_fd_t;
+
+_Static_assert(sizeof(__wasi_fd_t) == 4, "witx calculated size");
+_Static_assert(_Alignof(__wasi_fd_t) == 4, "witx calculated align");
+
+/**
+ * A region of memory for scatter/gather reads.
+ */
+typedef struct __wasi_iovec_t {
+    /**
+     * The address of the buffer to be filled.
+     */
+    uint8_t * buf;
+
+    /**
+     * The length of the buffer to be filled.
+     */
+    __wasi_size_t buf_len;
+
+} __wasi_iovec_t;
+
+_Static_assert(sizeof(__wasi_iovec_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_iovec_t) == 4, "witx calculated align");
+_Static_assert(offsetof(__wasi_iovec_t, buf) == 0, "witx calculated offset");
+_Static_assert(offsetof(__wasi_iovec_t, buf_len) == 4, "witx calculated offset");
+
+/**
+ * A region of memory for scatter/gather writes.
+ */
+typedef struct __wasi_ciovec_t {
+    /**
+     * The address of the buffer to be written.
+     */
+    const uint8_t * buf;
+
+    /**
+     * The length of the buffer to be written.
+     */
+    __wasi_size_t buf_len;
+
+} __wasi_ciovec_t;
+
+_Static_assert(sizeof(__wasi_ciovec_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_ciovec_t) == 4, "witx calculated align");
+_Static_assert(offsetof(__wasi_ciovec_t, buf) == 0, "witx calculated offset");
+_Static_assert(offsetof(__wasi_ciovec_t, buf_len) == 4, "witx calculated offset");
+
+/**
+ * Relative offset within a file.
+ */
+typedef int64_t __wasi_filedelta_t;
+
+_Static_assert(sizeof(__wasi_filedelta_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_filedelta_t) == 8, "witx calculated align");
+
+/**
+ * The position relative to which to set the offset of the file descriptor.
+ */
+typedef uint8_t __wasi_whence_t;
+
+/**
+ * Seek relative to start-of-file.
+ */
+#define __WASI_WHENCE_SET (UINT8_C(0))
+
+/**
+ * Seek relative to current position.
+ */
+#define __WASI_WHENCE_CUR (UINT8_C(1))
+
+/**
+ * Seek relative to end-of-file.
+ */
+#define __WASI_WHENCE_END (UINT8_C(2))
+
+_Static_assert(sizeof(__wasi_whence_t) == 1, "witx calculated size");
+_Static_assert(_Alignof(__wasi_whence_t) == 1, "witx calculated align");
+
+/**
+ * A reference to the offset of a directory entry.
+ * 
+ * The value 0 signifies the start of the directory.
+ */
+typedef uint64_t __wasi_dircookie_t;
+
+_Static_assert(sizeof(__wasi_dircookie_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_dircookie_t) == 8, "witx calculated align");
+
+/**
+ * The type for the `dirent::d_namlen` field of `dirent` struct.
+ */
+typedef uint32_t __wasi_dirnamlen_t;
+
+_Static_assert(sizeof(__wasi_dirnamlen_t) == 4, "witx calculated size");
+_Static_assert(_Alignof(__wasi_dirnamlen_t) == 4, "witx calculated align");
+
+/**
+ * File serial number that is unique within its file system.
+ */
+typedef uint64_t __wasi_inode_t;
+
+_Static_assert(sizeof(__wasi_inode_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_inode_t) == 8, "witx calculated align");
+
+/**
+ * The type of a file descriptor or file.
+ */
+typedef uint8_t __wasi_filetype_t;
+
+/**
+ * The type of the file descriptor or file is unknown or is different from any of the other types specified.
+ */
+#define __WASI_FILETYPE_UNKNOWN (UINT8_C(0))
+
+/**
+ * The file descriptor or file refers to a block device inode.
+ */
+#define __WASI_FILETYPE_BLOCK_DEVICE (UINT8_C(1))
+
+/**
+ * The file descriptor or file refers to a character device inode.
+ */
+#define __WASI_FILETYPE_CHARACTER_DEVICE (UINT8_C(2))
+
+/**
+ * The file descriptor or file refers to a directory inode.
+ */
+#define __WASI_FILETYPE_DIRECTORY (UINT8_C(3))
+
+/**
+ * The file descriptor or file refers to a regular file inode.
+ */
+#define __WASI_FILETYPE_REGULAR_FILE (UINT8_C(4))
+
+/**
+ * The file descriptor or file refers to a datagram socket.
+ */
+#define __WASI_FILETYPE_SOCKET_DGRAM (UINT8_C(5))
+
+/**
+ * The file descriptor or file refers to a byte-stream socket.
+ */
+#define __WASI_FILETYPE_SOCKET_STREAM (UINT8_C(6))
+
+/**
+ * The file refers to a symbolic link inode.
+ */
+#define __WASI_FILETYPE_SYMBOLIC_LINK (UINT8_C(7))
+
+_Static_assert(sizeof(__wasi_filetype_t) == 1, "witx calculated size");
+_Static_assert(_Alignof(__wasi_filetype_t) == 1, "witx calculated align");
+
+/**
+ * A directory entry.
+ */
+typedef struct __wasi_dirent_t {
+    /**
+     * The offset of the next directory entry stored in this directory.
+     */
+    __wasi_dircookie_t d_next;
+
+    /**
+     * The serial number of the file referred to by this directory entry.
+     */
+    __wasi_inode_t d_ino;
+
+    /**
+     * The length of the name of the directory entry.
+     */
+    __wasi_dirnamlen_t d_namlen;
+
+    /**
+     * The type of the file referred to by this directory entry.
+     */
+    __wasi_filetype_t d_type;
+
+} __wasi_dirent_t;
+
+_Static_assert(sizeof(__wasi_dirent_t) == 24, "witx calculated size");
+_Static_assert(_Alignof(__wasi_dirent_t) == 8, "witx calculated align");
+_Static_assert(offsetof(__wasi_dirent_t, d_next) == 0, "witx calculated offset");
+_Static_assert(offsetof(__wasi_dirent_t, d_ino) == 8, "witx calculated offset");
+_Static_assert(offsetof(__wasi_dirent_t, d_namlen) == 16, "witx calculated offset");
+_Static_assert(offsetof(__wasi_dirent_t, d_type) == 20, "witx calculated offset");
+
+/**
+ * File or memory access pattern advisory information.
+ */
+typedef uint8_t __wasi_advice_t;
+
+/**
+ * The application has no advice to give on its behavior with respect to the specified data.
+ */
+#define __WASI_ADVICE_NORMAL (UINT8_C(0))
+
+/**
+ * The application expects to access the specified data sequentially from lower offsets to higher offsets.
+ */
+#define __WASI_ADVICE_SEQUENTIAL (UINT8_C(1))
+
+/**
+ * The application expects to access the specified data in a random order.
+ */
+#define __WASI_ADVICE_RANDOM (UINT8_C(2))
+
+/**
+ * The application expects to access the specified data in the near future.
+ */
+#define __WASI_ADVICE_WILLNEED (UINT8_C(3))
+
+/**
+ * The application expects that it will not access the specified data in the near future.
+ */
+#define __WASI_ADVICE_DONTNEED (UINT8_C(4))
+
+/**
+ * The application expects to access the specified data once and then not reuse it thereafter.
+ */
+#define __WASI_ADVICE_NOREUSE (UINT8_C(5))
+
+_Static_assert(sizeof(__wasi_advice_t) == 1, "witx calculated size");
+_Static_assert(_Alignof(__wasi_advice_t) == 1, "witx calculated align");
+
+/**
+ * File descriptor flags.
+ */
+typedef uint16_t __wasi_fdflags_t;
+
+/**
+ * Append mode: Data written to the file is always appended to the file's end.
+ */
+#define __WASI_FDFLAGS_APPEND ((__wasi_fdflags_t)(1 << 0))
+
+/**
+ * Write according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized.
+ */
+#define __WASI_FDFLAGS_DSYNC ((__wasi_fdflags_t)(1 << 1))
+
+/**
+ * Non-blocking mode.
+ */
+#define __WASI_FDFLAGS_NONBLOCK ((__wasi_fdflags_t)(1 << 2))
+
+/**
+ * Synchronized read I/O operations.
+ */
+#define __WASI_FDFLAGS_RSYNC ((__wasi_fdflags_t)(1 << 3))
+
+/**
+ * Write according to synchronized I/O file integrity completion. In
+ * addition to synchronizing the data stored in the file, the implementation
+ * may also synchronously update the file's metadata.
+ */
+#define __WASI_FDFLAGS_SYNC ((__wasi_fdflags_t)(1 << 4))
+
+/**
+ * File descriptor attributes.
+ */
+typedef struct __wasi_fdstat_t {
+    /**
+     * File type.
+     */
+    __wasi_filetype_t fs_filetype;
+
+    /**
+     * File descriptor flags.
+     */
+    __wasi_fdflags_t fs_flags;
+
+    /**
+     * Rights that apply to this file descriptor.
+     */
+    __wasi_rights_t fs_rights_base;
+
+    /**
+     * Maximum set of rights that may be installed on new file descriptors that
+     * are created through this file descriptor, e.g., through `path_open`.
+     */
+    __wasi_rights_t fs_rights_inheriting;
+
+} __wasi_fdstat_t;
+
+_Static_assert(sizeof(__wasi_fdstat_t) == 24, "witx calculated size");
+_Static_assert(_Alignof(__wasi_fdstat_t) == 8, "witx calculated align");
+_Static_assert(offsetof(__wasi_fdstat_t, fs_filetype) == 0, "witx calculated offset");
+_Static_assert(offsetof(__wasi_fdstat_t, fs_flags) == 2, "witx calculated offset");
+_Static_assert(offsetof(__wasi_fdstat_t, fs_rights_base) == 8, "witx calculated offset");
+_Static_assert(offsetof(__wasi_fdstat_t, fs_rights_inheriting) == 16, "witx calculated offset");
+
+/**
+ * Identifier for a device containing a file system. Can be used in combination
+ * with `inode` to uniquely identify a file or directory in the filesystem.
+ */
+typedef uint64_t __wasi_device_t;
+
+_Static_assert(sizeof(__wasi_device_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_device_t) == 8, "witx calculated align");
+
+/**
+ * Which file time attributes to adjust.
+ */
+typedef uint16_t __wasi_fstflags_t;
+
+/**
+ * Adjust the last data access timestamp to the value stored in `filestat::atim`.
+ */
+#define __WASI_FSTFLAGS_ATIM ((__wasi_fstflags_t)(1 << 0))
+
+/**
+ * Adjust the last data access timestamp to the time of clock `clockid::realtime`.
+ */
+#define __WASI_FSTFLAGS_ATIM_NOW ((__wasi_fstflags_t)(1 << 1))
+
+/**
+ * Adjust the last data modification timestamp to the value stored in `filestat::mtim`.
+ */
+#define __WASI_FSTFLAGS_MTIM ((__wasi_fstflags_t)(1 << 2))
+
+/**
+ * Adjust the last data modification timestamp to the time of clock `clockid::realtime`.
+ */
+#define __WASI_FSTFLAGS_MTIM_NOW ((__wasi_fstflags_t)(1 << 3))
+
+/**
+ * Flags determining the method of how paths are resolved.
+ */
+typedef uint32_t __wasi_lookupflags_t;
+
+/**
+ * As long as the resolved path corresponds to a symbolic link, it is expanded.
+ */
+#define __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW ((__wasi_lookupflags_t)(1 << 0))
+
+/**
+ * Open flags used by `path_open`.
+ */
+typedef uint16_t __wasi_oflags_t;
+
+/**
+ * Create file if it does not exist.
+ */
+#define __WASI_OFLAGS_CREAT ((__wasi_oflags_t)(1 << 0))
+
+/**
+ * Fail if not a directory.
+ */
+#define __WASI_OFLAGS_DIRECTORY ((__wasi_oflags_t)(1 << 1))
+
+/**
+ * Fail if file already exists.
+ */
+#define __WASI_OFLAGS_EXCL ((__wasi_oflags_t)(1 << 2))
+
+/**
+ * Truncate file to size 0.
+ */
+#define __WASI_OFLAGS_TRUNC ((__wasi_oflags_t)(1 << 3))
+
+/**
+ * Number of hard links to an inode.
+ */
+typedef uint64_t __wasi_linkcount_t;
+
+_Static_assert(sizeof(__wasi_linkcount_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_linkcount_t) == 8, "witx calculated align");
+
+/**
+ * File attributes.
+ */
+typedef struct __wasi_filestat_t {
+    /**
+     * Device ID of device containing the file.
+     */
+    __wasi_device_t dev;
+
+    /**
+     * File serial number.
+     */
+    __wasi_inode_t ino;
+
+    /**
+     * File type.
+     */
+    __wasi_filetype_t filetype;
+
+    /**
+     * Number of hard links to the file.
+     */
+    __wasi_linkcount_t nlink;
+
+    /**
+     * For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link.
+     */
+    __wasi_filesize_t size;
+
+    /**
+     * Last data access timestamp.
+     */
+    __wasi_timestamp_t atim;
+
+    /**
+     * Last data modification timestamp.
+     */
+    __wasi_timestamp_t mtim;
+
+    /**
+     * Last file status change timestamp.
+     */
+    __wasi_timestamp_t ctim;
+
+} __wasi_filestat_t;
+
+_Static_assert(sizeof(__wasi_filestat_t) == 64, "witx calculated size");
+_Static_assert(_Alignof(__wasi_filestat_t) == 8, "witx calculated align");
+_Static_assert(offsetof(__wasi_filestat_t, dev) == 0, "witx calculated offset");
+_Static_assert(offsetof(__wasi_filestat_t, ino) == 8, "witx calculated offset");
+_Static_assert(offsetof(__wasi_filestat_t, filetype) == 16, "witx calculated offset");
+_Static_assert(offsetof(__wasi_filestat_t, nlink) == 24, "witx calculated offset");
+_Static_assert(offsetof(__wasi_filestat_t, size) == 32, "witx calculated offset");
+_Static_assert(offsetof(__wasi_filestat_t, atim) == 40, "witx calculated offset");
+_Static_assert(offsetof(__wasi_filestat_t, mtim) == 48, "witx calculated offset");
+_Static_assert(offsetof(__wasi_filestat_t, ctim) == 56, "witx calculated offset");
+
+/**
+ * User-provided value that may be attached to objects that is retained when
+ * extracted from the implementation.
+ */
+typedef uint64_t __wasi_userdata_t;
+
+_Static_assert(sizeof(__wasi_userdata_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_userdata_t) == 8, "witx calculated align");
+
+/**
+ * Type of a subscription to an event or its occurrence.
+ */
+typedef uint8_t __wasi_eventtype_t;
+
+/**
+ * The time value of clock `subscription_clock::id` has
+ * reached timestamp `subscription_clock::timeout`.
+ */
+#define __WASI_EVENTTYPE_CLOCK (UINT8_C(0))
+
+/**
+ * File descriptor `subscription_fd_readwrite::file_descriptor` has data
+ * available for reading. This event always triggers for regular files.
+ */
+#define __WASI_EVENTTYPE_FD_READ (UINT8_C(1))
+
+/**
+ * File descriptor `subscription_fd_readwrite::file_descriptor` has capacity
+ * available for writing. This event always triggers for regular files.
+ */
+#define __WASI_EVENTTYPE_FD_WRITE (UINT8_C(2))
+
+_Static_assert(sizeof(__wasi_eventtype_t) == 1, "witx calculated size");
+_Static_assert(_Alignof(__wasi_eventtype_t) == 1, "witx calculated align");
+
+/**
+ * The state of the file descriptor subscribed to with
+ * `eventtype::fd_read` or `eventtype::fd_write`.
+ */
+typedef uint16_t __wasi_eventrwflags_t;
+
+/**
+ * The peer of this socket has closed or disconnected.
+ */
+#define __WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP ((__wasi_eventrwflags_t)(1 << 0))
+
+/**
+ * The contents of an `event` when type is `eventtype::fd_read` or
+ * `eventtype::fd_write`.
+ */
+typedef struct __wasi_event_fd_readwrite_t {
+    /**
+     * The number of bytes available for reading or writing.
+     */
+    __wasi_filesize_t nbytes;
+
+    /**
+     * The state of the file descriptor.
+     */
+    __wasi_eventrwflags_t flags;
+
+} __wasi_event_fd_readwrite_t;
+
+_Static_assert(sizeof(__wasi_event_fd_readwrite_t) == 16, "witx calculated size");
+_Static_assert(_Alignof(__wasi_event_fd_readwrite_t) == 8, "witx calculated align");
+_Static_assert(offsetof(__wasi_event_fd_readwrite_t, nbytes) == 0, "witx calculated offset");
+_Static_assert(offsetof(__wasi_event_fd_readwrite_t, flags) == 8, "witx calculated offset");
+
+/**
+ * An event that occurred.
+ */
+typedef struct __wasi_event_t {
+    /**
+     * User-provided value that got attached to `subscription::userdata`.
+     */
+    __wasi_userdata_t userdata;
+
+    /**
+     * If non-zero, an error that occurred while processing the subscription request.
+     */
+    __wasi_errno_t error;
+
+    /**
+     * The type of event that occured
+     */
+    __wasi_eventtype_t type;
+
+    /**
+     * The contents of the event, if it is an `eventtype::fd_read` or
+     * `eventtype::fd_write`. `eventtype::clock` events ignore this field.
+     */
+    __wasi_event_fd_readwrite_t fd_readwrite;
+
+} __wasi_event_t;
+
+_Static_assert(sizeof(__wasi_event_t) == 32, "witx calculated size");
+_Static_assert(_Alignof(__wasi_event_t) == 8, "witx calculated align");
+_Static_assert(offsetof(__wasi_event_t, userdata) == 0, "witx calculated offset");
+_Static_assert(offsetof(__wasi_event_t, error) == 8, "witx calculated offset");
+_Static_assert(offsetof(__wasi_event_t, type) == 10, "witx calculated offset");
+_Static_assert(offsetof(__wasi_event_t, fd_readwrite) == 16, "witx calculated offset");
+
+/**
+ * Flags determining how to interpret the timestamp provided in
+ * `subscription_clock::timeout`.
+ */
+typedef uint16_t __wasi_subclockflags_t;
+
+/**
+ * If set, treat the timestamp provided in
+ * `subscription_clock::timeout` as an absolute timestamp of clock
+ * `subscription_clock::id`. If clear, treat the timestamp
+ * provided in `subscription_clock::timeout` relative to the
+ * current time value of clock `subscription_clock::id`.
+ */
+#define __WASI_SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME ((__wasi_subclockflags_t)(1 << 0))
+
+/**
+ * The contents of a `subscription` when type is `eventtype::clock`.
+ */
+typedef struct __wasi_subscription_clock_t {
+    /**
+     * The clock against which to compare the timestamp.
+     */
+    __wasi_clockid_t id;
+
+    /**
+     * The absolute or relative timestamp.
+     */
+    __wasi_timestamp_t timeout;
+
+    /**
+     * The amount of time that the implementation may wait additionally
+     * to coalesce with other events.
+     */
+    __wasi_timestamp_t precision;
+
+    /**
+     * Flags specifying whether the timeout is absolute or relative
+     */
+    __wasi_subclockflags_t flags;
+
+} __wasi_subscription_clock_t;
+
+_Static_assert(sizeof(__wasi_subscription_clock_t) == 32, "witx calculated size");
+_Static_assert(_Alignof(__wasi_subscription_clock_t) == 8, "witx calculated align");
+_Static_assert(offsetof(__wasi_subscription_clock_t, id) == 0, "witx calculated offset");
+_Static_assert(offsetof(__wasi_subscription_clock_t, timeout) == 8, "witx calculated offset");
+_Static_assert(offsetof(__wasi_subscription_clock_t, precision) == 16, "witx calculated offset");
+_Static_assert(offsetof(__wasi_subscription_clock_t, flags) == 24, "witx calculated offset");
+
+/**
+ * The contents of a `subscription` when type is type is
+ * `eventtype::fd_read` or `eventtype::fd_write`.
+ */
+typedef struct __wasi_subscription_fd_readwrite_t {
+    /**
+     * The file descriptor on which to wait for it to become ready for reading or writing.
+     */
+    __wasi_fd_t file_descriptor;
+
+} __wasi_subscription_fd_readwrite_t;
+
+_Static_assert(sizeof(__wasi_subscription_fd_readwrite_t) == 4, "witx calculated size");
+_Static_assert(_Alignof(__wasi_subscription_fd_readwrite_t) == 4, "witx calculated align");
+_Static_assert(offsetof(__wasi_subscription_fd_readwrite_t, file_descriptor) == 0, "witx calculated offset");
+
+/**
+ * The contents of a `subscription`.
+ */
+typedef union __wasi_subscription_u_u_t {
+    __wasi_subscription_clock_t clock;
+    __wasi_subscription_fd_readwrite_t fd_read;
+    __wasi_subscription_fd_readwrite_t fd_write;
+} __wasi_subscription_u_u_t;
+typedef struct __wasi_subscription_u_t {
+    uint8_t tag;
+    __wasi_subscription_u_u_t u;
+} __wasi_subscription_u_t;
+
+_Static_assert(sizeof(__wasi_subscription_u_t) == 40, "witx calculated size");
+_Static_assert(_Alignof(__wasi_subscription_u_t) == 8, "witx calculated align");
+
+/**
+ * Subscription to an event.
+ */
+typedef struct __wasi_subscription_t {
+    /**
+     * User-provided value that is attached to the subscription in the
+     * implementation and returned through `event::userdata`.
+     */
+    __wasi_userdata_t userdata;
+
+    /**
+     * The type of the event to which to subscribe, and its contents
+     */
+    __wasi_subscription_u_t u;
+
+} __wasi_subscription_t;
+
+_Static_assert(sizeof(__wasi_subscription_t) == 48, "witx calculated size");
+_Static_assert(_Alignof(__wasi_subscription_t) == 8, "witx calculated align");
+_Static_assert(offsetof(__wasi_subscription_t, userdata) == 0, "witx calculated offset");
+_Static_assert(offsetof(__wasi_subscription_t, u) == 8, "witx calculated offset");
+
+/**
+ * Exit code generated by a process when exiting.
+ */
+typedef uint32_t __wasi_exitcode_t;
+
+_Static_assert(sizeof(__wasi_exitcode_t) == 4, "witx calculated size");
+_Static_assert(_Alignof(__wasi_exitcode_t) == 4, "witx calculated align");
+
+/**
+ * Flags provided to `sock_recv`.
+ */
+typedef uint16_t __wasi_riflags_t;
+
+/**
+ * Returns the message without removing it from the socket's receive queue.
+ */
+#define __WASI_RIFLAGS_RECV_PEEK ((__wasi_riflags_t)(1 << 0))
+
+/**
+ * On byte-stream sockets, block until the full amount of data can be returned.
+ */
+#define __WASI_RIFLAGS_RECV_WAITALL ((__wasi_riflags_t)(1 << 1))
+
+/**
+ * Flags returned by `sock_recv`.
+ */
+typedef uint16_t __wasi_roflags_t;
+
+/**
+ * Returned by `sock_recv`: Message data has been truncated.
+ */
+#define __WASI_ROFLAGS_RECV_DATA_TRUNCATED ((__wasi_roflags_t)(1 << 0))
+
+/**
+ * Flags provided to `sock_send`. As there are currently no flags
+ * defined, it must be set to zero.
+ */
+typedef uint16_t __wasi_siflags_t;
+
+_Static_assert(sizeof(__wasi_siflags_t) == 2, "witx calculated size");
+_Static_assert(_Alignof(__wasi_siflags_t) == 2, "witx calculated align");
+
+/**
+ * Which channels on a socket to shut down.
+ */
+typedef uint8_t __wasi_sdflags_t;
+
+/**
+ * Disables further receive operations.
+ */
+#define __WASI_SDFLAGS_RD ((__wasi_sdflags_t)(1 << 0))
+
+/**
+ * Disables further send operations.
+ */
+#define __WASI_SDFLAGS_WR ((__wasi_sdflags_t)(1 << 1))
+
+/**
+ * Identifiers for preopened capabilities.
+ */
+typedef uint8_t __wasi_preopentype_t;
+
+/**
+ * A pre-opened directory.
+ */
+#define __WASI_PREOPENTYPE_DIR (UINT8_C(0))
+
+_Static_assert(sizeof(__wasi_preopentype_t) == 1, "witx calculated size");
+_Static_assert(_Alignof(__wasi_preopentype_t) == 1, "witx calculated align");
+
+/**
+ * The contents of a $prestat when type is `preopentype::dir`.
+ */
+typedef struct __wasi_prestat_dir_t {
+    /**
+     * The length of the directory name for use with `fd_prestat_dir_name`.
+     */
+    __wasi_size_t pr_name_len;
+
+} __wasi_prestat_dir_t;
+
+_Static_assert(sizeof(__wasi_prestat_dir_t) == 4, "witx calculated size");
+_Static_assert(_Alignof(__wasi_prestat_dir_t) == 4, "witx calculated align");
+_Static_assert(offsetof(__wasi_prestat_dir_t, pr_name_len) == 0, "witx calculated offset");
+
+/**
+ * Information about a pre-opened capability.
+ */
+typedef union __wasi_prestat_u_t {
+    __wasi_prestat_dir_t dir;
+} __wasi_prestat_u_t;
+typedef struct __wasi_prestat_t {
+    uint8_t tag;
+    __wasi_prestat_u_t u;
+} __wasi_prestat_t;
+
+_Static_assert(sizeof(__wasi_prestat_t) == 8, "witx calculated size");
+_Static_assert(_Alignof(__wasi_prestat_t) == 4, "witx calculated align");
+
+/**
+ * @defgroup wasi_snapshot_preview1
+ * @{
+ */
+
+/**
+ * Read command-line argument data.
+ * The size of the array should match that returned by `args_sizes_get`.
+ * Each argument is expected to be `\0` terminated.
+ */
+__wasi_errno_t __wasi_args_get(
+    uint8_t * * argv,
+    uint8_t * argv_buf
+) __attribute__((__warn_unused_result__));
+/**
+ * Return command-line argument data sizes.
+ * @return
+ * Returns the number of arguments and the size of the argument string
+ * data, or an error.
+ */
+__wasi_errno_t __wasi_args_sizes_get(
+    __wasi_size_t *retptr0,
+    __wasi_size_t *retptr1
+) __attribute__((__warn_unused_result__));
+/**
+ * Read environment variable data.
+ * The sizes of the buffers should match that returned by `environ_sizes_get`.
+ * Key/value pairs are expected to be joined with `=`s, and terminated with `\0`s.
+ */
+__wasi_errno_t __wasi_environ_get(
+    uint8_t * * environ,
+    uint8_t * environ_buf
+) __attribute__((__warn_unused_result__));
+/**
+ * Return environment variable data sizes.
+ * @return
+ * Returns the number of environment variable arguments and the size of the
+ * environment variable data.
+ */
+__wasi_errno_t __wasi_environ_sizes_get(
+    __wasi_size_t *retptr0,
+    __wasi_size_t *retptr1
+) __attribute__((__warn_unused_result__));
+/**
+ * Return the resolution of a clock.
+ * Implementations are required to provide a non-zero value for supported clocks. For unsupported clocks,
+ * return `errno::inval`.
+ * Note: This is similar to `clock_getres` in POSIX.
+ * @return
+ * The resolution of the clock, or an error if one happened.
+ */
+__wasi_errno_t __wasi_clock_res_get(
+    /**
+     * The clock for which to return the resolution.
+     */
+    __wasi_clockid_t id,
+    __wasi_timestamp_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Return the time value of a clock.
+ * Note: This is similar to `clock_gettime` in POSIX.
+ * @return
+ * The time value of the clock.
+ */
+__wasi_errno_t __wasi_clock_time_get(
+    /**
+     * The clock for which to return the time.
+     */
+    __wasi_clockid_t id,
+    /**
+     * The maximum lag (exclusive) that the returned time value may have, compared to its actual value.
+     */
+    __wasi_timestamp_t precision,
+    __wasi_timestamp_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Provide file advisory information on a file descriptor.
+ * Note: This is similar to `posix_fadvise` in POSIX.
+ */
+__wasi_errno_t __wasi_fd_advise(
+    __wasi_fd_t fd,
+    /**
+     * The offset within the file to which the advisory applies.
+     */
+    __wasi_filesize_t offset,
+    /**
+     * The length of the region to which the advisory applies.
+     */
+    __wasi_filesize_t len,
+    /**
+     * The advice.
+     */
+    __wasi_advice_t advice
+) __attribute__((__warn_unused_result__));
+/**
+ * Force the allocation of space in a file.
+ * Note: This is similar to `posix_fallocate` in POSIX.
+ */
+__wasi_errno_t __wasi_fd_allocate(
+    __wasi_fd_t fd,
+    /**
+     * The offset at which to start the allocation.
+     */
+    __wasi_filesize_t offset,
+    /**
+     * The length of the area that is allocated.
+     */
+    __wasi_filesize_t len
+) __attribute__((__warn_unused_result__));
+/**
+ * Close a file descriptor.
+ * Note: This is similar to `close` in POSIX.
+ */
+__wasi_errno_t __wasi_fd_close(
+    __wasi_fd_t fd
+) __attribute__((__warn_unused_result__));
+/**
+ * Synchronize the data of a file to disk.
+ * Note: This is similar to `fdatasync` in POSIX.
+ */
+__wasi_errno_t __wasi_fd_datasync(
+    __wasi_fd_t fd
+) __attribute__((__warn_unused_result__));
+/**
+ * Get the attributes of a file descriptor.
+ * Note: This returns similar flags to `fsync(fd, F_GETFL)` in POSIX, as well as additional fields.
+ * @return
+ * The buffer where the file descriptor's attributes are stored.
+ */
+__wasi_errno_t __wasi_fd_fdstat_get(
+    __wasi_fd_t fd,
+    __wasi_fdstat_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Adjust the flags associated with a file descriptor.
+ * Note: This is similar to `fcntl(fd, F_SETFL, flags)` in POSIX.
+ */
+__wasi_errno_t __wasi_fd_fdstat_set_flags(
+    __wasi_fd_t fd,
+    /**
+     * The desired values of the file descriptor flags.
+     */
+    __wasi_fdflags_t flags
+) __attribute__((__warn_unused_result__));
+/**
+ * Adjust the rights associated with a file descriptor.
+ * This can only be used to remove rights, and returns `errno::notcapable` if called in a way that would attempt to add rights
+ */
+__wasi_errno_t __wasi_fd_fdstat_set_rights(
+    __wasi_fd_t fd,
+    /**
+     * The desired rights of the file descriptor.
+     */
+    __wasi_rights_t fs_rights_base,
+    __wasi_rights_t fs_rights_inheriting
+) __attribute__((__warn_unused_result__));
+/**
+ * Return the attributes of an open file.
+ * @return
+ * The buffer where the file's attributes are stored.
+ */
+__wasi_errno_t __wasi_fd_filestat_get(
+    __wasi_fd_t fd,
+    __wasi_filestat_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.
+ * Note: This is similar to `ftruncate` in POSIX.
+ */
+__wasi_errno_t __wasi_fd_filestat_set_size(
+    __wasi_fd_t fd,
+    /**
+     * The desired file size.
+     */
+    __wasi_filesize_t size
+) __attribute__((__warn_unused_result__));
+/**
+ * Adjust the timestamps of an open file or directory.
+ * Note: This is similar to `futimens` in POSIX.
+ */
+__wasi_errno_t __wasi_fd_filestat_set_times(
+    __wasi_fd_t fd,
+    /**
+     * The desired values of the data access timestamp.
+     */
+    __wasi_timestamp_t atim,
+    /**
+     * The desired values of the data modification timestamp.
+     */
+    __wasi_timestamp_t mtim,
+    /**
+     * A bitmask indicating which timestamps to adjust.
+     */
+    __wasi_fstflags_t fst_flags
+) __attribute__((__warn_unused_result__));
+/**
+ * Read from a file descriptor, without using and updating the file descriptor's offset.
+ * Note: This is similar to `preadv` in POSIX.
+ * @return
+ * The number of bytes read.
+ */
+__wasi_errno_t __wasi_fd_pread(
+    __wasi_fd_t fd,
+    /**
+     * List of scatter/gather vectors in which to store data.
+     */
+    const __wasi_iovec_t *iovs,
+    /**
+     * The length of the array pointed to by `iovs`.
+     */
+    size_t iovs_len,
+    /**
+     * The offset within the file at which to read.
+     */
+    __wasi_filesize_t offset,
+    __wasi_size_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Return a description of the given preopened file descriptor.
+ * @return
+ * The buffer where the description is stored.
+ */
+__wasi_errno_t __wasi_fd_prestat_get(
+    __wasi_fd_t fd,
+    __wasi_prestat_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Return a description of the given preopened file descriptor.
+ */
+__wasi_errno_t __wasi_fd_prestat_dir_name(
+    __wasi_fd_t fd,
+    /**
+     * A buffer into which to write the preopened directory name.
+     */
+    uint8_t * path,
+    __wasi_size_t path_len
+) __attribute__((__warn_unused_result__));
+/**
+ * Write to a file descriptor, without using and updating the file descriptor's offset.
+ * Note: This is similar to `pwritev` in POSIX.
+ * @return
+ * The number of bytes written.
+ */
+__wasi_errno_t __wasi_fd_pwrite(
+    __wasi_fd_t fd,
+    /**
+     * List of scatter/gather vectors from which to retrieve data.
+     */
+    const __wasi_ciovec_t *iovs,
+    /**
+     * The length of the array pointed to by `iovs`.
+     */
+    size_t iovs_len,
+    /**
+     * The offset within the file at which to write.
+     */
+    __wasi_filesize_t offset,
+    __wasi_size_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Read from a file descriptor.
+ * Note: This is similar to `readv` in POSIX.
+ * @return
+ * The number of bytes read.
+ */
+__wasi_errno_t __wasi_fd_read(
+    __wasi_fd_t fd,
+    /**
+     * List of scatter/gather vectors to which to store data.
+     */
+    const __wasi_iovec_t *iovs,
+    /**
+     * The length of the array pointed to by `iovs`.
+     */
+    size_t iovs_len,
+    __wasi_size_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Read directory entries from a directory.
+ * When successful, the contents of the output buffer consist of a sequence of
+ * directory entries. Each directory entry consists of a `dirent` object,
+ * followed by `dirent::d_namlen` bytes holding the name of the directory
+ * entry.
+ * This function fills the output buffer as much as possible, potentially
+ * truncating the last directory entry. This allows the caller to grow its
+ * read buffer size in case it's too small to fit a single large directory
+ * entry, or skip the oversized directory entry.
+ * @return
+ * The number of bytes stored in the read buffer. If less than the size of the read buffer, the end of the directory has been reached.
+ */
+__wasi_errno_t __wasi_fd_readdir(
+    __wasi_fd_t fd,
+    /**
+     * The buffer where directory entries are stored
+     */
+    uint8_t * buf,
+    __wasi_size_t buf_len,
+    /**
+     * The location within the directory to start reading
+     */
+    __wasi_dircookie_t cookie,
+    __wasi_size_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Atomically replace a file descriptor by renumbering another file descriptor.
+ * Due to the strong focus on thread safety, this environment does not provide
+ * a mechanism to duplicate or renumber a file descriptor to an arbitrary
+ * number, like `dup2()`. This would be prone to race conditions, as an actual
+ * file descriptor with the same number could be allocated by a different
+ * thread at the same time.
+ * This function provides a way to atomically renumber file descriptors, which
+ * would disappear if `dup2()` were to be removed entirely.
+ */
+__wasi_errno_t __wasi_fd_renumber(
+    __wasi_fd_t fd,
+    /**
+     * The file descriptor to overwrite.
+     */
+    __wasi_fd_t to
+) __attribute__((__warn_unused_result__));
+/**
+ * Move the offset of a file descriptor.
+ * Note: This is similar to `lseek` in POSIX.
+ * @return
+ * The new offset of the file descriptor, relative to the start of the file.
+ */
+__wasi_errno_t __wasi_fd_seek(
+    __wasi_fd_t fd,
+    /**
+     * The number of bytes to move.
+     */
+    __wasi_filedelta_t offset,
+    /**
+     * The base from which the offset is relative.
+     */
+    __wasi_whence_t whence,
+    __wasi_filesize_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Synchronize the data and metadata of a file to disk.
+ * Note: This is similar to `fsync` in POSIX.
+ */
+__wasi_errno_t __wasi_fd_sync(
+    __wasi_fd_t fd
+) __attribute__((__warn_unused_result__));
+/**
+ * Return the current offset of a file descriptor.
+ * Note: This is similar to `lseek(fd, 0, SEEK_CUR)` in POSIX.
+ * @return
+ * The current offset of the file descriptor, relative to the start of the file.
+ */
+__wasi_errno_t __wasi_fd_tell(
+    __wasi_fd_t fd,
+    __wasi_filesize_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Write to a file descriptor.
+ * Note: This is similar to `writev` in POSIX.
+ */
+__wasi_errno_t __wasi_fd_write(
+    __wasi_fd_t fd,
+    /**
+     * List of scatter/gather vectors from which to retrieve data.
+     */
+    const __wasi_ciovec_t *iovs,
+    /**
+     * The length of the array pointed to by `iovs`.
+     */
+    size_t iovs_len,
+    __wasi_size_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Create a directory.
+ * Note: This is similar to `mkdirat` in POSIX.
+ */
+__wasi_errno_t __wasi_path_create_directory(
+    __wasi_fd_t fd,
+    /**
+     * The path at which to create the directory.
+     */
+    const char *path
+) __attribute__((__warn_unused_result__));
+/**
+ * Return the attributes of a file or directory.
+ * Note: This is similar to `stat` in POSIX.
+ * @return
+ * The buffer where the file's attributes are stored.
+ */
+__wasi_errno_t __wasi_path_filestat_get(
+    __wasi_fd_t fd,
+    /**
+     * Flags determining the method of how the path is resolved.
+     */
+    __wasi_lookupflags_t flags,
+    /**
+     * The path of the file or directory to inspect.
+     */
+    const char *path,
+    __wasi_filestat_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Adjust the timestamps of a file or directory.
+ * Note: This is similar to `utimensat` in POSIX.
+ */
+__wasi_errno_t __wasi_path_filestat_set_times(
+    __wasi_fd_t fd,
+    /**
+     * Flags determining the method of how the path is resolved.
+     */
+    __wasi_lookupflags_t flags,
+    /**
+     * The path of the file or directory to operate on.
+     */
+    const char *path,
+    /**
+     * The desired values of the data access timestamp.
+     */
+    __wasi_timestamp_t atim,
+    /**
+     * The desired values of the data modification timestamp.
+     */
+    __wasi_timestamp_t mtim,
+    /**
+     * A bitmask indicating which timestamps to adjust.
+     */
+    __wasi_fstflags_t fst_flags
+) __attribute__((__warn_unused_result__));
+/**
+ * Create a hard link.
+ * Note: This is similar to `linkat` in POSIX.
+ */
+__wasi_errno_t __wasi_path_link(
+    __wasi_fd_t old_fd,
+    /**
+     * Flags determining the method of how the path is resolved.
+     */
+    __wasi_lookupflags_t old_flags,
+    /**
+     * The source path from which to link.
+     */
+    const char *old_path,
+    /**
+     * The working directory at which the resolution of the new path starts.
+     */
+    __wasi_fd_t new_fd,
+    /**
+     * The destination path at which to create the hard link.
+     */
+    const char *new_path
+) __attribute__((__warn_unused_result__));
+/**
+ * Open a file or directory.
+ * The returned file descriptor is not guaranteed to be the lowest-numbered
+ * file descriptor not currently open; it is randomized to prevent
+ * applications from depending on making assumptions about indexes, since this
+ * is error-prone in multi-threaded contexts. The returned file descriptor is
+ * guaranteed to be less than 2**31.
+ * Note: This is similar to `openat` in POSIX.
+ * @return
+ * The file descriptor of the file that has been opened.
+ */
+__wasi_errno_t __wasi_path_open(
+    __wasi_fd_t fd,
+    /**
+     * Flags determining the method of how the path is resolved.
+     */
+    __wasi_lookupflags_t dirflags,
+    /**
+     * The relative path of the file or directory to open, relative to the
+     * `path_open::fd` directory.
+     */
+    const char *path,
+    /**
+     * The method by which to open the file.
+     */
+    __wasi_oflags_t oflags,
+    /**
+     * The initial rights of the newly created file descriptor. The
+     * implementation is allowed to return a file descriptor with fewer rights
+     * than specified, if and only if those rights do not apply to the type of
+     * file being opened.
+     * The *base* rights are rights that will apply to operations using the file
+     * descriptor itself, while the *inheriting* rights are rights that apply to
+     * file descriptors derived from it.
+     */
+    __wasi_rights_t fs_rights_base,
+    __wasi_rights_t fs_rights_inheriting,
+    __wasi_fdflags_t fdflags,
+    __wasi_fd_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Read the contents of a symbolic link.
+ * Note: This is similar to `readlinkat` in POSIX.
+ * @return
+ * The number of bytes placed in the buffer.
+ */
+__wasi_errno_t __wasi_path_readlink(
+    __wasi_fd_t fd,
+    /**
+     * The path of the symbolic link from which to read.
+     */
+    const char *path,
+    /**
+     * The buffer to which to write the contents of the symbolic link.
+     */
+    uint8_t * buf,
+    __wasi_size_t buf_len,
+    __wasi_size_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Remove a directory.
+ * Return `errno::notempty` if the directory is not empty.
+ * Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+ */
+__wasi_errno_t __wasi_path_remove_directory(
+    __wasi_fd_t fd,
+    /**
+     * The path to a directory to remove.
+     */
+    const char *path
+) __attribute__((__warn_unused_result__));
+/**
+ * Rename a file or directory.
+ * Note: This is similar to `renameat` in POSIX.
+ */
+__wasi_errno_t __wasi_path_rename(
+    __wasi_fd_t fd,
+    /**
+     * The source path of the file or directory to rename.
+     */
+    const char *old_path,
+    /**
+     * The working directory at which the resolution of the new path starts.
+     */
+    __wasi_fd_t new_fd,
+    /**
+     * The destination path to which to rename the file or directory.
+     */
+    const char *new_path
+) __attribute__((__warn_unused_result__));
+/**
+ * Create a symbolic link.
+ * Note: This is similar to `symlinkat` in POSIX.
+ */
+__wasi_errno_t __wasi_path_symlink(
+    /**
+     * The contents of the symbolic link.
+     */
+    const char *old_path,
+    __wasi_fd_t fd,
+    /**
+     * The destination path at which to create the symbolic link.
+     */
+    const char *new_path
+) __attribute__((__warn_unused_result__));
+/**
+ * Unlink a file.
+ * Return `errno::isdir` if the path refers to a directory.
+ * Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+ */
+__wasi_errno_t __wasi_path_unlink_file(
+    __wasi_fd_t fd,
+    /**
+     * The path to a file to unlink.
+     */
+    const char *path
+) __attribute__((__warn_unused_result__));
+/**
+ * Concurrently poll for the occurrence of a set of events.
+ * @return
+ * The number of events stored.
+ */
+__wasi_errno_t __wasi_poll_oneoff(
+    /**
+     * The events to which to subscribe.
+     */
+    const __wasi_subscription_t * in,
+    /**
+     * The events that have occurred.
+     */
+    __wasi_event_t * out,
+    /**
+     * Both the number of subscriptions and events.
+     */
+    __wasi_size_t nsubscriptions,
+    __wasi_size_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Terminate the process normally. An exit code of 0 indicates successful
+ * termination of the program. The meanings of other values is dependent on
+ * the environment.
+ */
+_Noreturn void __wasi_proc_exit(
+    /**
+     * The exit code returned by the process.
+     */
+    __wasi_exitcode_t rval
+);
+/**
+ * Temporarily yield execution of the calling thread.
+ * Note: This is similar to `sched_yield` in POSIX.
+ */
+__wasi_errno_t __wasi_sched_yield(
+    void
+) __attribute__((__warn_unused_result__));
+/**
+ * Write high-quality random data into a buffer.
+ * This function blocks when the implementation is unable to immediately
+ * provide sufficient high-quality random data.
+ * This function may execute slowly, so when large mounts of random data are
+ * required, it's advisable to use this function to seed a pseudo-random
+ * number generator, rather than to provide the random data directly.
+ */
+__wasi_errno_t __wasi_random_get(
+    /**
+     * The buffer to fill with random data.
+     */
+    uint8_t * buf,
+    __wasi_size_t buf_len
+) __attribute__((__warn_unused_result__));
+/**
+ * Accept a new incoming connection.
+ * Note: This is similar to `accept` in POSIX.
+ * @return
+ * New socket connection
+ */
+__wasi_errno_t __wasi_sock_accept(
+    /**
+     * The listening socket.
+     */
+    __wasi_fd_t fd,
+    /**
+     * The desired values of the file descriptor flags.
+     */
+    __wasi_fdflags_t flags,
+    __wasi_fd_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Receive a message from a socket.
+ * Note: This is similar to `recv` in POSIX, though it also supports reading
+ * the data into multiple buffers in the manner of `readv`.
+ * @return
+ * Number of bytes stored in ri_data and message flags.
+ */
+__wasi_errno_t __wasi_sock_recv(
+    __wasi_fd_t fd,
+    /**
+     * List of scatter/gather vectors to which to store data.
+     */
+    const __wasi_iovec_t *ri_data,
+    /**
+     * The length of the array pointed to by `ri_data`.
+     */
+    size_t ri_data_len,
+    /**
+     * Message flags.
+     */
+    __wasi_riflags_t ri_flags,
+    __wasi_size_t *retptr0,
+    __wasi_roflags_t *retptr1
+) __attribute__((__warn_unused_result__));
+/**
+ * Send a message on a socket.
+ * Note: This is similar to `send` in POSIX, though it also supports writing
+ * the data from multiple buffers in the manner of `writev`.
+ * @return
+ * Number of bytes transmitted.
+ */
+__wasi_errno_t __wasi_sock_send(
+    __wasi_fd_t fd,
+    /**
+     * List of scatter/gather vectors to which to retrieve data
+     */
+    const __wasi_ciovec_t *si_data,
+    /**
+     * The length of the array pointed to by `si_data`.
+     */
+    size_t si_data_len,
+    /**
+     * Message flags.
+     */
+    __wasi_siflags_t si_flags,
+    __wasi_size_t *retptr0
+) __attribute__((__warn_unused_result__));
+/**
+ * Shut down socket send and receive channels.
+ * Note: This is similar to `shutdown` in POSIX.
+ */
+__wasi_errno_t __wasi_sock_shutdown(
+    __wasi_fd_t fd,
+    /**
+     * Which channels on the socket to shut down.
+     */
+    __wasi_sdflags_t how
+) __attribute__((__warn_unused_result__));
+/** @} */
+
+#ifdef _REENTRANT
+/**
+ * Request a new thread to be created by the host.
+ *
+ * The host will create a new instance of the current module sharing its
+ * memory, find an exported entry function--`wasi_thread_start`--, and call the
+ * entry function with `start_arg` in the new thread.
+ *
+ * @see https://github.com/WebAssembly/wasi-threads/#readme
+ */
+__wasi_errno_t __wasi_thread_spawn(
+    /**
+     * A pointer to an opaque struct to be passed to the module's entry
+     * function.
+     */
+    void *start_arg
+)  __attribute__((__warn_unused_result__));
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/wasi/libc-environ.h b/libc-bottom-half/headers/public/wasi/libc-environ.h
new file mode 100644
index 0000000..f84ba8e
--- /dev/null
+++ b/libc-bottom-half/headers/public/wasi/libc-environ.h
@@ -0,0 +1,36 @@
+#ifndef __wasi_libc_environ_h
+#define __wasi_libc_environ_h
+
+/// This header file is a WASI-libc-specific interface, and is not needed by
+/// most programs. Most programs should just use the standard `getenv` and
+/// related APIs, which take care of all of the details automatically.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Initialize the global environment variable state. Only needs to be
+/// called once; most users should call `__wasilibc_ensure_environ` instead.
+void __wasilibc_initialize_environ(void);
+
+/// If `__wasilibc_initialize_environ` has not yet been called, call it.
+void __wasilibc_ensure_environ(void);
+
+/// De-initialize the global environment variable state, so that subsequent
+/// calls to `__wasilibc_ensure_environ` call `__wasilibc_initialize_environ`.
+void __wasilibc_deinitialize_environ(void);
+
+/// Call `__wasilibc_initialize_environ` only if `environ` and `_environ` are
+/// referenced in the program.
+void __wasilibc_maybe_reinitialize_environ_eagerly(void);
+
+/// Return the value of the `environ` variable. Using `environ` directly
+/// requires eager initialization of the environment variables. Using this
+/// function instead of `environ` allows initialization to happen lazily.
+char **__wasilibc_get_environ(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/wasi/libc-find-relpath.h b/libc-bottom-half/headers/public/wasi/libc-find-relpath.h
new file mode 100644
index 0000000..32dbb03
--- /dev/null
+++ b/libc-bottom-half/headers/public/wasi/libc-find-relpath.h
@@ -0,0 +1,79 @@
+#ifndef __wasi_libc_find_relpath_h
+#define __wasi_libc_find_relpath_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Look up the given `path`, relative to the cwd, in the preopened directory
+ * map. If a suitable entry is found, then the file descriptor for that entry
+ * is returned. Additionally the absolute path of the directory's file
+ * descriptor is returned in `abs_prefix` and the relative portion that needs
+ * to be opened is stored in `*relative_path`.
+ *
+ * The `relative_path` argument must be a pointer to a buffer valid  for
+ * `relative_path_len` bytes, and this may be used as storage for the relative
+ * portion of the path being returned through `*relative_path`.
+ *
+ * See documentation on `__wasilibc_find_abspath` for more info about what the
+ * paths look like.
+ *
+ * Returns -1 on failure. Errno is set to either:
+ *
+ *  * ENOMEM - failed to allocate memory for internal routines.
+ *  * ENOENT - the `path` could not be found relative to any preopened dir.
+ *  * ERANGE - the `relative_path` buffer is too small to hold the relative path.
+ */
+int __wasilibc_find_relpath(const char *path,
+                            const char **__restrict__ abs_prefix,
+                            char **relative_path,
+                            size_t relative_path_len);
+
+/**
+ * Look up the given `path`, which is interpreted as absolute, in the preopened
+ * directory map. If a suitable entry is found, then the file descriptor for
+ * that entry is returned. Additionally the relative portion of the path to
+ * where the fd is opened is returned through `relative_path`, the absolute
+ * prefix which was matched is stored to `abs_prefix`, and `relative_path` may
+ * be an interior pointer to the `abspath` string.
+ *
+ * The `abs_prefix` returned string will not contain a leading `/`. Note that
+ * this may be the empty string. Additionally the returned `relative_path` will
+ * not contain a leading `/`. The `relative_path` return will not return an
+ * empty string, it will return `"."` instead if it would otherwise do so.
+ *
+ * Returns -1 on failure. Errno is set to either:
+ *
+ *  * ENOMEM - failed to allocate memory for internal routines.
+ *  * ENOENT - the `path` could not be found relative to any preopened dir.
+ */
+int __wasilibc_find_abspath(const char *abspath,
+                            const char **__restrict__ abs_prefix,
+                            const char **__restrict__ relative_path);
+
+/**
+ * Same as `__wasilibc_find_relpath`, except that this function will interpret
+ * `relative` as a malloc'd buffer that will be `realloc`'d to the appropriate
+ * size to contain the relative path.
+ *
+ * Note that this is a weak symbol and if it's not defined you can use
+ * `__wasilibc_find_relpath`. The weak-nature of this symbols means that if it's
+ * not otherwise included in the compilation then `chdir` wasn't used an there's
+ * no need for this symbol.
+ *
+ * See documentation on `__wasilibc_find_relpath` for more information.
+ */
+int __wasilibc_find_relpath_alloc(
+    const char *path,
+    const char **abs,
+    char **relative,
+    size_t *relative_len,
+    int can_realloc
+) __attribute__((__weak__));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/wasi/libc-nocwd.h b/libc-bottom-half/headers/public/wasi/libc-nocwd.h
new file mode 100644
index 0000000..a988503
--- /dev/null
+++ b/libc-bottom-half/headers/public/wasi/libc-nocwd.h
@@ -0,0 +1,58 @@
+#ifndef __wasi_libc_nocwd_h
+#define __wasi_libc_nocwd_h
+
+/*
+ * In order to support AT_FDCWD, we need to wrap the *at functions to handle
+ * it by calling back into the non-at versions which perform libpreopen
+ * queries. These __wasilibc_nocwd_* forms are the underlying calls which
+ * assume AT_FDCWD has already been resolved.
+ */
+
+#define __need_size_t
+#include <stddef.h>
+#include <__typedef_ssize_t.h>
+#include <__typedef_mode_t.h>
+#include <__typedef_DIR.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct timespec;
+struct stat;
+struct dirent;
+
+int __wasilibc_nocwd___wasilibc_unlinkat(int, const char *)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_nocwd___wasilibc_rmdirat(int, const char *)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_nocwd_linkat(int, const char *, int, const char *, int)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_nocwd_symlinkat(const char *, int, const char *)
+    __attribute__((__warn_unused_result__));
+ssize_t __wasilibc_nocwd_readlinkat(int, const char *__restrict, char *__restrict, size_t)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_nocwd_faccessat(int, const char *, int, int)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_nocwd_renameat(int, const char *, int, const char *)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_nocwd_openat_nomode(int, const char *, int)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_nocwd_fstatat(int, const char *__restrict, struct stat *__restrict, int)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_nocwd_mkdirat_nomode(int, const char *)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_nocwd_utimensat(int, const char *, const struct timespec [2], int)
+    __attribute__((__warn_unused_result__));
+DIR *__wasilibc_nocwd_opendirat(int, const char *)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_nocwd_scandirat(int, const char *, struct dirent ***,
+                               int (*)(const struct dirent *),
+                               int (*)(const struct dirent **, const struct dirent **))
+    __attribute__((__warn_unused_result__));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/wasi/libc.h b/libc-bottom-half/headers/public/wasi/libc.h
new file mode 100644
index 0000000..b50518b
--- /dev/null
+++ b/libc-bottom-half/headers/public/wasi/libc.h
@@ -0,0 +1,65 @@
+#ifndef __wasi_libc_h
+#define __wasi_libc_h
+
+#include <__typedef_off_t.h>
+#include <__struct_timespec.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct stat;
+struct timespec;
+
+/// Register the given pre-opened file descriptor under the given path.
+///
+/// This function does not take ownership of `prefix` (it makes its own copy).
+int __wasilibc_register_preopened_fd(int fd, const char *prefix);
+
+/// Renumber `fd` to `newfd`; similar to `dup2` but does a move rather than a
+/// copy.
+int __wasilibc_fd_renumber(int fd, int newfd)
+    __attribute__((__warn_unused_result__));
+
+/// Like `unlinkat`, but without depending on `__wasi_path_remove_directory`.
+int __wasilibc_unlinkat(int fd, const char *path)
+    __attribute__((__warn_unused_result__));
+
+/// An `*at` version of rmdir.
+int __wasilibc_rmdirat(int fd, const char *path)
+    __attribute__((__warn_unused_result__));
+
+/// Like `open`, but without the varargs in the signature.
+int __wasilibc_open_nomode(const char *path, int oflag);
+
+/// Like `openat`, but without the varargs in the signature.
+int __wasilibc_openat_nomode(int fd, const char *path, int oflag);
+
+/// Return the current file offset. Like `lseek(fd, 0, SEEK_CUR)`, but without
+/// depending on `lseek`.
+off_t __wasilibc_tell(int fd)
+    __attribute__((__warn_unused_result__));
+
+/* Non-`at` forms of various `*at` functions. */
+int __wasilibc_access(const char *pathname, int mode, int flags)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_stat(const char *__restrict pathname, struct stat *__restrict statbuf, int flags)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_utimens(const char *pathname, const struct timespec times[2], int flags)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_link(const char *oldpath, const char *newpath, int flags)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_link_oldat(int olddirfd, const char *oldpath, const char *newpath, int flags)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_link_newat(const char *oldpath, int newdirfd, const char *newpath, int flags)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_rename_oldat(int olddirfd, const char *oldpath, const char *newpath)
+    __attribute__((__warn_unused_result__));
+int __wasilibc_rename_newat(const char *oldpath, int newdirfd, const char *newpath)
+    __attribute__((__warn_unused_result__));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libc-bottom-half/headers/public/wchar.h b/libc-bottom-half/headers/public/wchar.h
new file mode 100644
index 0000000..f43d72f
--- /dev/null
+++ b/libc-bottom-half/headers/public/wchar.h
@@ -0,0 +1,9 @@
+#ifndef __wasilibc_wchar_h
+#define __wasilibc_wchar_h
+
+#define __need_size_t
+#define __need_wchar_t
+#define __need_NULL
+#include <stddef.h>
+
+#endif
diff --git a/libc-bottom-half/mman/mman.c b/libc-bottom-half/mman/mman.c
new file mode 100644
index 0000000..f02b136
--- /dev/null
+++ b/libc-bottom-half/mman/mman.c
@@ -0,0 +1,124 @@
+// Userspace emulation of mmap and munmap. Restrictions apply.
+//
+// This is meant to be complete enough to be compatible with code that uses
+// mmap for simple file I/O. It just allocates memory with malloc and reads
+// and writes data with pread and pwrite.
+
+#define _WASI_EMULATED_MMAN
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+
+struct map {
+    int prot;
+    int flags;
+    off_t offset;
+    size_t length;
+};
+
+void *mmap(void *addr, size_t length, int prot, int flags,
+           int fd, off_t offset) {
+    // Check for unsupported flags.
+    if ((flags & (MAP_PRIVATE | MAP_SHARED)) == 0 ||
+        (flags & MAP_FIXED) != 0 ||
+#ifdef MAP_SHARED_VALIDATE
+        (flags & MAP_SHARED_VALIDATE) == MAP_SHARED_VALIDATE ||
+#endif
+#ifdef MAP_NORESERVE
+        (flags & MAP_NORESERVE) != 0 ||
+#endif
+#ifdef MAP_GROWSDOWN
+        (flags & MAP_GROWSDOWN) != 0 ||
+#endif
+#ifdef MAP_HUGETLB
+        (flags & MAP_HUGETLB) != 0 ||
+#endif
+#ifdef MAP_FIXED_NOREPLACE
+        (flags & MAP_FIXED_NOREPLACE) != 0 ||
+#endif
+        0)
+    {
+        errno = EINVAL;
+        return MAP_FAILED;
+    }
+
+    // Check for unsupported protection requests.
+    if (prot == PROT_NONE ||
+#ifdef PROT_EXEC
+        (prot & PROT_EXEC) != 0 ||
+#endif
+        0)
+    {
+        errno = EINVAL;
+        return MAP_FAILED;
+    }
+
+    //  To be consistent with POSIX.
+    if (length == 0) {
+        errno = EINVAL;
+        return MAP_FAILED;
+    }
+
+    // Check for integer overflow.
+    size_t buf_len = 0;
+    if (__builtin_add_overflow(length, sizeof(struct map), &buf_len)) {
+        errno = ENOMEM;
+        return MAP_FAILED;
+    }
+
+    // Allocate the memory.
+    struct map *map = malloc(buf_len);
+    if (!map) {
+        errno = ENOMEM;
+        return MAP_FAILED;
+    }
+
+    // Initialize the header.
+    map->prot = prot;
+    map->flags = flags;
+    map->offset = offset;
+    map->length = length;
+
+    // Initialize the main memory buffer, either with the contents of a file,
+    // or with zeros.
+    addr = map + 1;
+    if ((flags & MAP_ANON) == 0) {
+        char *body = (char *)addr;
+        while (length > 0) {
+            const ssize_t nread = pread(fd, body, length, offset);
+            if (nread < 0) {
+                if (errno == EINTR)
+                    continue;
+                return MAP_FAILED;
+            }
+            if (nread == 0)
+                break;
+            length -= (size_t)nread;
+            offset += (size_t)nread;
+            body += (size_t)nread;
+        }
+    } else {
+        memset(addr, 0, length);
+    }
+
+    return addr;
+}
+
+int munmap(void *addr, size_t length) {
+    struct map *map = (struct map *)addr - 1;
+
+    // We don't support partial munmapping.
+    if (map->length != length) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    // Release the memory.
+    free(map);
+
+    // Success!
+    return 0;
+}
diff --git a/libc-bottom-half/signal/signal.c b/libc-bottom-half/signal/signal.c
new file mode 100644
index 0000000..290d6b2
--- /dev/null
+++ b/libc-bottom-half/signal/signal.c
@@ -0,0 +1,142 @@
+// Userspace emulation of `raise` and `signal`.
+//
+// WebAssembly doesn't support asynchronous signal delivery, so we can't
+// support it in WASI libc. But we can make things like `raise` work.
+
+#define _WASI_EMULATED_SIGNAL
+#define _ALL_SOURCE
+#define _GNU_SOURCE
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <assert.h>
+
+void __SIG_IGN(int sig) {
+    // do nothing
+}
+
+_Noreturn
+void __SIG_ERR(int sig) {
+    __builtin_trap();
+}
+
+_Noreturn
+static void core_handler(int sig) {
+    fprintf(stderr, "Program received fatal signal: %s\n", strsignal(sig));
+    abort();
+}
+
+_Noreturn
+static void terminate_handler(int sig) {
+    fprintf(stderr, "Program recieved termination signal: %s\n", strsignal(sig));
+    abort();
+}
+
+_Noreturn
+static void stop_handler(int sig) {
+    fprintf(stderr, "Program recieved stop signal: %s\n", strsignal(sig));
+    abort();
+}
+
+static void continue_handler(int sig) {
+    // do nothing
+}
+
+static const sighandler_t default_handlers[_NSIG] = {
+    // Default behavior: "core".
+    [SIGABRT] = core_handler,
+    [SIGBUS] = core_handler,
+    [SIGFPE] = core_handler,
+    [SIGILL] = core_handler,
+#if SIGIOT != SIGABRT
+    [SIGIOT] = core_handler,
+#endif
+    [SIGQUIT] = core_handler,
+    [SIGSEGV] = core_handler,
+    [SIGSYS] = core_handler,
+    [SIGTRAP] = core_handler,
+    [SIGXCPU] = core_handler,
+    [SIGXFSZ] = core_handler,
+#if defined(SIGUNUSED) && SIGUNUSED != SIGSYS
+    [SIGUNUSED] = core_handler,
+#endif
+
+    // Default behavior: ignore.
+    [SIGCHLD] = SIG_IGN,
+#if defined(SIGCLD) && SIGCLD != SIGCHLD
+    [SIGCLD] = SIG_IGN,
+#endif
+    [SIGURG] = SIG_IGN,
+    [SIGWINCH] = SIG_IGN,
+
+    // Default behavior: "continue".
+    [SIGCONT] = continue_handler,
+
+    // Default behavior: "stop".
+    [SIGSTOP] = stop_handler,
+    [SIGTSTP] = stop_handler,
+    [SIGTTIN] = stop_handler,
+    [SIGTTOU] = stop_handler,
+
+    // Default behavior: "terminate".
+    [SIGHUP] = terminate_handler,
+    [SIGINT] = terminate_handler,
+    [SIGKILL] = terminate_handler,
+    [SIGUSR1] = terminate_handler,
+    [SIGUSR2] = terminate_handler,
+    [SIGPIPE] = terminate_handler,
+    [SIGALRM] = terminate_handler,
+    [SIGTERM] = terminate_handler,
+    [SIGSTKFLT] = terminate_handler,
+    [SIGVTALRM] = terminate_handler,
+    [SIGPROF] = terminate_handler,
+    [SIGIO] = terminate_handler,
+#if SIGPOLL != SIGIO
+    [SIGPOLL] = terminate_handler,
+#endif
+    [SIGPWR] = terminate_handler,
+};
+
+static sighandler_t handlers[_NSIG];
+
+int raise(int sig) {
+    if (sig < 0 || sig >= _NSIG) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    sighandler_t func = handlers[sig];
+
+    if (func == NULL) {
+        default_handlers[sig](sig);
+    } else {
+        func(sig);
+    }
+
+    return 0;
+}
+
+void (*signal(int sig, void (*func)(int)))(int) {
+    assert(SIG_DFL == NULL);
+
+    if (sig < 0 || sig >= _NSIG) {
+        errno = EINVAL;
+        return SIG_ERR;
+    }
+
+    if (sig == SIGKILL || sig == SIGSTOP) {
+        errno = EINVAL;
+        return SIG_ERR;
+    }
+
+    sighandler_t old = handlers[sig];
+
+    handlers[sig] = func;
+
+    return old;
+}
+
+extern __typeof(signal) bsd_signal __attribute__((weak, alias("signal")));
+extern __typeof(signal) __sysv_signal __attribute__((weak, alias("signal")));
diff --git a/libc-bottom-half/sources/__errno_location.c b/libc-bottom-half/sources/__errno_location.c
new file mode 100644
index 0000000..5e6ef5e
--- /dev/null
+++ b/libc-bottom-half/sources/__errno_location.c
@@ -0,0 +1,5 @@
+#include <errno.h>
+
+int *__errno_location(void) {
+    return &errno;
+}
diff --git a/libc-bottom-half/sources/__main_void.c b/libc-bottom-half/sources/__main_void.c
new file mode 100644
index 0000000..cba22ef
--- /dev/null
+++ b/libc-bottom-half/sources/__main_void.c
@@ -0,0 +1,54 @@
+#include <wasi/api.h>
+#include <stdlib.h>
+#include <sysexits.h>
+
+// The user's `main` function, expecting arguments.
+int __main_argc_argv(int argc, char *argv[]);
+
+// If the user's `main` function expects arguments, the compiler will rename
+// it to `__main_argc_argv`, and this version will get linked in, which
+// initializes the argument data and calls `__main_argc_argv`.
+__attribute__((__weak__, nodebug))
+int __main_void(void) {
+    __wasi_errno_t err;
+
+    // Get the sizes of the arrays we'll have to create to copy in the args.
+    size_t argv_buf_size;
+    size_t argc;
+    err = __wasi_args_sizes_get(&argc, &argv_buf_size);
+    if (err != __WASI_ERRNO_SUCCESS) {
+        _Exit(EX_OSERR);
+    }
+
+    // Add 1 for the NULL pointer to mark the end, and check for overflow.
+    size_t num_ptrs = argc + 1;
+    if (num_ptrs == 0) {
+        _Exit(EX_SOFTWARE);
+    }
+
+    // Allocate memory for storing the argument chars.
+    char *argv_buf = malloc(argv_buf_size);
+    if (argv_buf == NULL) {
+        _Exit(EX_SOFTWARE);
+    }
+
+    // Allocate memory for the array of pointers. This uses `calloc` both to
+    // handle overflow and to initialize the NULL pointer at the end.
+    char **argv = calloc(num_ptrs, sizeof(char *));
+    if (argv == NULL) {
+        free(argv_buf);
+        _Exit(EX_SOFTWARE);
+    }
+
+    // Fill the argument chars, and the argv array with pointers into those chars.
+    // TODO: Remove the casts on `argv_ptrs` and `argv_buf` once the witx is updated with char8 support.
+    err = __wasi_args_get((uint8_t **)argv, (uint8_t *)argv_buf);
+    if (err != __WASI_ERRNO_SUCCESS) {
+        free(argv_buf);
+        free(argv);
+        _Exit(EX_OSERR);
+    }
+
+    // Call `__main_argc_argv` with the arguments!
+    return __main_argc_argv(argc, argv);
+}
diff --git a/libc-bottom-half/sources/__wasilibc_dt.c b/libc-bottom-half/sources/__wasilibc_dt.c
new file mode 100644
index 0000000..b06460f
--- /dev/null
+++ b/libc-bottom-half/sources/__wasilibc_dt.c
@@ -0,0 +1,34 @@
+#include <__header_dirent.h>
+#include <__mode_t.h>
+
+int __wasilibc_iftodt(int x) {
+    switch (x) {
+        case S_IFDIR: return DT_DIR;
+        case S_IFCHR: return DT_CHR;
+        case S_IFBLK: return DT_BLK;
+        case S_IFREG: return DT_REG;
+        case S_IFIFO: return DT_FIFO;
+        case S_IFLNK: return DT_LNK;
+#ifdef DT_SOCK
+        case S_IFSOCK: return DT_SOCK;
+#endif
+        default: return DT_UNKNOWN;
+    }
+}
+
+int __wasilibc_dttoif(int x) {
+    switch (x) {
+        case DT_DIR: return S_IFDIR;
+        case DT_CHR: return S_IFCHR;
+        case DT_BLK: return S_IFBLK;
+        case DT_REG: return S_IFREG;
+        case DT_FIFO: return S_IFIFO;
+        case DT_LNK: return S_IFLNK;
+#ifdef DT_SOCK
+        case DT_SOCK: return S_IFSOCK;
+#endif
+        case DT_UNKNOWN:
+        default:
+	    return S_IFSOCK;
+    }
+}
diff --git a/libc-bottom-half/sources/__wasilibc_environ.c b/libc-bottom-half/sources/__wasilibc_environ.c
new file mode 100644
index 0000000..53d0a55
--- /dev/null
+++ b/libc-bottom-half/sources/__wasilibc_environ.c
@@ -0,0 +1,14 @@
+#include <wasi/libc-environ.h>
+
+extern char **__wasilibc_environ;
+
+// See the comments in libc-environ.h.
+char **__wasilibc_get_environ(void) {
+    // Perform lazy initialization if needed.
+    __wasilibc_ensure_environ();
+
+    // Return `environ`. Use the `__wasilibc_`-prefixed name so that we don't
+    // pull in the `environ` symbol directly, which would lead to eager
+    // initialization being done instead.
+    return __wasilibc_environ;
+}
diff --git a/libc-bottom-half/sources/__wasilibc_fd_renumber.c b/libc-bottom-half/sources/__wasilibc_fd_renumber.c
new file mode 100644
index 0000000..aa9d8dc
--- /dev/null
+++ b/libc-bottom-half/sources/__wasilibc_fd_renumber.c
@@ -0,0 +1,13 @@
+#include <wasi/api.h>
+#include <wasi/libc.h>
+#include <errno.h>
+#include <unistd.h>
+
+int __wasilibc_fd_renumber(int fd, int newfd) {
+    __wasi_errno_t error = __wasi_fd_renumber(fd, newfd);
+    if (error != 0) {
+        errno = error;
+        return -1;
+    }
+    return 0;
+}
diff --git a/libc-bottom-half/sources/__wasilibc_initialize_environ.c b/libc-bottom-half/sources/__wasilibc_initialize_environ.c
new file mode 100644
index 0000000..2d31c5d
--- /dev/null
+++ b/libc-bottom-half/sources/__wasilibc_initialize_environ.c
@@ -0,0 +1,93 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <sysexits.h>
+#include <wasi/api.h>
+#include <wasi/libc.h>
+#include <wasi/libc-environ.h>
+
+/// If the program doesn't use `environ`, it'll get this version of
+/// `__wasilibc_environ`, which isn't initialized with a constructor function.
+/// `getenv` etc. call `__wasilibc_ensure_environ()` before accessing it.
+/// Statically-initialize it to an invalid pointer value so that we can
+/// detect if it's been explicitly initialized (we can't use `NULL` because
+/// `clearenv` sets it to NULL.
+weak char **__wasilibc_environ = (char **)-1;
+
+// See the comments in libc-environ.h.
+void __wasilibc_ensure_environ(void) {
+    if (__wasilibc_environ == (char **)-1) {
+        __wasilibc_initialize_environ();
+    }
+}
+
+/// Avoid dynamic allocation for the case where there are no environment
+/// variables, but we still need a non-NULL pointer to an (empty) array.
+static char *empty_environ[1] = { NULL };
+
+// See the comments in libc-environ.h.
+void __wasilibc_initialize_environ(void) {
+    // Get the sizes of the arrays we'll have to create to copy in the environment.
+    size_t environ_count;
+    size_t environ_buf_size;
+    __wasi_errno_t err = __wasi_environ_sizes_get(&environ_count, &environ_buf_size);
+    if (err != __WASI_ERRNO_SUCCESS) {
+        goto oserr;
+    }
+    if (environ_count == 0) {
+        __wasilibc_environ = empty_environ;
+        return;
+    }
+
+    // Add 1 for the NULL pointer to mark the end, and check for overflow.
+    size_t num_ptrs = environ_count + 1;
+    if (num_ptrs == 0) {
+        goto software;
+    }
+
+    // Allocate memory for storing the environment chars.
+    char *environ_buf = malloc(environ_buf_size);
+    if (environ_buf == NULL) {
+        goto software;
+    }
+
+    // Allocate memory for the array of pointers. This uses `calloc` both to
+    // handle overflow and to initialize the NULL pointer at the end.
+    char **environ_ptrs = calloc(num_ptrs, sizeof(char *));
+    if (environ_ptrs == NULL) {
+        free(environ_buf);
+        goto software;
+    }
+
+    // Fill the environment chars, and the `__wasilibc_environ` array with
+    // pointers into those chars.
+    // TODO: Remove the casts on `environ_ptrs` and `environ_buf` once the witx is updated with char8 support.
+    err = __wasi_environ_get((uint8_t **)environ_ptrs, (uint8_t *)environ_buf);
+    if (err != __WASI_ERRNO_SUCCESS) {
+        free(environ_buf);
+        free(environ_ptrs);
+        goto oserr;
+    }
+
+    __wasilibc_environ = environ_ptrs;
+    return;
+oserr:
+    _Exit(EX_OSERR);
+software:
+    _Exit(EX_SOFTWARE);
+}
+
+// See the comments in libc-environ.h.
+void __wasilibc_deinitialize_environ(void) {
+    if (__wasilibc_environ != (char **)-1) {
+        // Let libc-top-half clear the old environment-variable strings.
+        clearenv();
+        // Set the pointer to the special init value.
+        __wasilibc_environ = (char **)-1;
+    }
+}
+
+// See the comments in libc-environ.h.
+weak void __wasilibc_maybe_reinitialize_environ_eagerly(void) {
+    // This version does nothing. It may be overridden by a version which does
+    // something if `environ` is used.
+}
diff --git a/libc-bottom-half/sources/__wasilibc_real.c b/libc-bottom-half/sources/__wasilibc_real.c
new file mode 100644
index 0000000..855a2c6
--- /dev/null
+++ b/libc-bottom-half/sources/__wasilibc_real.c
@@ -0,0 +1,672 @@
+/**
+ * THIS FILE IS AUTO-GENERATED from the following files:
+ *   wasi_snapshot_preview1.witx
+ *
+ * To regenerate this file execute:
+ *
+ *     cargo run --manifest-path tools/wasi-headers/Cargo.toml generate-libc
+ *
+ * Modifications to this file will cause CI to fail, the code generator tool
+ * must be modified to change this file.
+ */
+
+#include <wasi/api.h>
+#include <string.h>
+
+int32_t __imported_wasi_snapshot_preview1_args_get(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("args_get")
+));
+
+__wasi_errno_t __wasi_args_get(
+    uint8_t * * argv,
+    uint8_t * argv_buf
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_args_get((int32_t) argv, (int32_t) argv_buf);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_args_sizes_get(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("args_sizes_get")
+));
+
+__wasi_errno_t __wasi_args_sizes_get(
+    __wasi_size_t *retptr0,
+    __wasi_size_t *retptr1
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_args_sizes_get((int32_t) retptr0, (int32_t) retptr1);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_environ_get(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("environ_get")
+));
+
+__wasi_errno_t __wasi_environ_get(
+    uint8_t * * environ,
+    uint8_t * environ_buf
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_environ_get((int32_t) environ, (int32_t) environ_buf);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_environ_sizes_get(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("environ_sizes_get")
+));
+
+__wasi_errno_t __wasi_environ_sizes_get(
+    __wasi_size_t *retptr0,
+    __wasi_size_t *retptr1
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_environ_sizes_get((int32_t) retptr0, (int32_t) retptr1);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_clock_res_get(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("clock_res_get")
+));
+
+__wasi_errno_t __wasi_clock_res_get(
+    __wasi_clockid_t id,
+    __wasi_timestamp_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_clock_res_get((int32_t) id, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_clock_time_get(int32_t arg0, int64_t arg1, int32_t arg2) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("clock_time_get")
+));
+
+__wasi_errno_t __wasi_clock_time_get(
+    __wasi_clockid_t id,
+    __wasi_timestamp_t precision,
+    __wasi_timestamp_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_clock_time_get((int32_t) id, (int64_t) precision, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_advise(int32_t arg0, int64_t arg1, int64_t arg2, int32_t arg3) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_advise")
+));
+
+__wasi_errno_t __wasi_fd_advise(
+    __wasi_fd_t fd,
+    __wasi_filesize_t offset,
+    __wasi_filesize_t len,
+    __wasi_advice_t advice
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_advise((int32_t) fd, (int64_t) offset, (int64_t) len, (int32_t) advice);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_allocate(int32_t arg0, int64_t arg1, int64_t arg2) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_allocate")
+));
+
+__wasi_errno_t __wasi_fd_allocate(
+    __wasi_fd_t fd,
+    __wasi_filesize_t offset,
+    __wasi_filesize_t len
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_allocate((int32_t) fd, (int64_t) offset, (int64_t) len);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_close(int32_t arg0) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_close")
+));
+
+__wasi_errno_t __wasi_fd_close(
+    __wasi_fd_t fd
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_close((int32_t) fd);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_datasync(int32_t arg0) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_datasync")
+));
+
+__wasi_errno_t __wasi_fd_datasync(
+    __wasi_fd_t fd
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_datasync((int32_t) fd);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_fdstat_get(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_fdstat_get")
+));
+
+__wasi_errno_t __wasi_fd_fdstat_get(
+    __wasi_fd_t fd,
+    __wasi_fdstat_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_fdstat_get((int32_t) fd, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_fdstat_set_flags(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_fdstat_set_flags")
+));
+
+__wasi_errno_t __wasi_fd_fdstat_set_flags(
+    __wasi_fd_t fd,
+    __wasi_fdflags_t flags
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_fdstat_set_flags((int32_t) fd, flags);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_fdstat_set_rights(int32_t arg0, int64_t arg1, int64_t arg2) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_fdstat_set_rights")
+));
+
+__wasi_errno_t __wasi_fd_fdstat_set_rights(
+    __wasi_fd_t fd,
+    __wasi_rights_t fs_rights_base,
+    __wasi_rights_t fs_rights_inheriting
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_fdstat_set_rights((int32_t) fd, fs_rights_base, fs_rights_inheriting);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_filestat_get(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_filestat_get")
+));
+
+__wasi_errno_t __wasi_fd_filestat_get(
+    __wasi_fd_t fd,
+    __wasi_filestat_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_filestat_get((int32_t) fd, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_filestat_set_size(int32_t arg0, int64_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_filestat_set_size")
+));
+
+__wasi_errno_t __wasi_fd_filestat_set_size(
+    __wasi_fd_t fd,
+    __wasi_filesize_t size
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_filestat_set_size((int32_t) fd, (int64_t) size);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_filestat_set_times(int32_t arg0, int64_t arg1, int64_t arg2, int32_t arg3) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_filestat_set_times")
+));
+
+__wasi_errno_t __wasi_fd_filestat_set_times(
+    __wasi_fd_t fd,
+    __wasi_timestamp_t atim,
+    __wasi_timestamp_t mtim,
+    __wasi_fstflags_t fst_flags
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_filestat_set_times((int32_t) fd, (int64_t) atim, (int64_t) mtim, fst_flags);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_pread(int32_t arg0, int32_t arg1, int32_t arg2, int64_t arg3, int32_t arg4) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_pread")
+));
+
+__wasi_errno_t __wasi_fd_pread(
+    __wasi_fd_t fd,
+    const __wasi_iovec_t *iovs,
+    size_t iovs_len,
+    __wasi_filesize_t offset,
+    __wasi_size_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_pread((int32_t) fd, (int32_t) iovs, (int32_t) iovs_len, (int64_t) offset, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_prestat_get(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_prestat_get")
+));
+
+__wasi_errno_t __wasi_fd_prestat_get(
+    __wasi_fd_t fd,
+    __wasi_prestat_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_prestat_get((int32_t) fd, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_prestat_dir_name(int32_t arg0, int32_t arg1, int32_t arg2) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_prestat_dir_name")
+));
+
+__wasi_errno_t __wasi_fd_prestat_dir_name(
+    __wasi_fd_t fd,
+    uint8_t * path,
+    __wasi_size_t path_len
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_prestat_dir_name((int32_t) fd, (int32_t) path, (int32_t) path_len);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_pwrite(int32_t arg0, int32_t arg1, int32_t arg2, int64_t arg3, int32_t arg4) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_pwrite")
+));
+
+__wasi_errno_t __wasi_fd_pwrite(
+    __wasi_fd_t fd,
+    const __wasi_ciovec_t *iovs,
+    size_t iovs_len,
+    __wasi_filesize_t offset,
+    __wasi_size_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_pwrite((int32_t) fd, (int32_t) iovs, (int32_t) iovs_len, (int64_t) offset, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_read(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_read")
+));
+
+__wasi_errno_t __wasi_fd_read(
+    __wasi_fd_t fd,
+    const __wasi_iovec_t *iovs,
+    size_t iovs_len,
+    __wasi_size_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_read((int32_t) fd, (int32_t) iovs, (int32_t) iovs_len, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_readdir(int32_t arg0, int32_t arg1, int32_t arg2, int64_t arg3, int32_t arg4) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_readdir")
+));
+
+__wasi_errno_t __wasi_fd_readdir(
+    __wasi_fd_t fd,
+    uint8_t * buf,
+    __wasi_size_t buf_len,
+    __wasi_dircookie_t cookie,
+    __wasi_size_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_readdir((int32_t) fd, (int32_t) buf, (int32_t) buf_len, (int64_t) cookie, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_renumber(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_renumber")
+));
+
+__wasi_errno_t __wasi_fd_renumber(
+    __wasi_fd_t fd,
+    __wasi_fd_t to
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_renumber((int32_t) fd, (int32_t) to);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_seek(int32_t arg0, int64_t arg1, int32_t arg2, int32_t arg3) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_seek")
+));
+
+__wasi_errno_t __wasi_fd_seek(
+    __wasi_fd_t fd,
+    __wasi_filedelta_t offset,
+    __wasi_whence_t whence,
+    __wasi_filesize_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_seek((int32_t) fd, offset, (int32_t) whence, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_sync(int32_t arg0) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_sync")
+));
+
+__wasi_errno_t __wasi_fd_sync(
+    __wasi_fd_t fd
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_sync((int32_t) fd);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_tell(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_tell")
+));
+
+__wasi_errno_t __wasi_fd_tell(
+    __wasi_fd_t fd,
+    __wasi_filesize_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_tell((int32_t) fd, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_fd_write(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("fd_write")
+));
+
+__wasi_errno_t __wasi_fd_write(
+    __wasi_fd_t fd,
+    const __wasi_ciovec_t *iovs,
+    size_t iovs_len,
+    __wasi_size_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_fd_write((int32_t) fd, (int32_t) iovs, (int32_t) iovs_len, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_path_create_directory(int32_t arg0, int32_t arg1, int32_t arg2) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("path_create_directory")
+));
+
+__wasi_errno_t __wasi_path_create_directory(
+    __wasi_fd_t fd,
+    const char *path
+){
+    size_t path_len = strlen(path);
+    int32_t ret = __imported_wasi_snapshot_preview1_path_create_directory((int32_t) fd, (int32_t) path, (int32_t) path_len);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_path_filestat_get(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("path_filestat_get")
+));
+
+__wasi_errno_t __wasi_path_filestat_get(
+    __wasi_fd_t fd,
+    __wasi_lookupflags_t flags,
+    const char *path,
+    __wasi_filestat_t *retptr0
+){
+    size_t path_len = strlen(path);
+    int32_t ret = __imported_wasi_snapshot_preview1_path_filestat_get((int32_t) fd, flags, (int32_t) path, (int32_t) path_len, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_path_filestat_set_times(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int64_t arg4, int64_t arg5, int32_t arg6) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("path_filestat_set_times")
+));
+
+__wasi_errno_t __wasi_path_filestat_set_times(
+    __wasi_fd_t fd,
+    __wasi_lookupflags_t flags,
+    const char *path,
+    __wasi_timestamp_t atim,
+    __wasi_timestamp_t mtim,
+    __wasi_fstflags_t fst_flags
+){
+    size_t path_len = strlen(path);
+    int32_t ret = __imported_wasi_snapshot_preview1_path_filestat_set_times((int32_t) fd, flags, (int32_t) path, (int32_t) path_len, (int64_t) atim, (int64_t) mtim, fst_flags);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_path_link(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5, int32_t arg6) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("path_link")
+));
+
+__wasi_errno_t __wasi_path_link(
+    __wasi_fd_t old_fd,
+    __wasi_lookupflags_t old_flags,
+    const char *old_path,
+    __wasi_fd_t new_fd,
+    const char *new_path
+){
+    size_t old_path_len = strlen(old_path);
+    size_t new_path_len = strlen(new_path);
+    int32_t ret = __imported_wasi_snapshot_preview1_path_link((int32_t) old_fd, old_flags, (int32_t) old_path, (int32_t) old_path_len, (int32_t) new_fd, (int32_t) new_path, (int32_t) new_path_len);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_path_open(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int64_t arg5, int64_t arg6, int32_t arg7, int32_t arg8) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("path_open")
+));
+
+__wasi_errno_t __wasi_path_open(
+    __wasi_fd_t fd,
+    __wasi_lookupflags_t dirflags,
+    const char *path,
+    __wasi_oflags_t oflags,
+    __wasi_rights_t fs_rights_base,
+    __wasi_rights_t fs_rights_inheriting,
+    __wasi_fdflags_t fdflags,
+    __wasi_fd_t *retptr0
+){
+    size_t path_len = strlen(path);
+    int32_t ret = __imported_wasi_snapshot_preview1_path_open((int32_t) fd, dirflags, (int32_t) path, (int32_t) path_len, oflags, fs_rights_base, fs_rights_inheriting, fdflags, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_path_readlink(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("path_readlink")
+));
+
+__wasi_errno_t __wasi_path_readlink(
+    __wasi_fd_t fd,
+    const char *path,
+    uint8_t * buf,
+    __wasi_size_t buf_len,
+    __wasi_size_t *retptr0
+){
+    size_t path_len = strlen(path);
+    int32_t ret = __imported_wasi_snapshot_preview1_path_readlink((int32_t) fd, (int32_t) path, (int32_t) path_len, (int32_t) buf, (int32_t) buf_len, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_path_remove_directory(int32_t arg0, int32_t arg1, int32_t arg2) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("path_remove_directory")
+));
+
+__wasi_errno_t __wasi_path_remove_directory(
+    __wasi_fd_t fd,
+    const char *path
+){
+    size_t path_len = strlen(path);
+    int32_t ret = __imported_wasi_snapshot_preview1_path_remove_directory((int32_t) fd, (int32_t) path, (int32_t) path_len);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_path_rename(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("path_rename")
+));
+
+__wasi_errno_t __wasi_path_rename(
+    __wasi_fd_t fd,
+    const char *old_path,
+    __wasi_fd_t new_fd,
+    const char *new_path
+){
+    size_t old_path_len = strlen(old_path);
+    size_t new_path_len = strlen(new_path);
+    int32_t ret = __imported_wasi_snapshot_preview1_path_rename((int32_t) fd, (int32_t) old_path, (int32_t) old_path_len, (int32_t) new_fd, (int32_t) new_path, (int32_t) new_path_len);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_path_symlink(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("path_symlink")
+));
+
+__wasi_errno_t __wasi_path_symlink(
+    const char *old_path,
+    __wasi_fd_t fd,
+    const char *new_path
+){
+    size_t old_path_len = strlen(old_path);
+    size_t new_path_len = strlen(new_path);
+    int32_t ret = __imported_wasi_snapshot_preview1_path_symlink((int32_t) old_path, (int32_t) old_path_len, (int32_t) fd, (int32_t) new_path, (int32_t) new_path_len);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_path_unlink_file(int32_t arg0, int32_t arg1, int32_t arg2) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("path_unlink_file")
+));
+
+__wasi_errno_t __wasi_path_unlink_file(
+    __wasi_fd_t fd,
+    const char *path
+){
+    size_t path_len = strlen(path);
+    int32_t ret = __imported_wasi_snapshot_preview1_path_unlink_file((int32_t) fd, (int32_t) path, (int32_t) path_len);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_poll_oneoff(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("poll_oneoff")
+));
+
+__wasi_errno_t __wasi_poll_oneoff(
+    const __wasi_subscription_t * in,
+    __wasi_event_t * out,
+    __wasi_size_t nsubscriptions,
+    __wasi_size_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_poll_oneoff((int32_t) in, (int32_t) out, (int32_t) nsubscriptions, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+_Noreturn void __imported_wasi_snapshot_preview1_proc_exit(int32_t arg0) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("proc_exit")
+));
+
+_Noreturn void __wasi_proc_exit(
+    __wasi_exitcode_t rval
+){
+    __imported_wasi_snapshot_preview1_proc_exit((int32_t) rval);
+}
+
+int32_t __imported_wasi_snapshot_preview1_sched_yield() __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("sched_yield")
+));
+
+__wasi_errno_t __wasi_sched_yield(
+    void
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_sched_yield();
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_random_get(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("random_get")
+));
+
+__wasi_errno_t __wasi_random_get(
+    uint8_t * buf,
+    __wasi_size_t buf_len
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_random_get((int32_t) buf, (int32_t) buf_len);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_sock_accept(int32_t arg0, int32_t arg1, int32_t arg2) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("sock_accept")
+));
+
+__wasi_errno_t __wasi_sock_accept(
+    __wasi_fd_t fd,
+    __wasi_fdflags_t flags,
+    __wasi_fd_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_sock_accept((int32_t) fd, flags, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_sock_recv(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("sock_recv")
+));
+
+__wasi_errno_t __wasi_sock_recv(
+    __wasi_fd_t fd,
+    const __wasi_iovec_t *ri_data,
+    size_t ri_data_len,
+    __wasi_riflags_t ri_flags,
+    __wasi_size_t *retptr0,
+    __wasi_roflags_t *retptr1
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_sock_recv((int32_t) fd, (int32_t) ri_data, (int32_t) ri_data_len, ri_flags, (int32_t) retptr0, (int32_t) retptr1);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_sock_send(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("sock_send")
+));
+
+__wasi_errno_t __wasi_sock_send(
+    __wasi_fd_t fd,
+    const __wasi_ciovec_t *si_data,
+    size_t si_data_len,
+    __wasi_siflags_t si_flags,
+    __wasi_size_t *retptr0
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_sock_send((int32_t) fd, (int32_t) si_data, (int32_t) si_data_len, (int32_t) si_flags, (int32_t) retptr0);
+    return (uint16_t) ret;
+}
+
+int32_t __imported_wasi_snapshot_preview1_sock_shutdown(int32_t arg0, int32_t arg1) __attribute__((
+    __import_module__("wasi_snapshot_preview1"),
+    __import_name__("sock_shutdown")
+));
+
+__wasi_errno_t __wasi_sock_shutdown(
+    __wasi_fd_t fd,
+    __wasi_sdflags_t how
+){
+    int32_t ret = __imported_wasi_snapshot_preview1_sock_shutdown((int32_t) fd, how);
+    return (uint16_t) ret;
+}
+
+#ifdef _REENTRANT
+int32_t __imported_wasi_thread_spawn(int32_t arg0) __attribute__((
+    __import_module__("wasi"),
+    __import_name__("thread_spawn")
+));
+
+__wasi_errno_t __wasi_thread_spawn(void* start_arg) {
+	int32_t ret = __imported_wasi_thread_spawn((int32_t) start_arg);
+    return (uint16_t) ret;
+}
+#endif
diff --git a/libc-bottom-half/sources/__wasilibc_rmdirat.c b/libc-bottom-half/sources/__wasilibc_rmdirat.c
new file mode 100644
index 0000000..b2b906a
--- /dev/null
+++ b/libc-bottom-half/sources/__wasilibc_rmdirat.c
@@ -0,0 +1,12 @@
+#include <wasi/api.h>
+#include <wasi/libc.h>
+#include <errno.h>
+
+int __wasilibc_nocwd___wasilibc_rmdirat(int fd, const char *path) {
+    __wasi_errno_t error = __wasi_path_remove_directory(fd, path);
+    if (error != 0) {
+        errno = error;
+        return -1;
+    }
+    return 0;
+}
diff --git a/libc-bottom-half/sources/__wasilibc_tell.c b/libc-bottom-half/sources/__wasilibc_tell.c
new file mode 100644
index 0000000..358d0ca
--- /dev/null
+++ b/libc-bottom-half/sources/__wasilibc_tell.c
@@ -0,0 +1,14 @@
+#include <wasi/api.h>
+#include <errno.h>
+
+off_t __wasilibc_tell(int fildes) {
+    __wasi_filesize_t offset;
+    __wasi_errno_t error = __wasi_fd_tell(fildes, &offset);
+    if (error != 0) {
+        // lseek returns ESPIPE on when called on a pipe, socket, or fifo,
+        // which on WASI would translate into ENOTCAPABLE.
+        errno = error == ENOTCAPABLE ? ESPIPE : error;
+        return -1;
+    }
+    return offset;
+}
diff --git a/libc-bottom-half/sources/__wasilibc_unlinkat.c b/libc-bottom-half/sources/__wasilibc_unlinkat.c
new file mode 100644
index 0000000..8b4f6b5
--- /dev/null
+++ b/libc-bottom-half/sources/__wasilibc_unlinkat.c
@@ -0,0 +1,12 @@
+#include <wasi/api.h>
+#include <wasi/libc.h>
+#include <errno.h>
+
+int __wasilibc_nocwd___wasilibc_unlinkat(int fd, const char *path) {
+    __wasi_errno_t error = __wasi_path_unlink_file(fd, path);
+    if (error != 0) {
+        errno = error;
+        return -1;
+    }
+    return 0;
+}
diff --git a/libc-bottom-half/sources/abort.c b/libc-bottom-half/sources/abort.c
new file mode 100644
index 0000000..95fe2be
--- /dev/null
+++ b/libc-bottom-half/sources/abort.c
@@ -0,0 +1,6 @@
+#include <stdlib.h>
+
+void abort(void) {
+    // wasm doesn't support signals, so just trap to halt the program.
+    __builtin_trap();
+}
diff --git a/libc-bottom-half/sources/accept.c b/libc-bottom-half/sources/accept.c
new file mode 100644
index 0000000..902e731
--- /dev/null
+++ b/libc-bottom-half/sources/accept.c
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <sys/socket.h>
+
+#include <assert.h>
+#include <wasi/api.h>
+#include <errno.h>
+#include <string.h>
+
+int accept(int socket, struct sockaddr *restrict addr, socklen_t *restrict addrlen) {
+  int ret = -1;
+
+  __wasi_errno_t error = __wasi_sock_accept(socket, 0, &ret);
+
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+
+  // Clear sockaddr to indicate undefined address
+  memset(addr, 0, *addrlen);
+  // might be AF_UNIX or AF_INET
+  addr->sa_family = AF_UNSPEC;
+  *addrlen = sizeof(struct sockaddr);
+
+  return ret;
+}
+
+int accept4(int socket, struct sockaddr *restrict addr, socklen_t *restrict addrlen, int flags) {
+  int ret = -1;
+
+  if (flags & ~(SOCK_NONBLOCK | SOCK_CLOEXEC)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  __wasi_errno_t error = __wasi_sock_accept(socket, (flags & SOCK_NONBLOCK) ? __WASI_FDFLAGS_NONBLOCK : 0, &ret);
+
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+
+  // Clear sockaddr to indicate undefined address
+  memset(addr, 0, *addrlen);
+  // might be AF_UNIX or AF_INET
+  addr->sa_family = AF_UNSPEC;
+  *addrlen = sizeof(struct sockaddr);
+
+  return ret;
+}
diff --git a/libc-bottom-half/sources/at_fdcwd.c b/libc-bottom-half/sources/at_fdcwd.c
new file mode 100644
index 0000000..c83797d
--- /dev/null
+++ b/libc-bottom-half/sources/at_fdcwd.c
@@ -0,0 +1,141 @@
+// Handle AT_FDCWD and absolute paths for the *at functions.
+//
+// In the case of an AT_FDCWD file descriptor or an absolute path, call the
+// corresponding non-`at` function. This will send it through the libpreopen
+// wrappers to convert the path into a directory file descriptor and relative
+// path before translating it into the corresponding `__wasilibc_nocwd_*at`
+// function, which then calls the appropriate WASI function.
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <wasi/libc.h>
+#include <wasi/libc-nocwd.h>
+
+// If the platform doesn't define O_TMPFILE, we don't need to worry about it.
+#ifndef O_TMPFILE
+#define O_TMPFILE 0
+#endif
+
+int openat(int dirfd, const char *pathname, int flags, ...) {
+    if (dirfd == AT_FDCWD || pathname[0] == '/') {
+        return open(pathname, flags);
+    }
+
+    return __wasilibc_nocwd_openat_nomode(dirfd, pathname, flags);
+}
+
+int symlinkat(const char *target, int dirfd, const char *linkpath) {
+    if (dirfd == AT_FDCWD || linkpath[0] == '/') {
+        return symlink(target, linkpath);
+    }
+
+    return __wasilibc_nocwd_symlinkat(target, dirfd, linkpath);
+}
+
+ssize_t readlinkat(int dirfd, const char *__restrict pathname, char *__restrict buf, size_t bufsiz) {
+    if (dirfd == AT_FDCWD || pathname[0] == '/') {
+        return readlink(pathname, buf, bufsiz);
+    }
+
+    return __wasilibc_nocwd_readlinkat(dirfd, pathname, buf, bufsiz);
+}
+
+int mkdirat(int dirfd, const char *pathname, mode_t mode) {
+    if (dirfd == AT_FDCWD || pathname[0] == '/') {
+        return mkdir(pathname, mode);
+    }
+
+    return __wasilibc_nocwd_mkdirat_nomode(dirfd, pathname);
+}
+
+DIR *opendirat(int dirfd, const char *path) {
+    if (dirfd == AT_FDCWD || path[0] == '/') {
+        return opendir(path);
+    }
+
+    return __wasilibc_nocwd_opendirat(dirfd, path);
+}
+
+int scandirat(int dirfd, const char *dirp, struct dirent ***namelist,
+              int (*filter)(const struct dirent *),
+              int (*compar)(const struct dirent **, const struct dirent **)) {
+    if (dirfd == AT_FDCWD || dirp[0] == '/') {
+        return scandir(dirp, namelist, filter, compar);
+    }
+
+    return __wasilibc_nocwd_scandirat(dirfd, dirp, namelist, filter, compar);
+}
+
+int faccessat(int dirfd, const char *pathname, int mode, int flags) {
+    if (dirfd == AT_FDCWD || pathname[0] == '/') {
+        return __wasilibc_access(pathname, mode, flags);
+    }
+
+    return __wasilibc_nocwd_faccessat(dirfd, pathname, mode, flags);
+}
+
+int fstatat(int dirfd, const char *__restrict pathname, struct stat *__restrict statbuf, int flags) {
+    if (dirfd == AT_FDCWD || pathname[0] == '/') {
+        return __wasilibc_stat(pathname, statbuf, flags);
+    }
+
+    return __wasilibc_nocwd_fstatat(dirfd, pathname, statbuf, flags);
+}
+
+int utimensat(int dirfd, const char *pathname, const struct timespec times[2], int flags) {
+    if (dirfd == AT_FDCWD || pathname[0] == '/') {
+        return __wasilibc_utimens(pathname, times, flags);
+    }
+
+    return __wasilibc_nocwd_utimensat(dirfd, pathname, times, flags);
+}
+
+int linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags) {
+    if ((olddirfd == AT_FDCWD || oldpath[0] == '/') &&
+        (newdirfd == AT_FDCWD || newpath[0] == '/')) {
+        return __wasilibc_link(oldpath, newpath, flags);
+    }
+    if (olddirfd == AT_FDCWD || oldpath[0] == '/') {
+        return __wasilibc_link_newat(oldpath, newdirfd, newpath, flags);
+    }
+    if (newdirfd == AT_FDCWD || newpath[0] == '/') {
+        return __wasilibc_link_oldat(olddirfd, oldpath, newpath, flags);
+    }
+
+    return __wasilibc_nocwd_linkat(olddirfd, oldpath, newdirfd, newpath, flags);
+}
+
+int renameat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath) {
+    if ((olddirfd == AT_FDCWD || oldpath[0] == '/') &&
+        (newdirfd == AT_FDCWD || newpath[0] == '/')) {
+        return rename(oldpath, newpath);
+    }
+    if (olddirfd == AT_FDCWD || oldpath[0] == '/') {
+        return __wasilibc_rename_newat(oldpath, newdirfd, newpath);
+    }
+    if (newdirfd == AT_FDCWD || newpath[0] == '/') {
+        return __wasilibc_rename_oldat(olddirfd, oldpath, newpath);
+    }
+
+    return __wasilibc_nocwd_renameat(olddirfd, oldpath, newdirfd, newpath);
+}
+
+int __wasilibc_unlinkat(int dirfd, const char *path) {
+    if (dirfd == AT_FDCWD || path[0] == '/') {
+        return unlink(path);
+    }
+
+    return __wasilibc_nocwd___wasilibc_unlinkat(dirfd, path);
+}
+
+int __wasilibc_rmdirat(int dirfd, const char *path) {
+    if (dirfd == AT_FDCWD || path[0] == '/') {
+        return rmdir(path);
+    }
+
+    return __wasilibc_nocwd___wasilibc_rmdirat(dirfd, path);
+}
diff --git a/libc-bottom-half/sources/chdir.c b/libc-bottom-half/sources/chdir.c
new file mode 100644
index 0000000..37c95a4
--- /dev/null
+++ b/libc-bottom-half/sources/chdir.c
@@ -0,0 +1,171 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <wasi/libc-find-relpath.h>
+#include <wasi/libc.h>
+
+#ifdef _REENTRANT
+void __wasilibc_cwd_lock(void);
+void __wasilibc_cwd_unlock(void);
+#else
+#define __wasilibc_cwd_lock() (void)0
+#define __wasilibc_cwd_unlock() (void)0
+#endif
+extern char *__wasilibc_cwd;
+static int __wasilibc_cwd_mallocd = 0;
+
+int chdir(const char *path)
+{
+    static char *relative_buf = NULL;
+    static size_t relative_buf_len = 0;
+
+    // Find a preopen'd directory as well as a relative path we're anchored
+    // from which we're changing directories to.
+    const char *abs;
+    int parent_fd = __wasilibc_find_relpath_alloc(path, &abs, &relative_buf, &relative_buf_len, 1);
+    if (parent_fd == -1)
+        return -1;
+
+    // Make sure that this directory we're accessing is indeed a directory.
+    struct stat dirinfo;
+    int ret = fstatat(parent_fd, relative_buf, &dirinfo, 0);
+    if (ret == -1)
+        return -1;
+    if (!S_ISDIR(dirinfo.st_mode)) {
+        errno = ENOTDIR;
+        return -1;
+    }
+
+    // Create a string that looks like:
+    //
+    //    __wasilibc_cwd = "/" + abs + "/" + relative_buf
+    //
+    // If `relative_buf` is equal to "." or `abs` is equal to the empty string,
+    // however, we skip that part and the middle slash.
+    size_t abs_len = strlen(abs);
+    int copy_relative = strcmp(relative_buf, ".") != 0;
+    int mid = copy_relative && abs[0] != 0;
+    char *new_cwd = malloc(1 + abs_len + mid + (copy_relative ? strlen(relative_buf) : 0) + 1);
+    if (new_cwd == NULL) {
+        errno = ENOMEM;
+        return -1;
+    }
+    new_cwd[0] = '/';
+    strcpy(new_cwd + 1, abs);
+    if (mid)
+        new_cwd[1 + abs_len] = '/';
+    if (copy_relative)
+        strcpy(new_cwd + 1 + abs_len + mid, relative_buf);
+
+    // And set our new malloc'd buffer into the global cwd, freeing the
+    // previous one if necessary.
+    __wasilibc_cwd_lock();
+    char *prev_cwd = __wasilibc_cwd;
+    __wasilibc_cwd = new_cwd;
+    __wasilibc_cwd_unlock();
+    if (__wasilibc_cwd_mallocd)
+        free(prev_cwd);
+    __wasilibc_cwd_mallocd = 1;
+    return 0;
+}
+
+static const char *make_absolute(const char *path) {
+    static char *make_absolute_buf = NULL;
+    static size_t make_absolute_len = 0;
+
+    // If this path is absolute, then we return it as-is.
+    if (path[0] == '/') {
+        return path;
+    }
+
+#ifndef _REENTRANT
+    // If the path is empty, or points to the current directory, then return
+    // the current directory.
+    if (path[0] == 0 || !strcmp(path, ".") || !strcmp(path, "./")) {
+        return __wasilibc_cwd;
+    }
+#endif
+
+    // If the path starts with `./` then we won't be appending that to the cwd.
+    if (path[0] == '.' && path[1] == '/')
+        path += 2;
+
+    // Otherwise we'll take the current directory, add a `/`, and then add the
+    // input `path`. Note that this doesn't do any normalization (like removing
+    // `/./`).
+    __wasilibc_cwd_lock();
+    size_t cwd_len = strlen(__wasilibc_cwd);
+    size_t path_len = path ? strlen(path) : 0;
+    __wasilibc_cwd_unlock();
+    int need_slash = __wasilibc_cwd[cwd_len - 1] == '/' ? 0 : 1;
+    size_t alloc_len = cwd_len + path_len + 1 + need_slash;
+    if (alloc_len > make_absolute_len) {
+        char *tmp = realloc(make_absolute_buf, alloc_len);
+        if (tmp == NULL) {
+            __wasilibc_cwd_unlock();
+            return NULL;
+        }
+        make_absolute_buf = tmp;
+        make_absolute_len = alloc_len;
+    }
+    strcpy(make_absolute_buf, __wasilibc_cwd);
+    __wasilibc_cwd_unlock();
+
+#ifdef _REENTRANT
+    if (path[0] == 0 || !strcmp(path, ".") || !strcmp(path, "./")) {
+        return make_absolute_buf;
+    }
+#endif
+
+    if (need_slash)
+        strcpy(make_absolute_buf + cwd_len, "/");
+    strcpy(make_absolute_buf + cwd_len + need_slash, path);
+    return make_absolute_buf;
+}
+
+// Helper function defined only in this object file and weakly referenced from
+// `preopens.c` and `posix.c` This function isn't necessary unless `chdir` is
+// pulled in because all paths are otherwise absolute or relative to the root.
+int __wasilibc_find_relpath_alloc(
+    const char *path,
+    const char **abs_prefix,
+    char **relative_buf,
+    size_t *relative_buf_len,
+    int can_realloc
+) {
+    // First, make our path absolute taking the cwd into account.
+    const char *abspath = make_absolute(path);
+    if (abspath == NULL) {
+        errno = ENOMEM;
+        return -1;
+    }
+
+    // Next use our absolute path and split it. Find the preopened `fd` parent
+    // directory and set `abs_prefix`. Next up we'll be trying to fit `rel`
+    // into `relative_buf`.
+    const char *rel;
+    int fd = __wasilibc_find_abspath(abspath, abs_prefix, &rel);
+    if (fd == -1)
+        return -1;
+
+    size_t rel_len = strlen(rel);
+    if (*relative_buf_len < rel_len + 1) {
+        if (!can_realloc) {
+            errno = ERANGE;
+            return -1;
+        }
+        char *tmp = realloc(*relative_buf, rel_len + 1);
+        if (tmp == NULL) {
+            errno = ENOMEM;
+            return -1;
+        }
+        *relative_buf = tmp;
+        *relative_buf_len = rel_len + 1;
+    }
+    strcpy(*relative_buf, rel);
+    return fd;
+}
diff --git a/libc-bottom-half/sources/complex-builtins.c b/libc-bottom-half/sources/complex-builtins.c
new file mode 100644
index 0000000..971d57e
--- /dev/null
+++ b/libc-bottom-half/sources/complex-builtins.c
@@ -0,0 +1,29 @@
+// Each of the following complex functions can be implemented with a single
+// wasm instruction, so use that implementation rather than the portable
+// one in libm.
+
+#include <complex.h>
+
+float (crealf)(float _Complex x) {
+    return __builtin_crealf(x);
+}
+
+double (creal)(double _Complex x) {
+    return __builtin_creal(x);
+}
+
+long double (creall)(long double _Complex x) {
+    return __builtin_creall(x);
+}
+
+float (cimagf)(float _Complex x) {
+    return __builtin_cimagf(x);
+}
+
+double (cimag)(double _Complex x) {
+    return __builtin_cimag(x);
+}
+
+long double (cimagl)(long double _Complex x) {
+    return __builtin_cimagl(x);
+}
diff --git a/libc-bottom-half/sources/environ.c b/libc-bottom-half/sources/environ.c
new file mode 100644
index 0000000..50d60de
--- /dev/null
+++ b/libc-bottom-half/sources/environ.c
@@ -0,0 +1,31 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <sysexits.h>
+#include <wasi/api.h>
+#include <wasi/libc.h>
+#include <wasi/libc-environ.h>
+
+// If the program does use `environ`, it'll get this version of
+// `__wasilibc_environ`, which is initialized with a constructor function, so
+// that it's initialized whenever user code might want to access it.
+char **__wasilibc_environ;
+weak_alias(__wasilibc_environ, _environ);
+weak_alias(__wasilibc_environ, environ);
+
+// We define this function here in the same source file as
+// `__wasilibc_environ`, so that this function is called in iff environment
+// variable support is used.
+// Concerning the 50 -- levels up to 100 are reserved for the implementation,
+// so we an arbitrary number in the middle of the range to allow other
+// reserved things to go before or after.
+__attribute__((constructor(50)))
+static void __wasilibc_initialize_environ_eagerly(void) {
+    __wasilibc_initialize_environ();
+}
+
+// See the comments in libc-environ.h.
+void __wasilibc_maybe_reinitialize_environ_eagerly(void) {
+    // This translation unit is linked in if `environ` is used, meaning we need
+    // to eagerly reinitialize the environment variables.
+    __wasilibc_initialize_environ();
+}
diff --git a/libc-bottom-half/sources/errno.c b/libc-bottom-half/sources/errno.c
new file mode 100644
index 0000000..4e98a5b
--- /dev/null
+++ b/libc-bottom-half/sources/errno.c
@@ -0,0 +1,5 @@
+#include <errno.h>
+
+// These values are used by reference-sysroot's dlmalloc.
+const int __EINVAL = EINVAL;
+const int __ENOMEM = ENOMEM;
diff --git a/libc-bottom-half/sources/getcwd.c b/libc-bottom-half/sources/getcwd.c
new file mode 100644
index 0000000..3b1ce70
--- /dev/null
+++ b/libc-bottom-half/sources/getcwd.c
@@ -0,0 +1,39 @@
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include "lock.h"
+
+char *__wasilibc_cwd = "/";
+
+#ifdef _REENTRANT
+static volatile int lock[1];
+void __wasilibc_cwd_lock(void) { LOCK(lock); }
+void __wasilibc_cwd_unlock(void) { UNLOCK(lock); }
+#else
+#define __wasilibc_cwd_lock() (void)0
+#define __wasilibc_cwd_unlock() (void)0
+#endif
+
+char *getcwd(char *buf, size_t size)
+{
+    __wasilibc_cwd_lock();
+    if (!buf) {
+        buf = strdup(__wasilibc_cwd);
+        if (!buf) {
+            errno = ENOMEM;
+            __wasilibc_cwd_unlock();
+            return NULL;
+        }
+    } else {
+        size_t len = strlen(__wasilibc_cwd);
+        if (size < len + 1) {
+            errno = ERANGE;
+            __wasilibc_cwd_unlock();
+            return NULL;
+        }
+        strcpy(buf, __wasilibc_cwd);
+    }
+    __wasilibc_cwd_unlock();
+    return buf;
+}
+
diff --git a/libc-bottom-half/sources/getentropy.c b/libc-bottom-half/sources/getentropy.c
new file mode 100644
index 0000000..e540e7e
--- /dev/null
+++ b/libc-bottom-half/sources/getentropy.c
@@ -0,0 +1,20 @@
+#include <errno.h>
+#include <unistd.h>
+#include <wasi/api.h>
+
+int __getentropy(void *buffer, size_t len) {
+    if (len > 256) {
+        errno = EIO;
+        return -1;
+    }
+
+    int r = __wasi_random_get(buffer, len);
+
+    if (r != 0) {
+        errno = r;
+        return -1;
+    }
+
+    return 0;
+}
+weak_alias(__getentropy, getentropy);
diff --git a/libc-bottom-half/sources/isatty.c b/libc-bottom-half/sources/isatty.c
new file mode 100644
index 0000000..c6f8662
--- /dev/null
+++ b/libc-bottom-half/sources/isatty.c
@@ -0,0 +1,22 @@
+#include <wasi/api.h>
+#include <__errno.h>
+#include <__function___isatty.h>
+
+int __isatty(int fd) {
+    __wasi_fdstat_t statbuf;
+    int r = __wasi_fd_fdstat_get(fd, &statbuf);
+    if (r != 0) {
+        errno = r;
+        return 0;
+    }
+
+    // A tty is a character device that we can't seek or tell on.
+    if (statbuf.fs_filetype != __WASI_FILETYPE_CHARACTER_DEVICE ||
+        (statbuf.fs_rights_base & (__WASI_RIGHTS_FD_SEEK | __WASI_RIGHTS_FD_TELL)) != 0) {
+        errno = __WASI_ERRNO_NOTTY;
+        return 0;
+    }
+
+    return 1;
+}
+extern __typeof(__isatty) isatty __attribute__((weak, alias("__isatty")));
diff --git a/libc-bottom-half/sources/math/fmin-fmax.c b/libc-bottom-half/sources/math/fmin-fmax.c
new file mode 100644
index 0000000..9293798
--- /dev/null
+++ b/libc-bottom-half/sources/math/fmin-fmax.c
@@ -0,0 +1,34 @@
+// Wasm's `min` and `max` operators implement the IEEE 754-2019
+// `minimum` and `maximum` operations, meaning that given a choice
+// between NaN and a number, they return NaN. This differs from
+// the C standard library's `fmin` and `fmax` functions, which
+// return the number. However, we can still use wasm's builtins
+// by handling the NaN cases explicitly, and it still turns out
+// to be faster than doing the whole operation in
+// target-independent C. And, it's smaller.
+
+#include <math.h>
+
+float fminf(float x, float y) {
+    if (isnan(x)) return y;
+    if (isnan(y)) return x;
+    return __builtin_wasm_min_f32(x, y);
+}
+
+float fmaxf(float x, float y) {
+    if (isnan(x)) return y;
+    if (isnan(y)) return x;
+    return __builtin_wasm_max_f32(x, y);
+}
+
+double fmin(double x, double y) {
+    if (isnan(x)) return y;
+    if (isnan(y)) return x;
+    return __builtin_wasm_min_f64(x, y);
+}
+
+double fmax(double x, double y) {
+    if (isnan(x)) return y;
+    if (isnan(y)) return x;
+    return __builtin_wasm_max_f64(x, y);
+}
diff --git a/libc-bottom-half/sources/math/math-builtins.c b/libc-bottom-half/sources/math/math-builtins.c
new file mode 100644
index 0000000..a5eb7cd
--- /dev/null
+++ b/libc-bottom-half/sources/math/math-builtins.c
@@ -0,0 +1,69 @@
+// Each of the following math functions can be implemented with a single
+// wasm instruction, so use that implementation rather than the portable
+// one in libm.
+
+#include <math.h>
+
+float fabsf(float x) {
+    return __builtin_fabsf(x);
+}
+
+double fabs(double x) {
+    return __builtin_fabs(x);
+}
+
+float sqrtf(float x) {
+    return __builtin_sqrtf(x);
+}
+
+double sqrt(double x) {
+    return __builtin_sqrt(x);
+}
+
+float copysignf(float x, float y) {
+    return __builtin_copysignf(x, y);
+}
+
+double copysign(double x, double y) {
+    return __builtin_copysign(x, y);
+}
+
+float ceilf(float x) {
+    return __builtin_ceilf(x);
+}
+
+double ceil(double x) {
+    return __builtin_ceil(x);
+}
+
+float floorf(float x) {
+    return __builtin_floorf(x);
+}
+
+double floor(double x) {
+    return __builtin_floor(x);
+}
+
+float truncf(float x) {
+    return __builtin_truncf(x);
+}
+
+double trunc(double x) {
+    return __builtin_trunc(x);
+}
+
+float nearbyintf(float x) {
+    return __builtin_nearbyintf(x);
+}
+
+double nearbyint(double x) {
+    return __builtin_nearbyint(x);
+}
+
+float rintf(float x) {
+    return __builtin_rintf(x);
+}
+
+double rint(double x) {
+    return __builtin_rint(x);
+}
diff --git a/libc-bottom-half/sources/posix.c b/libc-bottom-half/sources/posix.c
new file mode 100644
index 0000000..35dd99b
--- /dev/null
+++ b/libc-bottom-half/sources/posix.c
@@ -0,0 +1,449 @@
+//! POSIX-like functions supporting absolute path arguments, implemented in
+//! terms of `__wasilibc_find_relpath` and `*at`-style functions.
+
+#include <errno.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <utime.h>
+#include <wasi/libc.h>
+#include <wasi/libc-find-relpath.h>
+#include <wasi/libc-nocwd.h>
+
+static int find_relpath2(
+    const char *path,
+    char **relative,
+    size_t *relative_len
+) {
+    // See comments in `preopens.c` for what this trick is doing.
+    const char *abs;
+    if (__wasilibc_find_relpath_alloc)
+        return __wasilibc_find_relpath_alloc(path, &abs, relative, relative_len, 1);
+    return __wasilibc_find_relpath(path, &abs, relative, *relative_len);
+}
+
+// Helper to call `__wasilibc_find_relpath` and return an already-managed
+// pointer for the `relative` path. This function is not reentrant since the
+// `relative` pointer will point to static data that cannot be reused until
+// `relative` is no longer used.
+static int find_relpath(const char *path, char **relative) {
+    static __thread char *relative_buf = NULL;
+    static __thread size_t relative_buf_len = 0;
+    int fd = find_relpath2(path, &relative_buf, &relative_buf_len);
+    // find_relpath2 can update relative_buf, so assign it after the call
+    *relative = relative_buf;
+    return fd;
+}
+
+// same as `find_relpath`, but uses another set of static variables to cache
+static int find_relpath_alt(const char *path, char **relative) {
+    static __thread char *relative_buf = NULL;
+    static __thread size_t relative_buf_len = 0;
+    int fd = find_relpath2(path, &relative_buf, &relative_buf_len);
+    // find_relpath2 can update relative_buf, so assign it after the call
+    *relative = relative_buf;
+    return fd;
+}
+
+int open(const char *path, int oflag, ...) {
+    // WASI libc's `openat` ignores the mode argument, so call a special
+    // entrypoint which avoids the varargs calling convention.
+    return __wasilibc_open_nomode(path, oflag);
+}
+
+// See the documentation in libc.h
+int __wasilibc_open_nomode(const char *path, int oflag) {
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_openat_nomode(dirfd, relative_path, oflag);
+}
+
+int access(const char *path, int amode) {
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_faccessat(dirfd, relative_path, amode, 0);
+}
+
+ssize_t readlink(
+    const char *restrict path,
+    char *restrict buf,
+    size_t bufsize)
+{
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_readlinkat(dirfd, relative_path, buf, bufsize);
+}
+
+int stat(const char *restrict path, struct stat *restrict buf) {
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_fstatat(dirfd, relative_path, buf, 0);
+}
+
+int lstat(const char *restrict path, struct stat *restrict buf) {
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_fstatat(dirfd, relative_path, buf, AT_SYMLINK_NOFOLLOW);
+}
+
+int utime(const char *path, const struct utimbuf *times) {
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_utimensat(
+             dirfd, relative_path,
+                     times ? ((struct timespec [2]) {
+                                 { .tv_sec = times->actime },
+                                 { .tv_sec = times->modtime }
+                             })
+                           : NULL,
+                     0);
+}
+
+int utimes(const char *path, const struct timeval times[2]) {
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_utimensat(
+             dirfd, relative_path,
+                     times ? ((struct timespec [2]) {
+                                 { .tv_sec = times[0].tv_sec,
+				   .tv_nsec = times[0].tv_usec * 1000 },
+                                 { .tv_sec = times[1].tv_sec,
+				   .tv_nsec = times[1].tv_usec * 1000 },
+                             })
+                           : NULL,
+                     0);
+}
+
+int unlink(const char *path) {
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    // `unlinkat` imports `__wasi_path_remove_directory` even when
+    // `AT_REMOVEDIR` isn't passed. Instead, use a specialized function which
+    // just imports `__wasi_path_unlink_file`.
+    return __wasilibc_nocwd___wasilibc_unlinkat(dirfd, relative_path);
+}
+
+int rmdir(const char *path) {
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd___wasilibc_rmdirat(dirfd, relative_path);
+}
+
+int remove(const char *path) {
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    // First try to remove it as a file.
+    int r = __wasilibc_nocwd___wasilibc_unlinkat(dirfd, relative_path);
+    if (r != 0 && (errno == EISDIR || errno == ENOTCAPABLE)) {
+        // That failed, but it might be a directory.
+        r = __wasilibc_nocwd___wasilibc_rmdirat(dirfd, relative_path);
+
+        // If it isn't a directory, we lack capabilities to remove it as a file.
+        if (errno == ENOTDIR)
+            errno = ENOTCAPABLE;
+    }
+    return r;
+}
+
+int mkdir(const char *path, mode_t mode) {
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_mkdirat_nomode(dirfd, relative_path);
+}
+
+DIR *opendir(const char *dirname) {
+    char *relative_path;
+    int dirfd = find_relpath(dirname, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return NULL;
+    }
+
+    return __wasilibc_nocwd_opendirat(dirfd, relative_path);
+}
+
+int scandir(
+    const char *restrict dir,
+    struct dirent ***restrict namelist,
+    int (*filter)(const struct dirent *),
+    int (*compar)(const struct dirent **, const struct dirent **)
+) {
+    char *relative_path;
+    int dirfd = find_relpath(dir, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_scandirat(dirfd, relative_path, namelist, filter, compar);
+}
+
+int symlink(const char *target, const char *linkpath) {
+    char *relative_path;
+    int dirfd = find_relpath(linkpath, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_symlinkat(target, dirfd, relative_path);
+}
+
+int link(const char *old, const char *new) {
+    char *old_relative_path;
+    int old_dirfd = find_relpath_alt(old, &old_relative_path);
+
+    if (old_dirfd != -1) {
+        char *new_relative_path;
+        int new_dirfd = find_relpath(new, &new_relative_path);
+
+        if (new_dirfd != -1)
+            return __wasilibc_nocwd_linkat(old_dirfd, old_relative_path,
+                                           new_dirfd, new_relative_path, 0);
+    }
+
+    // We couldn't find a preopen for it; indicate that we lack capabilities.
+    errno = ENOTCAPABLE;
+    return -1;
+}
+
+int rename(const char *old, const char *new) {
+    char *old_relative_path;
+    int old_dirfd = find_relpath_alt(old, &old_relative_path);
+
+    if (old_dirfd != -1) {
+        char *new_relative_path;
+        int new_dirfd = find_relpath(new, &new_relative_path);
+
+        if (new_dirfd != -1)
+            return __wasilibc_nocwd_renameat(old_dirfd, old_relative_path,
+                                             new_dirfd, new_relative_path);
+    }
+
+    // We couldn't find a preopen for it; indicate that we lack capabilities.
+    errno = ENOTCAPABLE;
+    return -1;
+}
+
+// Like `access`, but with `faccessat`'s flags argument.
+int
+__wasilibc_access(const char *path, int mode, int flags)
+{
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_faccessat(dirfd, relative_path,
+                                      mode, flags);
+}
+
+// Like `utimensat`, but without the `at` part.
+int
+__wasilibc_utimens(const char *path, const struct timespec times[2], int flags)
+{
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_utimensat(dirfd, relative_path,
+                                      times, flags);
+}
+
+// Like `stat`, but with `fstatat`'s flags argument.
+int
+__wasilibc_stat(const char *__restrict path, struct stat *__restrict st, int flags)
+{
+    char *relative_path;
+    int dirfd = find_relpath(path, &relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_fstatat(dirfd, relative_path, st, flags);
+}
+
+// Like `link`, but with `linkat`'s flags argument.
+int
+__wasilibc_link(const char *oldpath, const char *newpath, int flags)
+{
+    char *old_relative_path;
+    char *new_relative_path;
+    int old_dirfd = find_relpath(oldpath, &old_relative_path);
+    int new_dirfd = find_relpath(newpath, &new_relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (old_dirfd == -1 || new_dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_linkat(old_dirfd, old_relative_path,
+                                   new_dirfd, new_relative_path,
+                                   flags);
+}
+
+// Like `__wasilibc_link`, but oldpath is relative to olddirfd.
+int
+__wasilibc_link_oldat(int olddirfd, const char *oldpath, const char *newpath, int flags)
+{
+    char *new_relative_path;
+    int new_dirfd = find_relpath(newpath, &new_relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (new_dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_linkat(olddirfd, oldpath,
+                                   new_dirfd, new_relative_path,
+                                   flags);
+}
+
+// Like `__wasilibc_link`, but newpath is relative to newdirfd.
+int
+__wasilibc_link_newat(const char *oldpath, int newdirfd, const char *newpath, int flags)
+{
+    char *old_relative_path;
+    int old_dirfd = find_relpath(oldpath, &old_relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (old_dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_linkat(old_dirfd, old_relative_path,
+                                   newdirfd, newpath,
+                                   flags);
+}
+
+// Like `rename`, but from is relative to fromdirfd.
+int
+__wasilibc_rename_oldat(int fromdirfd, const char *from, const char *to)
+{
+    char *to_relative_path;
+    int to_dirfd = find_relpath(to, &to_relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (to_dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_renameat(fromdirfd, from, to_dirfd, to_relative_path);
+}
+
+// Like `rename`, but to is relative to todirfd.
+int
+__wasilibc_rename_newat(const char *from, int todirfd, const char *to)
+{
+    char *from_relative_path;
+    int from_dirfd = find_relpath(from, &from_relative_path);
+
+    // If we can't find a preopen for it, indicate that we lack capabilities.
+    if (from_dirfd == -1) {
+        errno = ENOTCAPABLE;
+        return -1;
+    }
+
+    return __wasilibc_nocwd_renameat(from_dirfd, from_relative_path, todirfd, to);
+}
diff --git a/libc-bottom-half/sources/preopens.c b/libc-bottom-half/sources/preopens.c
new file mode 100644
index 0000000..7293c8c
--- /dev/null
+++ b/libc-bottom-half/sources/preopens.c
@@ -0,0 +1,268 @@
+//! Support for "preopens", file descriptors passed into the program from the
+//! environment, with associated path prefixes, which can be used to map
+//! absolute paths to capabilities with relative paths.
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <lock.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sysexits.h>
+#include <wasi/api.h>
+#include <wasi/libc-find-relpath.h>
+#include <wasi/libc.h>
+
+/// A name and file descriptor pair.
+typedef struct preopen {
+    /// The path prefix associated with the file descriptor.
+    const char *prefix;
+
+    /// The file descriptor.
+    __wasi_fd_t fd;
+} preopen;
+
+/// A simple growable array of `preopen`.
+static preopen *preopens;
+static size_t num_preopens;
+static size_t preopen_capacity;
+
+/// Access to the the above preopen must be protected in the presence of
+/// threads.
+#ifdef _REENTRANT
+static volatile int lock[1];
+#endif
+
+#ifdef NDEBUG
+#define assert_invariants() // assertions disabled
+#else
+static void assert_invariants(void) {
+    assert(num_preopens <= preopen_capacity);
+    assert(preopen_capacity == 0 || preopens != NULL);
+    assert(preopen_capacity == 0 ||
+           preopen_capacity * sizeof(preopen) > preopen_capacity);
+
+    for (size_t i = 0; i < num_preopens; ++i) {
+        const preopen *pre = &preopens[i];
+        assert(pre->prefix != NULL);
+        assert(pre->fd != (__wasi_fd_t)-1);
+#ifdef __wasm__
+        assert((uintptr_t)pre->prefix <
+               (__uint128_t)__builtin_wasm_memory_size(0) * PAGESIZE);
+#endif
+    }
+}
+#endif
+
+/// Allocate space for more preopens. Returns 0 on success and -1 on failure.
+static int resize(void) {
+    LOCK(lock);
+    size_t start_capacity = 4;
+    size_t old_capacity = preopen_capacity;
+    size_t new_capacity = old_capacity == 0 ? start_capacity : old_capacity * 2;
+
+    preopen *old_preopens = preopens;
+    preopen *new_preopens = calloc(sizeof(preopen), new_capacity);
+    if (new_preopens == NULL) {
+        UNLOCK(lock);
+        return -1;
+    }
+
+    memcpy(new_preopens, old_preopens, num_preopens * sizeof(preopen));
+    preopens = new_preopens;
+    preopen_capacity = new_capacity;
+    free(old_preopens);
+
+    assert_invariants();
+    UNLOCK(lock);
+    return 0;
+}
+
+// Normalize an absolute path. Removes leading `/` and leading `./`, so the
+// first character is the start of a directory name. This works because our
+// process always starts with a working directory of `/`. Additionally translate
+// `.` to the empty string.
+static const char *strip_prefixes(const char *path) {
+    while (1) {
+        if (path[0] == '/') {
+            path++;
+        } else if (path[0] == '.' && path[1] == '/') {
+            path += 2;
+        } else if (path[0] == '.' && path[1] == 0) {
+            path++;
+        } else {
+            break;
+        }
+    }
+
+    return path;
+}
+
+/// Register the given preopened file descriptor under the given path.
+///
+/// This function takes ownership of `prefix`.
+static int internal_register_preopened_fd(__wasi_fd_t fd, const char *relprefix) {
+    LOCK(lock);
+
+    // Check preconditions.
+    assert_invariants();
+    assert(fd != AT_FDCWD);
+    assert(fd != -1);
+    assert(relprefix != NULL);
+
+    if (num_preopens == preopen_capacity && resize() != 0) {
+        UNLOCK(lock);
+        return -1;
+    }
+
+    char *prefix = strdup(strip_prefixes(relprefix));
+    if (prefix == NULL) {
+        UNLOCK(lock);
+        return -1;
+    }
+    preopens[num_preopens++] = (preopen) { prefix, fd, };
+
+    assert_invariants();
+    UNLOCK(lock);
+    return 0;
+}
+
+/// Are the `prefix_len` bytes pointed to by `prefix` a prefix of `path`?
+static bool prefix_matches(const char *prefix, size_t prefix_len, const char *path) {
+    // Allow an empty string as a prefix of any relative path.
+    if (path[0] != '/' && prefix_len == 0)
+        return true;
+
+    // Check whether any bytes of the prefix differ.
+    if (memcmp(path, prefix, prefix_len) != 0)
+        return false;
+
+    // Ignore trailing slashes in directory names.
+    size_t i = prefix_len;
+    while (i > 0 && prefix[i - 1] == '/') {
+        --i;
+    }
+
+    // Match only complete path components.
+    char last = path[i];
+    return last == '/' || last == '\0';
+}
+
+// See the documentation in libc.h
+int __wasilibc_register_preopened_fd(int fd, const char *prefix) {
+    return internal_register_preopened_fd((__wasi_fd_t)fd, prefix);
+}
+
+// See the documentation in libc-find-relpath.h.
+int __wasilibc_find_relpath(const char *path,
+                            const char **abs_prefix,
+                            char **relative_path,
+                            size_t relative_path_len) {
+    // If `chdir` is linked, whose object file defines this symbol, then we
+    // call that. Otherwise if the program can't `chdir` then `path` is
+    // absolute (or relative to the root dir), so we delegate to `find_abspath`
+    if (__wasilibc_find_relpath_alloc)
+        return __wasilibc_find_relpath_alloc(path, abs_prefix, relative_path, &relative_path_len, 0);
+    return __wasilibc_find_abspath(path, abs_prefix, (const char**) relative_path);
+}
+
+// See the documentation in libc-find-relpath.h.
+int __wasilibc_find_abspath(const char *path,
+                            const char **abs_prefix,
+                            const char **relative_path) {
+    // Strip leading `/` characters, the prefixes we're mataching won't have
+    // them.
+    while (*path == '/')
+        path++;
+    // Search through the preopens table. Iterate in reverse so that more
+    // recently added preopens take precedence over less recently addded ones.
+    size_t match_len = 0;
+    int fd = -1;
+    LOCK(lock);
+    for (size_t i = num_preopens; i > 0; --i) {
+        const preopen *pre = &preopens[i - 1];
+        const char *prefix = pre->prefix;
+        size_t len = strlen(prefix);
+
+        // If we haven't had a match yet, or the candidate path is longer than
+        // our current best match's path, and the candidate path is a prefix of
+        // the requested path, take that as the new best path.
+        if ((fd == -1 || len > match_len) &&
+            prefix_matches(prefix, len, path))
+        {
+            fd = pre->fd;
+            match_len = len;
+            *abs_prefix = prefix;
+        }
+    }
+    UNLOCK(lock);
+
+    if (fd == -1) {
+        errno = ENOENT;
+        return -1;
+    }
+
+    // The relative path is the substring after the portion that was matched.
+    const char *computed = path + match_len;
+
+    // Omit leading slashes in the relative path.
+    while (*computed == '/')
+        ++computed;
+
+    // *at syscalls don't accept empty relative paths, so use "." instead.
+    if (*computed == '\0')
+        computed = ".";
+
+    *relative_path = computed;
+    return fd;
+}
+
+/// This is referenced by weak reference from crt1.c and lives in the same
+/// source file as `__wasilibc_find_relpath` so that it's linked in when it's
+/// needed.
+// Concerning the 51 -- see the comment by the constructor priority in
+// libc-bottom-half/sources/environ.c.
+__attribute__((constructor(51)))
+static void __wasilibc_populate_preopens(void) {
+    // Skip stdin, stdout, and stderr, and count up until we reach an invalid
+    // file descriptor.
+    for (__wasi_fd_t fd = 3; fd != 0; ++fd) {
+        __wasi_prestat_t prestat;
+        __wasi_errno_t ret = __wasi_fd_prestat_get(fd, &prestat);
+        if (ret == __WASI_ERRNO_BADF)
+            break;
+        if (ret != __WASI_ERRNO_SUCCESS)
+            goto oserr;
+        switch (prestat.tag) {
+        case __WASI_PREOPENTYPE_DIR: {
+            char *prefix = malloc(prestat.u.dir.pr_name_len + 1);
+            if (prefix == NULL)
+                goto software;
+
+            // TODO: Remove the cast on `path` once the witx is updated with
+            // char8 support.
+            ret = __wasi_fd_prestat_dir_name(fd, (uint8_t *)prefix,
+                                             prestat.u.dir.pr_name_len);
+            if (ret != __WASI_ERRNO_SUCCESS)
+                goto oserr;
+            prefix[prestat.u.dir.pr_name_len] = '\0';
+
+            if (internal_register_preopened_fd(fd, prefix) != 0)
+                goto software;
+            free(prefix);
+
+            break;
+        }
+        default:
+            break;
+        }
+    }
+
+    return;
+oserr:
+    _Exit(EX_OSERR);
+software:
+    _Exit(EX_SOFTWARE);
+}
diff --git a/libc-bottom-half/sources/reallocarray.c b/libc-bottom-half/sources/reallocarray.c
new file mode 100644
index 0000000..3e828cc
--- /dev/null
+++ b/libc-bottom-half/sources/reallocarray.c
@@ -0,0 +1,14 @@
+#include <stdlib.h>
+#include <errno.h>
+
+void *__reallocarray(void *ptr, size_t nmemb, size_t size) {
+    size_t bytes;
+    if (__builtin_umull_overflow(nmemb, size, &bytes)) {
+        errno = ENOMEM;
+        return NULL;
+    }
+    return realloc(ptr, bytes);
+}
+
+void *reallocarray(void *ptr, size_t nmemb, size_t size)
+    __attribute__((__weak__, __alias__("__reallocarray")));
diff --git a/libc-bottom-half/sources/sbrk.c b/libc-bottom-half/sources/sbrk.c
new file mode 100644
index 0000000..a26b75e
--- /dev/null
+++ b/libc-bottom-half/sources/sbrk.c
@@ -0,0 +1,32 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <__macro_PAGESIZE.h>
+
+// Bare-bones implementation of sbrk.
+void *sbrk(intptr_t increment) {
+    // sbrk(0) returns the current memory size.
+    if (increment == 0) {
+        // The wasm spec doesn't guarantee that memory.grow of 0 always succeeds.
+        return (void *)(__builtin_wasm_memory_size(0) * PAGESIZE);
+    }
+
+    // We only support page-size increments.
+    if (increment % PAGESIZE != 0) {
+        abort();
+    }
+
+    // WebAssembly doesn't support shrinking linear memory.
+    if (increment < 0) {
+        abort();
+    }
+
+    uintptr_t old = __builtin_wasm_memory_grow(0, (uintptr_t)increment / PAGESIZE);
+
+    if (old == SIZE_MAX) {
+        errno = ENOMEM;
+        return (void *)-1;
+    }
+
+    return (void *)(old * PAGESIZE);
+}
diff --git a/libc-bottom-half/sources/truncate.c b/libc-bottom-half/sources/truncate.c
new file mode 100644
index 0000000..24ae28f
--- /dev/null
+++ b/libc-bottom-half/sources/truncate.c
@@ -0,0 +1,21 @@
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <wasi/libc.h>
+
+int truncate(const char *path, off_t length)
+{
+    int fd = __wasilibc_open_nomode(path, O_WRONLY | O_CLOEXEC | O_NOCTTY);
+    if (fd < 0)
+        return -1;
+
+    int result = ftruncate(fd, length);
+    if (result != 0) {
+        int save_errno = errno;
+        (void)close(fd);
+        errno = save_errno;
+        return -1;
+    }
+
+    return close(fd);
+}