2025-08-03 08:20:28 +00:00
542 changed files with 7486 additions and 12616 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -1,8 +1,5 @@
 name: build

-env:
-  COSMOCC_VERSION: 3.9.2
-
 on:
  push:
    branches:
@ -22,48 +19,13 @@ jobs:
      matrix:
        mode: ["", tiny, rel, tinylinux, optlinux]
    steps:
-      - uses: actions/checkout@v4
-        with:
-          # Full checkout needed for git-restore-mtime-bare.
-          fetch-depth: 0
-
-      # TODO(jart): fork this action.
-      - uses: chetan/git-restore-mtime-action@v2
-
-      - uses: actions/cache/restore@v4
-        id: cache
-        with:
-          path: |
-            .cosmocc
-            o
-          key: ${{ env.COSMOCC_VERSION }}-${{ matrix.mode }}-${{ github.sha }}
-          restore-keys: |
-            ${{ env.COSMOCC_VERSION }}-${{ matrix.mode }}-
-            ${{ env.COSMOCC_VERSION }}-
-
-      - name: Restore mtimes
-        if: steps.cache.outputs.cache-hit == 'true'
-        run: |
-          while read mtime file; do
-            [ -f "$file" ] && touch -d "@$mtime" "$file"
-          done < o/.mtimes
+      - uses: actions/checkout@v3

      - name: support ape bins 1
-        run: sudo cp -a build/bootstrap/ape.elf /usr/bin/ape
+        run: sudo cp build/bootstrap/ape.elf /usr/bin/ape

      - name: support ape bins 2
        run: sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"

      - name: make matrix
        run: V=0 make -j2 MODE=${{ matrix.mode }}
-
-      - name: Save mtimes
-        run: |
-          find o -type f -exec stat -c "%Y %n" {} \; > o/.mtimes
-
-      - uses: actions/cache/save@v4
-        with:
-          path: |
-            .cosmocc
-            o
-          key: ${{ env.COSMOCC_VERSION }}-${{ matrix.mode }}-${{ github.sha }}
--- a/.gitignore
+++ b/.gitignore
@ -15,4 +15,3 @@ __pycache__
 /tool/emacs/*.elc
 /perf.data
 /perf.data.old
-/qemu*core
--- a/20
+++ b/20
@ -77,8 +77,7 @@ COMMA := ,
 PWD := $(shell pwd)

 # detect wsl2 running cosmopolitan binaries on the host by checking whether:
-# - user ran .cosmocc/current/bin/make, in which case make's working directory
-#   is in wsl
+# - user ran build/bootstrap/make, in which case make's working directory is in wsl
 # - user ran make, in which case cocmd's working directory is in wsl
 ifneq ($(findstring //wsl.localhost/,$(CURDIR) $(PWD)),)
 $(warning wsl2 interop is enabled)
@ -90,7 +89,7 @@ UNAME_S := $(shell uname -s)

 # apple still distributes a 17 year old version of gnu make
 ifeq ($(MAKE_VERSION), 3.81)
-$(error please use https://cosmo.zip/pub/cosmos/bin/make)
+$(error please use build/bootstrap/make)
 endif

 LC_ALL = C
@ -136,7 +135,7 @@ ARCH = aarch64
 HOSTS ?= pi pi5 studio freebsdarm
 else
 ARCH = x86_64
-HOSTS ?= freebsd rhel7 xnu openbsd netbsd win10 luna
+HOSTS ?= freebsd rhel7 xnu openbsd netbsd win10
 endif

 ZIPOBJ_FLAGS += -a$(ARCH)
@ -275,10 +274,6 @@ include libc/BUILD.mk				#─┘
 include libc/sock/BUILD.mk			#─┐
 include net/http/BUILD.mk			# ├──ONLINE RUNTIME
 include third_party/musl/BUILD.mk		# │  You can communicate with the network
-include third_party/regex/BUILD.mk		# │
-include third_party/tr/BUILD.mk			# │
-include third_party/sed/BUILD.mk		# │
-include libc/system/BUILD.mk			# │
 include libc/x/BUILD.mk				# │
 include dsp/scale/BUILD.mk			# │
 include dsp/mpeg/BUILD.mk			# │
@ -298,7 +293,8 @@ include third_party/libcxx/BUILD.mk		# │
 include third_party/openmp/BUILD.mk		# │
 include third_party/pcre/BUILD.mk		# │
 include third_party/less/BUILD.mk		# │
-include net/https/BUILD.mk			#─┘
+include net/https/BUILD.mk			# │
+include third_party/regex/BUILD.mk		#─┘
 include third_party/tidy/BUILD.mk
 include third_party/BUILD.mk
 include third_party/nsync/testing/BUILD.mk
@ -317,6 +313,8 @@ include third_party/double-conversion/test/BUILD.mk
 include third_party/lua/BUILD.mk
 include third_party/tree/BUILD.mk
 include third_party/zstd/BUILD.mk
+include third_party/tr/BUILD.mk
+include third_party/sed/BUILD.mk
 include third_party/awk/BUILD.mk
 include third_party/hiredis/BUILD.mk
 include third_party/make/BUILD.mk
@ -369,7 +367,6 @@ include test/libc/fmt/BUILD.mk
 include test/libc/time/BUILD.mk
 include test/libc/proc/BUILD.mk
 include test/libc/stdio/BUILD.mk
-include test/libc/system/BUILD.mk
 include test/libc/BUILD.mk
 include test/net/http/BUILD.mk
 include test/net/https/BUILD.mk
@ -452,6 +449,7 @@ COSMOPOLITAN =				\
 	LIBC_NT_BCRYPTPRIMITIVES	\
 	LIBC_NT_COMDLG32		\
 	LIBC_NT_GDI32			\
+	LIBC_NT_SHELL32			\
 	LIBC_NT_IPHLPAPI		\
 	LIBC_NT_KERNEL32		\
 	LIBC_NT_NTDLL			\
@ -459,7 +457,6 @@ COSMOPOLITAN =				\
 	LIBC_NT_POWRPROF		\
 	LIBC_NT_PSAPI			\
 	LIBC_NT_REALTIME		\
-	LIBC_NT_SHELL32			\
 	LIBC_NT_SYNCHRONIZATION		\
 	LIBC_NT_USER32			\
 	LIBC_NT_WS2_32			\
@ -468,7 +465,6 @@ COSMOPOLITAN =				\
 	LIBC_SOCK			\
 	LIBC_STDIO			\
 	LIBC_STR			\
-	LIBC_SYSTEM			\
 	LIBC_SYSV			\
 	LIBC_SYSV_CALLS			\
 	LIBC_THREAD			\
--- a/README.md
+++ b/README.md
@ -3,7 +3,7 @@
 [![build](https://github.com/jart/cosmopolitan/actions/workflows/build.yml/badge.svg)](https://github.com/jart/cosmopolitan/actions/workflows/build.yml)
 # Cosmopolitan

-[Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C/C++
+[Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C
 a build-once run-anywhere language, like Java, except it doesn't need an
 interpreter or virtual machine. Instead, it reconfigures stock GCC and
 Clang to output a POSIX-approved polyglot format that runs natively on
@ -87,22 +87,15 @@ ape/apeinstall.sh
 ```

 You can now build the mono repo with any modern version of GNU Make. To
-bootstrap your build, you can install Cosmopolitan Make from this site:
-
-https://cosmo.zip/pub/cosmos/bin/make
-
-E.g.:
+make life easier, we've included one in the cosmocc toolchain, which is
+guaranteed to be compatible and furthermore includes our extensions for
+doing build system sandboxing.

 ```sh
-curl -LO https://cosmo.zip/pub/cosmos/bin/make
-./make -j8
+build/bootstrap/make -j8
 o//examples/hello
 ```

-After you've built the repo once, you can also use the make from your
-cosmocc at `.cosmocc/current/bin/make`. You might even prefer to alias
-make to `$COSMO/.cosmocc/current/bin/make`.
-
 Since the Cosmopolitan repository is very large, you might only want to
 build one particular thing. Here's an example of a target that can be
 compiled relatively quickly, which is a simple POSIX test that only
@ -110,7 +103,7 @@ depends on core LIBC packages.

 ```sh
 rm -rf o//libc o//test
-.cosmocc/current/bin/make o//test/posix/signal_test
+build/bootstrap/make o//test/posix/signal_test
 o//test/posix/signal_test
 ```

@ -119,21 +112,21 @@ list out each individual one. For example if you wanted to build and run
 all the unit tests in the `TEST_POSIX` package, you could say:

 ```sh
-.cosmocc/current/bin/make o//test/posix
+build/bootstrap/make o//test/posix
 ```

 Cosmopolitan provides a variety of build modes. For example, if you want
 really tiny binaries (as small as 12kb in size) then you'd say:

 ```sh
-.cosmocc/current/bin/make m=tiny
+build/bootstrap/make m=tiny
 ```

 You can furthermore cut out the bloat of other operating systems, and
 have Cosmopolitan become much more similar to Musl Libc.

 ```sh
-.cosmocc/current/bin/make m=tinylinux
+build/bootstrap/make m=tinylinux
 ```

 For further details, see [//build/config.mk](build/config.mk).
--- a/ape/aarch64.lds
+++ b/ape/aarch64.lds
@ -259,9 +259,6 @@ SECTIONS {
  .debug_ranges       0 : { *(.debug_ranges) }
  .debug_macro        0 : { *(.debug_macro) }
  .debug_addr         0 : { *(.debug_addr) }
-  .debug_names        0 : { *(.debug_names) }
-  .debug_loclists     0 : { *(.debug_loclists) }
-  .debug_str_offsets  0 : { *(.debug_str_offsets) }
  .ARM.attributes     0 : { KEEP(*(.ARM.attributes)) KEEP(*(.gnu.attributes)) }
  .note.gnu.arm.ident 0 : { KEEP(*(.note.gnu.arm.ident)) }

--- a/ape/ape.lds
+++ b/ape/ape.lds
@ -386,13 +386,6 @@ SECTIONS {
    _tbss_end = .;
  } :Tls

-  .eh_frame : {
-    __eh_frame_start = .;
-    KEEP(*(.eh_frame))
-    *(.eh_frame.*)
-    __eh_frame_end = .;
-  } :Ram
-
  .data . : {
 /*BEGIN: Read/Write Data */
 #if SupportsWindows()
@ -433,6 +426,11 @@ SECTIONS {
    KEEP(*(.dtors))
    __fini_array_end = .;

+    __eh_frame_start = .;
+    KEEP(*(.eh_frame))
+    *(.eh_frame.*)
+    __eh_frame_end = .;
+
 /*BEGIN: Post-Initialization Read-Only */
    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
    KEEP(*(SORT_BY_NAME(.piro.relo.sort.*)))
@ -441,6 +439,7 @@ SECTIONS {
    KEEP(*(.piro.pad.data))
    *(.igot.plt)
    KEEP(*(.dataepilogue))
+
    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
 /*END: NT FORK COPYING */
    _edata = .;
@ -520,9 +519,6 @@ SECTIONS {
  .debug_rnglists    0 : { *(.debug_rnglists) }
  .debug_macro       0 : { *(.debug_macro) }
  .debug_addr        0 : { *(.debug_addr) }
-  .debug_names       0 : { *(.debug_names) }
-  .debug_loclists    0 : { *(.debug_loclists) }
-  .debug_str_offsets 0 : { *(.debug_str_offsets) }
  .gnu.attributes    0 : { KEEP(*(.gnu.attributes)) }
  .GCC.command.line  0 : { *(.GCC.command.line) }

@ -586,11 +582,11 @@ ape_rom_memsz = ape_rom_filesz;
 ape_rom_align = CONSTANT(COMMONPAGESIZE);
 ape_rom_rva = RVA(ape_rom_vaddr);

-ape_ram_vaddr = ADDR(.eh_frame);
+ape_ram_vaddr = ADDR(.data);
 ape_ram_offset = ape_ram_vaddr - __executable_start;
-ape_ram_paddr = LOADADDR(.eh_frame);
-ape_ram_filesz = ADDR(.bss) - ADDR(.eh_frame);
-ape_ram_memsz = _end - ADDR(.eh_frame);
+ape_ram_paddr = LOADADDR(.data);
+ape_ram_filesz = ADDR(.bss) - ADDR(.data);
+ape_ram_memsz = _end - ADDR(.data);
 ape_ram_align = CONSTANT(COMMONPAGESIZE);
 ape_ram_rva = RVA(ape_ram_vaddr);

@ -600,7 +596,7 @@ ape_stack_offset = 0;
 ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000;
 ape_stack_paddr = ape_ram_paddr + ape_ram_filesz;
 ape_stack_filesz = 0;
-ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : 4 * 1024 * 1024;
+ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : 8 * 1024 * 1024;

 ape_note_offset = ape_cod_offset + (ape_note - ape_cod_vaddr);
 ape_note_filesz = ape_note_end - ape_note;
--- a/ape/apeinstall.sh
+++ b/ape/apeinstall.sh
@ -10,8 +10,8 @@ if [ ! -f ape/loader.c ]; then
  cd "$COSMO" || exit
 fi

-if [ -x .cosmocc/current/bin/make ]; then
-  MAKE=.cosmocc/current/bin/make
+if [ -x build/bootstrap/make ]; then
+  MAKE=build/bootstrap/make
 else
  MAKE=make
 fi
--- a/build/download-cosmocc.sh
+++ b/build/download-cosmocc.sh
@ -99,8 +99,3 @@ rm -f cosmocc.zip cosmocc.zip.sha256sum
 # commit output directory
 cd "${OLDPWD}" || die
 mv "${OUTPUT_TMP}" "${OUTPUT_DIR}" || die
-
-# update current symlink
-BASE=$(basename "${OUTPUT_DIR}")
-DIR=$(dirname "${OUTPUT_DIR}")
-ln -sfn "$BASE" "$DIR/current"
--- a/ctl/shared_ptr.h
+++ b/ctl/shared_ptr.h
@ -97,12 +97,12 @@ class shared_ref

    size_t use_count() const noexcept
    {
-        return __atomic_load_n(&shared, __ATOMIC_RELAXED) + 1;
+        return shared + 1;
    }

    size_t weak_count() const noexcept
    {
-        return __atomic_load_n(&weak, __ATOMIC_RELAXED);
+        return weak;
    }

  private:
@ -349,7 +349,7 @@ class shared_ptr
    template<typename U>
    bool owner_before(const weak_ptr<U>& r) const noexcept
    {
-        return rc < r.rc;
+        return !r.owner_before(*this);
    }

  private:
@ -382,34 +382,6 @@ class weak_ptr
            rc->keep_weak();
    }

-    weak_ptr(const weak_ptr& r) noexcept : p(r.p), rc(r.rc)
-    {
-        if (rc)
-            rc->keep_weak();
-    }
-
-    template<typename U>
-        requires __::shared_ptr_compatible<T, U>
-    weak_ptr(const weak_ptr<U>& r) noexcept : p(r.p), rc(r.rc)
-    {
-        if (rc)
-            rc->keep_weak();
-    }
-
-    weak_ptr(weak_ptr&& r) noexcept : p(r.p), rc(r.rc)
-    {
-        r.p = nullptr;
-        r.rc = nullptr;
-    }
-
-    template<typename U>
-        requires __::shared_ptr_compatible<T, U>
-    weak_ptr(weak_ptr<U>&& r) noexcept : p(r.p), rc(r.rc)
-    {
-        r.p = nullptr;
-        r.rc = nullptr;
-    }
-
    ~weak_ptr()
    {
        if (rc)
@ -438,19 +410,6 @@ class weak_ptr
        swap(rc, r.rc);
    }

-    weak_ptr& operator=(weak_ptr r) noexcept
-    {
-        swap(r);
-        return *this;
-    }
-
-    template<typename U>
-        requires __::shared_ptr_compatible<T, U>
-    weak_ptr& operator=(weak_ptr<U> r) noexcept
-    {
-        weak_ptr<T>(move(r)).swap(*this);
-    }
-
    shared_ptr<T> lock() const noexcept
    {
        if (expired())
--- a/examples/BUILD.mk
+++ b/examples/BUILD.mk
@ -54,8 +54,8 @@ EXAMPLES_DIRECTDEPS =						\
 	LIBC_NEXGEN32E						\
 	LIBC_NT_ADVAPI32					\
 	LIBC_NT_IPHLPAPI					\
-	LIBC_NT_KERNEL32					\
 	LIBC_NT_MEMORY						\
+	LIBC_NT_KERNEL32					\
 	LIBC_NT_NTDLL						\
 	LIBC_NT_USER32						\
 	LIBC_NT_WS2_32						\
@ -64,7 +64,6 @@ EXAMPLES_DIRECTDEPS =						\
 	LIBC_SOCK						\
 	LIBC_STDIO						\
 	LIBC_STR						\
-	LIBC_SYSTEM						\
 	LIBC_SYSV						\
 	LIBC_SYSV_CALLS						\
 	LIBC_TESTLIB						\
@ -82,8 +81,6 @@ EXAMPLES_DIRECTDEPS =						\
 	THIRD_PARTY_GETOPT					\
 	THIRD_PARTY_HIREDIS					\
 	THIRD_PARTY_LIBCXX					\
-	THIRD_PARTY_LIBCXXABI					\
-	THIRD_PARTY_LIBUNWIND					\
 	THIRD_PARTY_LINENOISE					\
 	THIRD_PARTY_LUA						\
 	THIRD_PARTY_MBEDTLS					\
@ -97,10 +94,12 @@ EXAMPLES_DIRECTDEPS =						\
 	THIRD_PARTY_TZ						\
 	THIRD_PARTY_VQSORT					\
 	THIRD_PARTY_XED						\
+	THIRD_PARTY_LIBCXXABI					\
+	THIRD_PARTY_LIBUNWIND					\
 	THIRD_PARTY_ZLIB					\
 	TOOL_ARGS						\
 	TOOL_BUILD_LIB						\
-	TOOL_VIZ_LIB						\
+	TOOL_VIZ_LIB

 EXAMPLES_DEPS :=						\
 	$(call uniq,$(foreach x,$(EXAMPLES_DIRECTDEPS),$($(x))))
--- a/examples/asteroids.c
+++ b/examples/asteroids.c
@ -1,353 +0,0 @@
-// -*- mode:c; indent-tabs-mode:nil; c-basic-offset:4 -*-
-// vi: set et ft=c ts=4 sts=4 sw=4 fenc=utf-8
-
-// asteroids by tsotchke
-// https://github.com/tsotchke/asteroids
-
-// clang-format off
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#include <time.h>
-#include <unistd.h>
-#include <signal.h>
-#include <termios.h>
-#include <sys/select.h>
-
-#define SCREEN_WIDTH 80
-#define SCREEN_HEIGHT 24
-#define MAX_ASTEROIDS 5
-#define MAX_BULLETS 5
-
-typedef struct {
-    float x, y;
-} Vector2;
-
-typedef struct {
-    Vector2 position;
-    Vector2 velocity;
-    float angle;
-    float radius;
-} GameObject;
-
-GameObject spaceship;
-GameObject asteroids[MAX_ASTEROIDS];
-GameObject bullets[MAX_BULLETS];
-
-int score = 0;
-time_t startTime;
-int isGameOver = 0;
-int shouldExit = 0;
-int finalTime = 0; // To store final time at game over
-char display[SCREEN_HEIGHT][SCREEN_WIDTH];
-
-// Function to clear the screen buffer
-void clearDisplay() {
-    memset(display, ' ', sizeof(display));
-}
-
-// Function to draw a pixel on the screen
-void drawPixel(int x, int y) {
-    if (x >= 0 && x < SCREEN_WIDTH && y >= 0 && y < SCREEN_HEIGHT) {
-        display[y][x] = '*';
-    }
-}
-
-// Function to draw a line using Bresenham's algorithm
-void drawLine(int x1, int y1, int x2, int y2) {
-    int dx = abs(x2 - x1), sx = (x1 < x2) ? 1 : -1;
-    int dy = -abs(y2 - y1), sy = (y1 < y2) ? 1 : -1;
-    int error = dx + dy, e2;
-
-    while (1) {
-        drawPixel(x1, y1);
-        if (x1 == x2 && y1 == y2) break;
-        e2 = 2 * error;
-        if (e2 >= dy) { error += dy; x1 += sx; }
-        if (e2 <= dx) { error += dx; y1 += sy; }
-    }
-}
-
-// Function to draw a circle
-void drawCircle(int centerX, int centerY, int radius) {
-    int x = radius - 1, y = 0, dx = 1, dy = 1, err = dx - (radius << 1);
-    while (x >= y) {
-        drawPixel(centerX + x, centerY + y);
-        drawPixel(centerX + y, centerY + x);
-        drawPixel(centerX - y, centerY + x);
-        drawPixel(centerX - x, centerY + y);
-        drawPixel(centerX - x, centerY - y);
-        drawPixel(centerX - y, centerY - x);
-        drawPixel(centerX + y, centerY - x);
-        drawPixel(centerX + x, centerY - y);
-
-        if (err <= 0) {
-            y++;
-            err += dy;
-            dy += 2;
-        }
-        if (err > 0) {
-            x--;
-            dx += 2;
-            err += dx - (radius << 1);
-        }
-    }
-}
-
-// Initialize a game object
-void initializeGameObject(GameObject *obj, float x, float y, float angle, float radius) {
-    obj->position = (Vector2){x, y};
-    obj->velocity = (Vector2){0, 0};
-    obj->angle = angle;
-    obj->radius = radius;
-}
-
-// Wrap position of the spaceship and asteroids within screen bounds
-void wrapPosition(Vector2 *pos) {
-    if (pos->x < 0) pos->x = SCREEN_WIDTH - 1;
-    if (pos->x >= SCREEN_WIDTH) pos->x = 0;
-    if (pos->y < 0) pos->y = SCREEN_HEIGHT - 1;
-    if (pos->y >= SCREEN_HEIGHT) pos->y = 0;
-}
-
-// Check if two game objects are colliding
-int checkCollision(GameObject *a, GameObject *b) {
-    float deltaX = a->position.x - b->position.x;
-    float deltaY = a->position.y - b->position.y;
-    return sqrt(deltaX * deltaX + deltaY * deltaY) < (a->radius + b->radius);
-}
-
-// Initialize game state
-void initGame() {
-    score = 0; // Reset the score
-    initializeGameObject(&spaceship, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0, 2);
-
-    for (int i = 0; i < MAX_ASTEROIDS; i++) {
-        initializeGameObject(&asteroids[i],
-            rand() % SCREEN_WIDTH,
-            rand() % SCREEN_HEIGHT,
-            0,
-            2 + rand() % 3);
-        asteroids[i].velocity.x = ((float)rand() / RAND_MAX) * 2 - 1;
-        asteroids[i].velocity.y = ((float)rand() / RAND_MAX) * 2 - 1;
-    }
-
-    for (int i = 0; i < MAX_BULLETS; i++) {
-        bullets[i].position.x = -1; // Mark bullet as inactive
-        bullets[i].position.y = -1;
-    }
-
-    startTime = time(NULL);
-    isGameOver = 0;
-    finalTime = 0; // Reset final time
-}
-
-// Draw the spaceship on the screen
-void drawSpaceship() {
-    int x = (int)spaceship.position.x;
-    int y = (int)spaceship.position.y;
-    int size = 3;
-
-    float cosAngle = cos(spaceship.angle);
-    float sinAngle = sin(spaceship.angle);
-
-    int x1 = x + size * cosAngle;
-    int y1 = y + size * sinAngle;
-    int x2 = x + size * cos(spaceship.angle + 2.5);
-    int y2 = y + size * sin(spaceship.angle + 2.5);
-    int x3 = x + size * cos(spaceship.angle - 2.5);
-    int y3 = y + size * sin(spaceship.angle - 2.5);
-
-    drawLine(x1, y1, x2, y2);
-    drawLine(x2, y2, x3, y3);
-    drawLine(x3, y3, x1, y1);
-}
-
-// Draw all entities on the screen
-void drawEntities(GameObject *entities, int count, void (*drawFunc)(GameObject *)) {
-    for (int i = 0; i < count; i++) {
-        drawFunc(&entities[i]);
-    }
-}
-
-// Draw a bullet on the screen
-void drawBullet(GameObject *bullet) { // Changed to non-const
-    if (bullet->position.x >= 0) {
-        drawPixel((int)bullet->position.x, (int)bullet->position.y);
-    }
-}
-
-// Draw an asteroid on the screen
-void drawAsteroid(GameObject *asteroid) { // Changed to non-const
-    drawCircle((int)asteroid->position.x, (int)asteroid->position.y, (int)asteroid->radius);
-}
-
-// Refresh the display
-void updateDisplay() {
-    clearDisplay();
-    if (!isGameOver) {
-        drawSpaceship();
-        drawEntities(asteroids, MAX_ASTEROIDS, drawAsteroid);
-        drawEntities(bullets, MAX_BULLETS, drawBullet);
-    }
-
-    // Print the screen buffer
-    printf("\033[H");
-    for (int y = 0; y < SCREEN_HEIGHT; y++) {
-        for (int x = 0; x < SCREEN_WIDTH; x++) {
-            putchar(display[y][x]);
-        }
-        putchar('\n');
-    }
-    
-    // Display score and elapsed time
-    time_t currentTime = time(NULL);
-    int elapsedTime = isGameOver ? finalTime : (currentTime - startTime);
-    printf("Score: %d | Time: %02d:%02d | %s\n", score, elapsedTime / 60, elapsedTime % 60, isGameOver ? "Game Over!" : "           ");
-}
-
-// Update the position of game objects
-void updateGameObject(GameObject *obj, int isBullet) {
-    obj->position.x += obj->velocity.x;
-    obj->position.y += obj->velocity.y;
-
-    // If it's a bullet, check if it's out of bounds
-    if (isBullet) {
-        if (obj->position.x < 0 || obj->position.x >= SCREEN_WIDTH || obj->position.y < 0 || obj->position.y >= SCREEN_HEIGHT) {
-            obj->position.x = -1; // Deactivate bullet
-            obj->position.y = -1;
-        }
-    } else {
-        wrapPosition(&obj->position);
-    }
-}
-
-// Update the game state
-void updateGame() {
-    if (isGameOver) return; 
-
-    // Update spaceship and apply friction
-    updateGameObject(&spaceship, 0); // 0 indicates it's not a bullet
-    spaceship.velocity.x *= 0.98;
-    spaceship.velocity.y *= 0.98;
-
-    // Move asteroids and check for collisions
-    for (int i = 0; i < MAX_ASTEROIDS; i++) {
-        updateGameObject(&asteroids[i], 0);
-        if (checkCollision(&spaceship, &asteroids[i])) {
-            isGameOver = 1;
-            finalTime = time(NULL) - startTime;
-            return;
-        }
-    }
-
-    // Update bullet positions
-    for (int i = 0; i < MAX_BULLETS; i++) {
-        if (bullets[i].position.x >= 0) {
-            updateGameObject(&bullets[i], 1); // 1 indicates it's a bullet
-        }
-    }
-
-    // Check for bullet collisions with asteroids
-    for (int i = 0; i < MAX_BULLETS; i++) {
-        if (bullets[i].position.x >= 0) {
-            for (int j = 0; j < MAX_ASTEROIDS; j++) {
-                if (checkCollision(&bullets[i], &asteroids[j])) {
-                    bullets[i].position.x = -1; // Deactivate bullet
-                    bullets[i].position.y = -1;
-                    asteroids[j].position.x = rand() % SCREEN_WIDTH;
-                    asteroids[j].position.y = rand() % SCREEN_HEIGHT;
-                    score += 100;
-                }
-            }
-        }
-    }
-}
-
-// Fire a bullet
-void shootBullet() {
-    for (int i = 0; i < MAX_BULLETS; i++) {
-        if (bullets[i].position.x < 0) {
-            bullets[i].position = spaceship.position;
-            bullets[i].velocity.x = cos(spaceship.angle) * 2;
-            bullets[i].velocity.y = sin(spaceship.angle) * 2;
-            break;
-        }
-    }
-}
-
-// Check if a key was hit
-int isKeyHit() {
-    struct timeval tv = { 0L, 0L };
-    fd_set fds;
-    FD_ZERO(&fds);
-    FD_SET(0, &fds);
-    return select(1, &fds, NULL, NULL, &tv);
-}
-
-// Configure terminal settings
-void configureTerminal(struct termios *old_tio, struct termios *new_tio) {
-    tcgetattr(STDIN_FILENO, old_tio);
-    *new_tio = *old_tio;
-    new_tio->c_lflag &= (~ICANON & ~ECHO);
-    tcsetattr(STDIN_FILENO, TCSANOW, new_tio);
-}
-
-// Restore terminal settings
-void restoreTerminal(struct termios *old_tio) {
-    tcsetattr(STDIN_FILENO, TCSANOW, old_tio);
-}
-
-void onSignal(int sig) {
-    shouldExit = 1;
-}
-
-// Main game loop
-int main() {
-    signal(SIGINT, onSignal); // Capture ^C
-    srand(time(NULL)); // Seed the random number generator
-    initGame(); // Initialize the game state
-
-    struct termios old_tio, new_tio;
-    configureTerminal(&old_tio, &new_tio);
-
-    printf("\033[?25l");  // Hide the cursor
-
-    while (!shouldExit) {
-        if (isKeyHit()) {
-            char input = getchar();
-            if (input == 27) {  // ESC key
-                if (getchar() == '[') {  // Handle arrow keys
-                    switch (getchar()) {
-                        case 'A':  // Up arrow
-                            spaceship.velocity.x += cos(spaceship.angle) * 0.2;
-                            spaceship.velocity.y += sin(spaceship.angle) * 0.2;
-                            break;
-                        case 'B':  // Down arrow
-                            spaceship.velocity.x -= cos(spaceship.angle) * 0.2;
-                            spaceship.velocity.y -= sin(spaceship.angle) * 0.2;
-                            break;
-                        case 'D': spaceship.angle -= 0.2; break;  // Left arrow
-                        case 'C': spaceship.angle += 0.2; break;  // Right arrow
-                    }
-                }
-            } else if (input == ' ') {
-                shootBullet(); // Fire a bullet
-            } else if (input == 'q') {
-                break; // Quit the game
-            } else if (input == 'r' && isGameOver) {
-                initGame(); // Restart the game
-            }
-        }
-
-        updateGame(); // Update game state
-        updateDisplay(); // Refresh the display
-        usleep(50000);  // Wait for 50ms (20 FPS)
-    }
-
-    printf("\033[?25h");  // Show the cursor
-    restoreTerminal(&old_tio); // Restore terminal settings
-    return 0;
-}
--- a/examples/greenbean.c
+++ b/examples/greenbean.c
@ -337,7 +337,7 @@ int main(int argc, char *argv[]) {
  sigaddset(&block, SIGQUIT);
  pthread_attr_t attr;
  unassert(!pthread_attr_init(&attr));
-  unassert(!pthread_attr_setstacksize(&attr, 65536 - getpagesize()));
+  unassert(!pthread_attr_setstacksize(&attr, 65536));
  unassert(!pthread_attr_setguardsize(&attr, getpagesize()));
  unassert(!pthread_attr_setsigmask_np(&attr, &block));
  unassert(!pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0));
--- a/examples/rote.c
+++ b/examples/rote.c
@ -1,322 +0,0 @@
-#/*────────────────────────────────────────────────────────────────╗
-┌┘ To the extent possible under law, Justine Tunney has waived     │
-│  all copyright and related or neighboring rights to this file,   │
-│  as it is written in the following disclaimers:                  │
-│    • http://unlicense.org/                                       │
-│    • http://creativecommons.org/publicdomain/zero/1.0/           │
-╚─────────────────────────────────────────────────────────────────*/
-#include <ctype.h>
-#include <signal.h>
-#include <stdatomic.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <termios.h>
-
-/**
- * @fileoverview cosmopolitan flash cards viewer
- */
-
-struct Card {
-  char* qa[2];
-};
-
-atomic_int g_done;
-
-void onsig(int sig) {
-  g_done = 1;
-}
-
-void* xmalloc(int n) {
-  void* p;
-  if ((p = malloc(n)))
-    return p;
-  perror("malloc");
-  exit(1);
-}
-
-void* xrealloc(void* p, int n) {
-  if ((p = realloc(p, n)))
-    return p;
-  perror("realloc");
-  exit(1);
-}
-
-char* xstrcat(const char* a, const char* b) {
-  char* p;
-  size_t n, m;
-  n = strlen(a);
-  m = strlen(b);
-  p = xmalloc(n + m + 1);
-  memcpy(p, a, n);
-  memcpy(p + n, b, m + 1);
-  return p;
-}
-
-void shuffle(struct Card* a, int n) {
-  while (n > 1) {
-    int i = rand() % n--;
-    struct Card t = a[i];
-    a[i] = a[n];
-    a[n] = t;
-  }
-}
-
-char* trim(char* s) {
-  int i;
-  if (s) {
-    while (isspace(*s))
-      ++s;
-    for (i = strlen(s); i--;) {
-      if (isspace(s[i])) {
-        s[i] = 0;
-      } else {
-        break;
-      }
-    }
-  }
-  return s;
-}
-
-char* readline(FILE* f) {
-  for (;;) {
-    char* line = trim(fgetln(f, 0));
-    if (!line)
-      return 0;
-    if (*line != '#')
-      if (*line)
-        return line;
-  }
-}
-
-char* fill(const char* text, int max_line_width, int* out_line_count) {
-  int text_len = strlen(text);
-  char* result = xmalloc(text_len * 2 + 1);
-  int result_pos = 0;
-  int line_start = 0;
-  int line_count = 1;
-  int i = 0;
-  while (i < text_len && isspace(text[i]))
-    i++;
-  while (i < text_len) {
-    int word_end = i;
-    while (word_end < text_len && !isspace(text[word_end]))
-      word_end++;
-    int word_length = word_end - i;
-    if ((result_pos - line_start) + (result_pos > line_start ? 1 : 0) +
-            word_length >
-        max_line_width) {
-      if (result_pos > line_start) {
-        ++line_count;
-        result[result_pos++] = '\n';
-        line_start = result_pos;
-      }
-    } else if (result_pos > line_start) {
-      result[result_pos++] = ' ';
-    }
-    memcpy(result + result_pos, text + i, word_length);
-    result_pos += word_length;
-    i = word_end;
-    while (i < text_len && isspace(text[i]))
-      i++;
-  }
-  result[result_pos] = '\0';
-  result = xrealloc(result, result_pos + 1);
-  if (out_line_count)
-    *out_line_count = line_count;
-  return result;
-}
-
-void show(const char* text, int i, int n) {
-
-  // get pseudoteletypewriter dimensions
-  struct winsize ws = {80, 25};
-  tcgetwinsize(1, &ws);
-  int width = ws.ws_col;
-  if (width > (int)(ws.ws_col * .9))
-    width = ws.ws_col * .9;
-  if (width > 80)
-    width = 80;
-  width &= -2;
-
-  // clear display
-  printf("\033[H\033[J");
-
-  // display flash card text in middle of display
-  char buf[32];
-  int line_count;
-  char* lines = fill(text, width, &line_count);
-  sprintf(buf, "%d/%d\r\n\r\n", i + 1, n);
-  line_count += 2;
-  char* extra = xstrcat(buf, lines);
-  free(lines);
-  char* tokens = extra;
-  for (int j = 0;; ++j) {
-    char* line = strtok(tokens, "\n");
-    tokens = 0;
-    if (!line)
-      break;
-    printf("\033[%d;%dH%s", ws.ws_row / 2 - line_count / 2 + j + 1,
-           ws.ws_col / 2 - strlen(line) / 2 + 1, line);
-  }
-  free(extra);
-  fflush(stdout);
-}
-
-void usage(FILE* f, const char* prog) {
-  fprintf(f,
-          "usage: %s FILE\n"
-          "\n"
-          "here's an example of what your file should look like:\n"
-          "\n"
-          "  # cosmopolitan flash cards\n"
-          "  # california dmv drivers test\n"
-          "  \n"
-          "  which of the following point totals could result in "
-          "your license being suspended by the dmv?\n"
-          "  4 points in 12 months (middle)\n"
-          "  \n"
-          "  at 55 mph under good conditions a passenger vehicle can stop "
-          "within\n"
-          "  300 feet (not 200, not 400, middle)\n"
-          "  \n"
-          "  two sets of solid double yellow lines spaced two or more feet "
-          "apart indicate\n"
-          "  a BARRIER (do not cross unless there's an opening)\n"
-          "\n"
-          "more specifically, empty lines are ignored, lines starting with\n"
-          "a hash are ignored, then an even number of lines must remain,\n"
-          "where each two lines is a card, holding question and answer.\n",
-          prog);
-}
-
-int main(int argc, char* argv[]) {
-
-  // show help
-  if (argc != 2) {
-    usage(stderr, argv[0]);
-    return 1;
-  }
-  if (!strcmp(argv[1], "-?") ||  //
-      !strcmp(argv[1], "-h") ||  //
-      !strcmp(argv[1], "--help")) {
-    usage(stdout, argv[0]);
-    return 0;
-  }
-
-  // teletypewriter is required
-  if (!isatty(0) || !isatty(1)) {
-    perror("isatty");
-    return 2;
-  }
-
-  // load cards
-  FILE* f = fopen(argv[1], "r");
-  if (!f) {
-    perror(argv[1]);
-    return 3;
-  }
-  int count = 0;
-  struct Card* cards = 0;
-  for (;;) {
-    struct Card card;
-    if (!(card.qa[0] = readline(f)))
-      break;
-    card.qa[0] = strdup(card.qa[0]);
-    if (!(card.qa[1] = readline(f))) {
-      fprintf(stderr, "%s: flash card file has odd number of lines\n", argv[1]);
-      exit(1);
-    }
-    card.qa[1] = strdup(card.qa[1]);
-    cards = xrealloc(cards, (count + 1) * sizeof(struct Card));
-    cards[count++] = card;
-  }
-  fclose(f);
-
-  // randomize
-  srand(time(0));
-  shuffle(cards, count);
-
-  // catch ctrl-c
-  struct sigaction sa;
-  sa.sa_flags = 0;
-  sa.sa_handler = onsig;
-  sigemptyset(&sa.sa_mask);
-  sigaction(SIGINT, &sa, 0);
-
-  // enter raw mode
-  struct termios ot;
-  tcgetattr(1, &ot);
-  struct termios nt = ot;
-  cfmakeraw(&nt);
-  nt.c_lflag |= ISIG;
-  tcsetattr(1, TCSANOW, &nt);
-  printf("\033[?25l");
-
-  // show flash cards
-  int i = 0;
-  while (!g_done) {
-    show(cards[i / 2].qa[i % 2], i / 2, count);
-
-    // press any key
-    char b[8] = {0};
-    read(0, b, sizeof(b));
-
-    // q quits
-    if (b[0] == 'q')
-      break;
-
-    // b or ctrl-b goes backward
-    if (b[0] == 'b' ||  //
-        b[0] == ('B' ^ 0100)) {
-      if (--i < 0)
-        i = count * 2 - 1;
-      i &= -2;
-      continue;
-    }
-
-    // p or ctrl-p goes backward
-    if (b[0] == 'p' ||  //
-        b[0] == ('P' ^ 0100)) {
-      if (--i < 0)
-        i = count * 2 - 1;
-      i &= -2;
-      continue;
-    }
-
-    // up arrow goes backward
-    if (b[0] == 033 &&  //
-        b[1] == '[' &&  //
-        b[2] == 'A') {
-      if (--i < 0)
-        i = count * 2 - 1;
-      i &= -2;
-      continue;
-    }
-
-    // left arrow goes backward
-    if (b[0] == 033 &&  //
-        b[1] == '[' &&  //
-        b[2] == 'D') {
-      if (--i < 0)
-        i = count * 2 - 1;
-      i &= -2;
-      continue;
-    }
-
-    // only advance
-    if (++i == count * 2)
-      i = 0;
-  }
-
-  // free memory
-  for (int i = 0; i < count; ++i)
-    for (int j = 0; j < 2; ++j)
-      free(cards[i].qa[j]);
-  free(cards);
-
-  // cleanup terminal and show cursor
-  tcsetattr(1, TCSANOW, &ot);
-  printf("\033[?25h");
-  printf("\n");
-}
--- a/examples/stackexplorer.c
+++ b/examples/stackexplorer.c
@ -7,13 +7,9 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/dce.h"
-#include "libc/intrin/maps.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
-#include "libc/runtime/stack.h"
-#include "libc/runtime/winargs.internal.h"
 #include "libc/stdio/stdio.h"
 #include "libc/x/xasprintf.h"

@ -71,18 +67,8 @@ int main(int argc, char *argv[]) {
    Append((uintptr_t)&__auxv[i + 1],
           xasprintf("&auxv[%d] = %#lx", i + 1, __auxv[i + 1]));
  }
-  if (!IsWindows()) {
-    struct AddrSize stak = __get_main_stack();
-    Append((intptr_t)stak.addr + stak.size, "top of stack");
-    Append((intptr_t)stak.addr, "bottom of stack");
-  } else {
-#ifdef __x86_64__
-    Append(GetStaticStackAddr(0) + GetStaticStackSize(), "top of stack");
-    Append(GetStaticStackAddr(0) + GetGuardSize(), "bottom of stack");
-    Append(GetStaticStackAddr(0), "bottom of guard region");
-#endif
-  }
  qsort(things.p, things.n, sizeof(*things.p), Compare);
-  for (int i = 0; i < things.n; ++i)
+  for (int i = 0; i < things.n; ++i) {
    printf("%012lx %s\n", things.p[i].i, things.p[i].s);
+  }
 }
--- a/examples/thread.c
+++ b/examples/thread.c
@ -1,17 +0,0 @@
-#include <pthread.h>
-#include <stdio.h>
-
-// how to spawn a thread
-
-void *my_thread(void *arg) {
-  printf("my_thread(%p) is running\n", arg);
-  return (void *)0x456L;
-}
-
-int main(int argc, char *argv[]) {
-  void *res;
-  pthread_t th;
-  pthread_create(&th, 0, my_thread, (void *)0x123L);
-  pthread_join(th, &res);
-  printf("my_thread() returned %p\n", res);
-}
--- a/libc/calls/BUILD.mk
+++ b/libc/calls/BUILD.mk
@ -216,6 +216,12 @@ o//libc/calls/writev.o: private				\
 			-mgeneral-regs-only

 # these assembly files are safe to build on aarch64
+o/$(MODE)/libc/calls/getcontext.o: libc/calls/getcontext.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+o/$(MODE)/libc/calls/swapcontext.o: libc/calls/swapcontext.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+o/$(MODE)/libc/calls/tailcontext.o: libc/calls/tailcontext.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/calls/stackjump.o: libc/calls/stackjump.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<

--- a/libc/intrin/checkcancel.c
+++ b/libc/intrin/checkcancel.c
--- a/libc/intrin/clock_gettime-mono.c
+++ b/libc/intrin/clock_gettime-mono.c
--- a/libc/intrin/clock_gettime-nt.c
+++ b/libc/intrin/clock_gettime-nt.c
@ -59,7 +59,7 @@ textwindows int sys_clock_gettime_nt(int clock, struct timespec *ts) {
      //                     —Quoth MSDN § Windows Time
      //
      QueryUnbiasedInterruptTimePrecise(&hectons);
-      *ts = WindowsDurationToTimeSpec(hectons);
+      *ts = timespec_fromnanos(hectons * 100);
      return 0;
    case _CLOCK_MONOTONIC_COARSE:
      //
@ -83,7 +83,7 @@ textwindows int sys_clock_gettime_nt(int clock, struct timespec *ts) {
      //                     —Quoth MSDN § QueryUnbiasedInterruptTimePrecise
      //
      QueryUnbiasedInterruptTime(&hectons);
-      *ts = WindowsDurationToTimeSpec(hectons);
+      *ts = timespec_fromnanos(hectons * 100);
      return 0;
    case _CLOCK_BOOTTIME:
      //
@ -95,7 +95,7 @@ textwindows int sys_clock_gettime_nt(int clock, struct timespec *ts) {
      //                     —Quoth MSDN § Interrupt Time
      //
      QueryInterruptTimePrecise(&hectons);
-      *ts = WindowsDurationToTimeSpec(hectons);
+      *ts = timespec_fromnanos(hectons * 100);
      return 0;
    case _CLOCK_PROCESS_CPUTIME_ID:
      GetProcessTimes(GetCurrentProcess(), &ftCreation, &ftExit, &ftKernel,
--- a/libc/intrin/clock_gettime-sysv.c
+++ b/libc/intrin/clock_gettime-sysv.c
--- a/libc/intrin/clock_gettime-xnu.c
+++ b/libc/intrin/clock_gettime-xnu.c
--- a/libc/intrin/clock_gettime.c
+++ b/libc/intrin/clock_gettime.c
--- a/libc/intrin/clock_gettime_monotonic_nt.c
+++ b/libc/intrin/clock_gettime_monotonic_nt.c
--- a/libc/calls/clock_nanosleep-nt.c
+++ b/libc/calls/clock_nanosleep-nt.c
@ -16,7 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/atomic.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/struct/timespec.h"
@ -24,37 +23,26 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/nt/enum/status.h"
-#include "libc/nt/ntdll.h"
 #include "libc/stdio/sysparam.h"
-#include "libc/sysv/consts/clock.h"
 #include "libc/sysv/consts/timer.h"
 #include "libc/thread/tls.h"
 #ifdef __x86_64__

-static atomic_int usingRes;
-static atomic_bool changedRes;
-
 static textwindows int sys_clock_nanosleep_nt_impl(int clock,
                                                   struct timespec abs,
                                                   sigset_t waitmask) {
-  struct timespec now, wall;
-  uint32_t minRes, maxRes, oldRes;
-  sys_clock_gettime_nt(0, &wall);
-  if (sys_clock_gettime_nt(clock, &now))
-    return -1;
-  bool wantRes = clock == CLOCK_REALTIME ||   //
-                 clock == CLOCK_MONOTONIC ||  //
-                 clock == CLOCK_BOOTTIME;
-  if (wantRes && !atomic_fetch_add(&usingRes, 1))
-    changedRes = NtSuccess(NtQueryTimerResolution(&minRes, &maxRes, &oldRes)) &&
-                 NtSuccess(NtSetTimerResolution(maxRes, true, &oldRes));
-  if (timespec_cmp(abs, now) > 0)
-    wall = timespec_add(wall, timespec_sub(abs, now));
-  int rc = _park_norestart(wall, waitmask);
-  if (wantRes && atomic_fetch_sub(&usingRes, 1) == 1 && changedRes)
-    NtSetTimerResolution(0, false, &minRes);
-  return rc;
+  uint32_t msdelay;
+  struct timespec now;
+  for (;;) {
+    if (sys_clock_gettime_nt(clock, &now))
+      return -1;
+    if (timespec_cmp(now, abs) >= 0)
+      return 0;
+    msdelay = timespec_tomillis(timespec_sub(abs, now));
+    msdelay = MIN(msdelay, -1u);
+    if (_park_norestart(msdelay, waitmask) == -1)
+      return -1;
+  }
 }

 textwindows int sys_clock_nanosleep_nt(int clock, int flags,
--- a/libc/calls/clock_nanosleep-openbsd.c
+++ b/libc/calls/clock_nanosleep-openbsd.c
@ -23,9 +23,9 @@
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"

-relegated int sys_clock_nanosleep_openbsd(int clock, int flags,
-                                          const struct timespec *req,
-                                          struct timespec *rem) {
+int sys_clock_nanosleep_openbsd(int clock, int flags,
+                                const struct timespec *req,
+                                struct timespec *rem) {
  int res;
  struct timespec start, relative, remainder;
  if (!flags) {
--- a/libc/calls/clock_nanosleep.c
+++ b/libc/calls/clock_nanosleep.c
@ -57,7 +57,6 @@
 *
 * @param clock may be
 *     - `CLOCK_REALTIME`
- *     - `CLOCK_BOOTTIME`
 *     - `CLOCK_MONOTONIC`
 *     - `CLOCK_REALTIME_COARSE` but is likely to sleep negative time
 *     - `CLOCK_MONTONIC_COARSE` but is likely to sleep negative time
--- a/libc/calls/fcntl-nt.c
+++ b/libc/calls/fcntl-nt.c
@ -51,7 +51,6 @@
 #include "libc/sysv/consts/fio.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"

 struct FileLock {
@ -68,9 +67,7 @@ struct FileLocks {
  struct FileLock *free;
 };

-static struct FileLocks g_locks = {
-    .mu = PTHREAD_MUTEX_INITIALIZER,
-};
+static struct FileLocks g_locks;

 static textwindows struct FileLock *NewFileLock(void) {
  struct FileLock *fl;
@ -113,7 +110,7 @@ static textwindows bool EqualsFileLock(struct FileLock *fl, int64_t off,

 textwindows void sys_fcntl_nt_lock_cleanup(int fd) {
  struct FileLock *fl, *ft, **flp;
-  _pthread_mutex_lock(&g_locks.mu);
+  pthread_mutex_lock(&g_locks.mu);
  for (flp = &g_locks.list, fl = *flp; fl;) {
    if (fl->fd == fd) {
      *flp = fl->next;
@ -125,7 +122,7 @@ textwindows void sys_fcntl_nt_lock_cleanup(int fd) {
      fl = *flp;
    }
  }
-  _pthread_mutex_unlock(&g_locks.mu);
+  pthread_mutex_unlock(&g_locks.mu);
 }

 static textwindows int64_t GetfileSize(int64_t handle) {
@ -356,9 +353,9 @@ textwindows int sys_fcntl_nt(int fd, int cmd, uintptr_t arg) {
    } else if (cmd == F_SETLK || cmd == F_SETLKW || cmd == F_GETLK) {
      struct Fd *f = g_fds.p + fd;
      if (f->cursor) {
-        _pthread_mutex_lock(&g_locks.mu);
+        pthread_mutex_lock(&g_locks.mu);
        rc = sys_fcntl_nt_lock(f, fd, cmd, arg);
-        _pthread_mutex_unlock(&g_locks.mu);
+        pthread_mutex_unlock(&g_locks.mu);
      } else {
        rc = ebadf();
      }
--- a/libc/intrin/getcontext.S
+++ b/libc/intrin/getcontext.S
@ -26,9 +26,7 @@
 //	@see	setcontext()
 	.ftrace1
 getcontext:
-	beg
 	.ftrace2
-#include "libc/intrin/getcontext.inc"
+#include "libc/calls/getcontext.inc"
 	jmp	__getcontextsig
-	end
 	.endfn	getcontext,globl
--- a/libc/intrin/getcontext.inc
+++ b/libc/intrin/getcontext.inc
@ -34,7 +34,6 @@
 	mov	%rbp,120(%rdi)
 	mov	%rbx,128(%rdi)
 	mov	%rdx,136(%rdi)
-	mov	%rax,144(%rdi)
 	mov	%rcx,152(%rdi)
 	lea	8(%rsp),%rax
 	mov	%rax,160(%rdi)		// rsp = caller's rsp
--- a/libc/calls/getloadavg-nt.c
+++ b/libc/calls/getloadavg-nt.c
@ -21,23 +21,24 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/fmt/conv.h"
-#include "libc/intrin/cxaatexit.h"
 #include "libc/macros.h"
 #include "libc/nt/accounting.h"
 #include "libc/runtime/runtime.h"
+#include "libc/thread/thread.h"

-#define CTOR  __attribute__((__constructor__(99)))
 #define FT(x) (x.dwLowDateTime | (uint64_t)x.dwHighDateTime << 32)

 static int cpus;
 static double load;
+static pthread_spinlock_t lock;
 static struct NtFileTime idle1, kern1, user1;

 textwindows int sys_getloadavg_nt(double *a, int n) {
  int i, rc;
  uint64_t elapsed, used;
  struct NtFileTime idle, kern, user;
-  __cxa_lock();
+  BLOCK_SIGNALS;
+  pthread_spin_lock(&lock);
  if (GetSystemTimes(&idle, &kern, &user)) {
    elapsed = (FT(kern) - FT(kern1)) + (FT(user) - FT(user1));
    if (elapsed) {
@ -53,11 +54,12 @@ textwindows int sys_getloadavg_nt(double *a, int n) {
  } else {
    rc = __winerr();
  }
-  __cxa_unlock();
+  pthread_spin_unlock(&lock);
+  ALLOW_SIGNALS;
  return rc;
 }

-CTOR static textstartup void sys_getloadavg_nt_init(void) {
+__attribute__((__constructor__(40))) static textstartup void ntinitload(void) {
  if (IsWindows()) {
    load = 1;
    cpus = __get_cpu_count() / 2;
--- a/libc/calls/getntsyspath.S
+++ b/libc/calls/getntsyspath.S
@ -28,8 +28,8 @@
 //	@return	rdi is rdi+edx
 	.text.startup
 __getntsyspath:
-	beg
-	pro
+	push	%rbp
+	mov	%rsp,%rbp
 	push	%rdx
 	movpp	%rdi,%rcx		# call f=%rax(p1=%rcx,p2=%rdx)
 	sub	$40,%rsp
@ -55,7 +55,6 @@ __getntsyspath:
 	jne	2f
 	movb	$'/',-1(%rdi)
 2:	.loop	1b
-	epi
+	leave
 	ret
-	end
 	.endfn	__getntsyspath,globl,hidden
--- a/libc/intrin/virtualalloc.c
+++ b/libc/intrin/virtualalloc.c
@ -1,7 +1,7 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
 │ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@ -16,14 +16,22 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/nt/memory.h"
+#include "libc/calls/syscall-nt.internal.h"
+#include "libc/nt/enum/status.h"
+#include "libc/nt/nt/process.h"
+#include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
+#include "libc/nt/struct/processbasicinformation.h"

-/**
- * Allocates memory on The New Technology.
- */
-textwindows void *VirtualAlloc(void *lpAddress, uint64_t dwSize,
-                               uint32_t flAllocationType, uint32_t flProtect) {
-  return VirtualAllocEx(GetCurrentProcess(), lpAddress, dwSize,
-                        flAllocationType, flProtect);
+textwindows int sys_getppid_nt(void) {
+  struct NtProcessBasicInformation ProcessInformation;
+  uint32_t gotsize = 0;
+  if (!NtError(
+          NtQueryInformationProcess(GetCurrentProcess(), 0, &ProcessInformation,
+                                    sizeof(ProcessInformation), &gotsize)) &&
+      gotsize >= sizeof(ProcessInformation) &&
+      ProcessInformation.InheritedFromUniqueProcessId) {
+    return ProcessInformation.InheritedFromUniqueProcessId;
+  }
+  return GetCurrentProcessId();
 }
--- a/libc/calls/getppid.c
+++ b/libc/calls/getppid.c
--- a/libc/calls/getprogramexecutablename.greg.c
+++ b/libc/calls/getprogramexecutablename.greg.c
@ -96,8 +96,9 @@ static int OldApeLoader(char *s) {
 static int CopyWithCwd(const char *q, char *p, char *e) {
  char c;
  if (*q != '/') {
-    if (q[0] == '.' && q[1] == '/')
+    if (q[0] == '.' && q[1] == '/') {
      q += 2;
+    }
    int got = __getcwd(p, e - p - 1 /* '/' */);
    if (got != -1) {
      p += got - 1;
@ -117,10 +118,9 @@ static int CopyWithCwd(const char *q, char *p, char *e) {

 // if q exists then turn it into an absolute path.
 static int TryPath(const char *q) {
-  if (!q)
-    return 0;
-  if (!CopyWithCwd(q, g_prog.u.buf, g_prog.u.buf + sizeof(g_prog.u.buf)))
+  if (!CopyWithCwd(q, g_prog.u.buf, g_prog.u.buf + sizeof(g_prog.u.buf))) {
    return 0;
+  }
  return !sys_faccessat(AT_FDCWD, g_prog.u.buf, F_OK, 0);
 }

@ -129,8 +129,9 @@ static int TryPath(const char *q) {
 void __init_program_executable_name(void) {
  if (__program_executable_name && *__program_executable_name != '/' &&
      CopyWithCwd(__program_executable_name, g_prog.u.buf,
-                  g_prog.u.buf + sizeof(g_prog.u.buf)))
+                  g_prog.u.buf + sizeof(g_prog.u.buf))) {
    __program_executable_name = g_prog.u.buf;
+  }
 }

 static inline void InitProgramExecutableNameImpl(void) {
@ -211,12 +212,14 @@ static inline void InitProgramExecutableNameImpl(void) {
  }

  // don't trust argv or envp if set-id.
-  if (issetugid())
+  if (issetugid()) {
    goto UseEmpty;
+  }

  // try argv[0], then then $_.
-  if (TryPath(__argv[0]) || TryPath(__getenv(__envp, "_").s))
+  if (TryPath(__argv[0]) || TryPath(__getenv(__envp, "_").s)) {
    goto UseBuf;
+  }

  // give up and just copy argv[0] into it
  if ((q = __argv[0])) {
--- a/libc/calls/getrandom.c
+++ b/libc/calls/getrandom.c
@ -114,8 +114,7 @@ static ssize_t GetDevUrandom(char *p, size_t n, unsigned f) {
 ssize_t __getrandom(void *p, size_t n, unsigned f) {
  ssize_t rc;
  if (IsWindows()) {
-    ProcessPrng(p, n);  // never fails
-    rc = n;
+    rc = ProcessPrng(p, n) ? n : __winerr();
  } else if (have_getrandom) {
    if (IsXnu() || IsOpenbsd()) {
      rc = GetRandomBsd(p, n, GetRandomEntropy);
@ -185,7 +184,9 @@ ssize_t __getrandom(void *p, size_t n, unsigned f) {
 * @raise EFAULT if the `n` bytes at `p` aren't valid memory
 * @raise EINTR if we needed to block and a signal was delivered instead
 * @cancelationpoint
+ * @asyncsignalsafe
 * @restartable
+ * @vforksafe
 */
 ssize_t getrandom(void *p, size_t n, unsigned f) {
  ssize_t rc;
--- a/libc/calls/getrlimit.c
+++ b/libc/calls/getrlimit.c
@ -21,7 +21,6 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/describeflags.h"
-#include "libc/intrin/rlimit.h"
 #include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
@ -48,7 +47,8 @@ int getrlimit(int resource, struct rlimit *rlim) {
  } else if (!IsWindows()) {
    rc = sys_getrlimit(resource, rlim);
  } else if (resource == RLIMIT_STACK) {
-    *rlim = __rlimit_stack_get();
+    rlim->rlim_cur = GetStaticStackSize();
+    rlim->rlim_max = GetStaticStackSize();
    rc = 0;
  } else if (resource == RLIMIT_AS) {
    rlim->rlim_cur = __virtualmax;
--- a/libc/calls/internal.h
+++ b/libc/calls/internal.h
@ -3,7 +3,6 @@
 #include "libc/atomic.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigval.h"
-#include "libc/calls/struct/timespec.h"
 #include "libc/dce.h"
 #include "libc/intrin/fds.h"
 #include "libc/macros.h"
@ -31,10 +30,8 @@ int CountConsoleInputBytes(void);
 int FlushConsoleInputBytes(void);
 int64_t GetConsoleInputHandle(void);
 int64_t GetConsoleOutputHandle(void);
-void EchoConsoleNt(const char *, size_t, bool);
 int IsWindowsExecutable(int64_t, const char16_t *);
 void InterceptTerminalCommands(const char *, size_t);
-void sys_read_nt_wipe_keystrokes(void);

 forceinline bool __isfdopen(int fd) {
  return 0 <= fd && fd < g_fds.n && g_fds.p[fd].kind != kFdEmpty;
@ -48,8 +45,8 @@ int _check_signal(bool);
 int _check_cancel(void);
 bool _is_canceled(void);
 int sys_close_nt(int, int);
-int _park_norestart(struct timespec, uint64_t);
-int _park_restartable(struct timespec, uint64_t);
+int _park_norestart(uint32_t, uint64_t);
+int _park_restartable(uint32_t, uint64_t);
 int sys_openat_metal(int, const char *, int, unsigned);

 #ifdef __x86_64__
--- a/libc/intrin/isqemu.c
+++ b/libc/intrin/isqemu.c
--- a/libc/calls/metalfile.c
+++ b/libc/calls/metalfile.c
@ -67,9 +67,10 @@ textstartup void InitializeMetalFile(void) {
    size_t size = ROUNDUP(_ezip - __executable_start, 4096);
    // TODO(jart): Restore support for ZIPOS on metal.
    void *copied_base;
-    void *addr = sys_mmap_metal(NULL, size, PROT_READ | PROT_WRITE,
-                                MAP_SHARED_linux | MAP_ANONYMOUS_linux, -1, 0);
-    copied_base = addr;
+    struct DirectMap dm;
+    dm = sys_mmap_metal(NULL, size, PROT_READ | PROT_WRITE,
+                        MAP_SHARED_linux | MAP_ANONYMOUS_linux, -1, 0);
+    copied_base = dm.addr;
    npassert(copied_base != (void *)-1);
    memcpy(copied_base, (void *)(BANE + IMAGE_BASE_PHYSICAL), size);
    __ape_com_base = copied_base;
--- a/libc/calls/ntspawn.c
+++ b/libc/calls/ntspawn.c
@ -17,7 +17,6 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/proc/ntspawn.h"
-#include "libc/calls/state.internal.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/intrin/strace.h"
@ -39,15 +38,12 @@
 #include "libc/nt/struct/procthreadattributelist.h"
 #include "libc/nt/struct/startupinfo.h"
 #include "libc/nt/struct/startupinfoex.h"
-#include "libc/nt/thunk/msabi.h"
 #include "libc/proc/ntspawn.h"
 #include "libc/stdalign.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 #ifdef __x86_64__

-__msabi extern typeof(CloseHandle) *const __imp_CloseHandle;
-
 struct SpawnBlock {
  char16_t path[PATH_MAX];
  char16_t cmdline[32767];
@ -67,12 +63,10 @@ static textwindows ssize_t ntspawn_read(intptr_t fh, char *buf, size_t len) {
  bool ok;
  uint32_t got;
  struct NtOverlapped overlap = {.hEvent = CreateEvent(0, 0, 0, 0)};
-  ok = overlap.hEvent &&
-       (ReadFile(fh, buf, len, 0, &overlap) ||
+  ok = (ReadFile(fh, buf, len, 0, &overlap) ||
        GetLastError() == kNtErrorIoPending) &&
       GetOverlappedResult(fh, &overlap, &got, true);
-  if (overlap.hEvent)
-    __imp_CloseHandle(overlap.hEvent);
+  CloseHandle(overlap.hEvent);
  return ok ? got : -1;
 }

@ -92,7 +86,7 @@ static textwindows int ntspawn2(struct NtSpawnArgs *a, struct SpawnBlock *sb) {
  if (fh == -1)
    return -1;
  ssize_t got = ntspawn_read(fh, p, pe - p);
-  __imp_CloseHandle(fh);
+  CloseHandle(fh);
  if (got < 3)
    return enoexec();
  pe = p + got;
--- a/libc/calls/openat-metal.c
+++ b/libc/calls/openat-metal.c
@ -49,9 +49,11 @@ int sys_openat_metal(int dirfd, const char *file, int flags, unsigned mode) {
  if ((fd = __reservefd(-1)) == -1)
    return -1;
  if (!_weaken(calloc) || !_weaken(free)) {
-    state = sys_mmap_metal(NULL, ROUNDUP(sizeof(struct MetalFile), 4096),
-                           PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS,
-                           -1, 0);
+    struct DirectMap dm;
+    dm = sys_mmap_metal(NULL, ROUNDUP(sizeof(struct MetalFile), 4096),
+                        PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1,
+                        0);
+    state = dm.addr;
    if (state == (void *)-1)
      return -1;
  } else {
--- a/libc/calls/park.c
+++ b/libc/calls/park.c
@ -19,96 +19,65 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/sigset.h"
-#include "libc/calls/struct/timespec.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/fmt/wintime.internal.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/weaken.h"
+#include "libc/nt/enum/wait.h"
 #include "libc/nt/events.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/synchronization.h"
-#include "libc/str/str.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/posixthread.internal.h"
-
 #ifdef __x86_64__

-// returns 0 if deadline is reached
+// returns 0 on timeout or spurious wakeup
 // raises EINTR if a signal delivery interrupted wait operation
 // raises ECANCELED if this POSIX thread was canceled in masked mode
-textwindows static int _park_thread(struct timespec deadline, sigset_t waitmask,
+textwindows static int _park_thread(uint32_t msdelay, sigset_t waitmask,
                                    bool restartable) {
-  for (;;) {
-    uint32_t handl = 0;
-    intptr_t hands[2];
+  struct PosixThread *pt = _pthread_self();

-    // create event object
-    intptr_t sigev;
-    if (!(sigev = CreateEvent(0, 0, 0, 0)))
-      return __winerr();
-    hands[handl++] = sigev;
+  // perform the wait operation
+  intptr_t sigev;
+  if (!(sigev = CreateEvent(0, 0, 0, 0)))
+    return __winerr();
+  pt->pt_event = sigev;
+  pt->pt_blkmask = waitmask;
+  atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_EVENT,
+                        memory_order_release);
+  //!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!//
+  int sig = 0;
+  uint32_t ws = 0;
+  if (!_is_canceled() &&
+      !(_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))))
+    ws = WaitForSingleObject(sigev, msdelay);
+  //!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!//
+  atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
+  CloseHandle(sigev);

-    // create high precision timer if needed
-    if (memcmp(&deadline, &timespec_max, sizeof(struct timespec))) {
-      intptr_t hTimer;
-      if ((hTimer = CreateWaitableTimer(NULL, true, NULL))) {
-        int64_t due = TimeSpecToWindowsTime(deadline);
-        if (SetWaitableTimer(hTimer, &due, 0, NULL, NULL, false)) {
-          hands[handl++] = hTimer;
-        } else {
-          CloseHandle(hTimer);
-        }
-      }
-    }
-
-    // perform wait operation
-    struct PosixThread *pt = _pthread_self();
-    pt->pt_event = sigev;
-    pt->pt_blkmask = waitmask;
-    atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_EVENT,
-                          memory_order_release);
-    //!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!//
-    int sig = 0;
-    uint32_t wi = 0;
-    if (!_is_canceled() &&
-        !(_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))))
-      wi = WaitForMultipleObjects(handl, hands, false, -1u);
-    //!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!//
-    atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
-    for (int i = 0; i < handl; ++i)
-      CloseHandle(hands[i]);
-
-    // recursion is now safe
-    if (wi == 1)
-      return 0;
-    if (wi == -1u)
-      return __winerr();
-    int handler_was_called = 0;
-    if (!sig) {
-      if (_check_cancel())
-        return -1;
-      if (_weaken(__sig_get))
-        sig = _weaken(__sig_get)(waitmask);
-    }
-    if (sig)
-      handler_was_called = _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
-    if (_check_cancel())
-      return -1;
-    if (handler_was_called & SIG_HANDLED_NO_RESTART)
+  // recursion is now safe
+  if (ws == -1u)
+    return __winerr();
+  int handler_was_called = 0;
+  if (sig)
+    handler_was_called = _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
+  if (_check_cancel())
+    return -1;
+  if (handler_was_called & SIG_HANDLED_NO_RESTART)
+    return eintr();
+  if (handler_was_called & SIG_HANDLED_SA_RESTART)
+    if (!restartable)
      return eintr();
-    if (handler_was_called & SIG_HANDLED_SA_RESTART)
-      if (!restartable)
-        return eintr();
-  }
+  return 0;
 }

-textwindows int _park_norestart(struct timespec deadline, sigset_t waitmask) {
-  return _park_thread(deadline, waitmask, false);
+textwindows int _park_norestart(uint32_t msdelay, sigset_t waitmask) {
+  return _park_thread(msdelay, waitmask, false);
 }

-textwindows int _park_restartable(struct timespec deadline, sigset_t waitmask) {
-  return _park_thread(deadline, waitmask, true);
+textwindows int _park_restartable(uint32_t msdelay, sigset_t waitmask) {
+  return _park_thread(msdelay, waitmask, true);
 }

 #endif /* __x86_64__ */
--- a/libc/calls/pause-nt.c
+++ b/libc/calls/pause-nt.c
@ -18,20 +18,21 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/sigset.internal.h"
-#include "libc/calls/struct/timespec.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #ifdef __x86_64__

 textwindows int sys_pause_nt(void) {
+  int rc;
  // we don't strictly need to block signals, but it reduces signal
  // delivery latency, by preventing other threads from delivering a
  // signal asynchronously. it takes about ~5us to deliver a signal
  // using SetEvent() whereas it takes ~30us to use SuspendThread(),
  // GetThreadContext(), SetThreadContext(), and ResumeThread().
  BLOCK_SIGNALS;
-  _park_norestart(timespec_max, 0);
+  while (!(rc = _park_norestart(-1u, 0)))
+    donothing;
  ALLOW_SIGNALS;
-  return -1;
+  return rc;
 }

 #endif /* __x86_64__ */
--- a/libc/calls/pledge-linux.c
+++ b/libc/calls/pledge-linux.c
@ -694,7 +694,6 @@ static const uint16_t kPledgeStdio[] = {
    __NR_linux_sched_getaffinity,  //
    __NR_linux_sched_setaffinity,  //
    __NR_linux_sigtimedwait,       //
-    __NR_linux_getcpu,             //
 };

 static const uint16_t kPledgeFlock[] = {
--- a/libc/calls/poll-nt.c
+++ b/libc/calls/poll-nt.c
@ -318,8 +318,8 @@ textwindows static int sys_poll_nt_actual(struct pollfd *fds, uint64_t nfds,
 textwindows static int sys_poll_nt_impl(struct pollfd *fds, uint64_t nfds,
                                        struct timespec deadline,
                                        const sigset_t waitmask) {
+  uint32_t waitms;
  int i, n, rc, got = 0;
-  struct timespec now, next, target;

  // we normally don't check for signals until we decide to wait, since
  // it's nice to have functions like write() be unlikely to EINTR, but
@ -344,16 +344,9 @@ textwindows static int sys_poll_nt_impl(struct pollfd *fds, uint64_t nfds,
    }
    if (got)
      return got;
-    now = sys_clock_gettime_monotonic_nt();
-    if (timespec_cmp(now, deadline) >= 0)
+    if (!(waitms = sys_poll_nt_waitms(deadline)))
      return 0;
-    next = timespec_add(now, timespec_frommillis(POLL_INTERVAL_MS));
-    if (timespec_cmp(next, deadline) >= 0) {
-      target = deadline;
-    } else {
-      target = next;
-    }
-    if (_park_norestart(target, waitmask) == -1)
+    if (_park_norestart(waitms, waitmask) == -1)
      return -1;
  }
 }
--- a/libc/calls/read-nt.c
+++ b/libc/calls/read-nt.c
@ -48,7 +48,6 @@
 #include "libc/nt/enum/wait.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/events.h"
-#include "libc/nt/memory.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/inputrecord.h"
 #include "libc/nt/synchronization.h"
@ -128,46 +127,33 @@ struct Keystrokes {
  bool ohno_decckm;
  bool bypass_mode;
  uint16_t utf16hs;
-  size_t free_keys;
+  int16_t freekeys;
  int64_t cin, cot;
  struct Dll *list;
  struct Dll *line;
  struct Dll *free;
+  pthread_mutex_t lock;
+  struct Keystroke pool[512];
 };

 static struct Keystrokes __keystroke;
-static pthread_mutex_t __keystroke_lock = PTHREAD_MUTEX_INITIALIZER;

-textwindows void sys_read_nt_wipe_keystrokes(void) {
+textwindows void WipeKeystrokes(void) {
  bzero(&__keystroke, sizeof(__keystroke));
-  _pthread_mutex_wipe_np(&__keystroke_lock);
 }

 textwindows static void FreeKeystrokeImpl(struct Dll *key) {
  dll_make_first(&__keystroke.free, key);
-  ++__keystroke.free_keys;
-}
-
-textwindows static struct Keystroke *AllocKeystroke(void) {
-  struct Keystroke *k;
-  if (!(k = HeapAlloc(GetProcessHeap(), 0, sizeof(struct Keystroke))))
-    return 0;
-  dll_init(&k->elem);
-  return k;
+  ++__keystroke.freekeys;
 }

 textwindows static struct Keystroke *NewKeystroke(void) {
-  struct Dll *e;
-  struct Keystroke *k;
-  if ((e = dll_first(__keystroke.free))) {
-    dll_remove(&__keystroke.free, e);
-    k = KEYSTROKE_CONTAINER(e);
-    --__keystroke.free_keys;
-  } else {
-    // PopulateKeystrokes() should make this branch impossible
-    if (!(k = AllocKeystroke()))
-      return 0;
-  }
+  struct Dll *e = dll_first(__keystroke.free);
+  if (!e)  // See MIN(freekeys) before ReadConsoleInput()
+    __builtin_trap();
+  struct Keystroke *k = KEYSTROKE_CONTAINER(e);
+  dll_remove(&__keystroke.free, &k->elem);
+  --__keystroke.freekeys;
  k->buflen = 0;
  return k;
 }
@ -183,22 +169,15 @@ textwindows static void FreeKeystrokes(struct Dll **list) {
    FreeKeystroke(list, key);
 }

-textwindows static void PopulateKeystrokes(size_t want) {
-  struct Keystroke *k;
-  while (__keystroke.free_keys < want) {
-    if ((k = AllocKeystroke())) {
-      FreeKeystrokeImpl(&k->elem);
-    } else {
-      break;
-    }
-  }
-}
-
 textwindows static void OpenConsole(void) {
  __keystroke.cin = CreateFile(u"CONIN$", kNtGenericRead | kNtGenericWrite,
                               kNtFileShareRead, 0, kNtOpenExisting, 0, 0);
  __keystroke.cot = CreateFile(u"CONOUT$", kNtGenericRead | kNtGenericWrite,
                               kNtFileShareWrite, 0, kNtOpenExisting, 0, 0);
+  for (int i = 0; i < ARRAYLEN(__keystroke.pool); ++i) {
+    dll_init(&__keystroke.pool[i].elem);
+    FreeKeystrokeImpl(&__keystroke.pool[i].elem);
+  }
 }

 textwindows static int AddSignal(int sig) {
@ -212,11 +191,11 @@ textwindows static void InitConsole(void) {
 }

 textwindows static void LockKeystrokes(void) {
-  _pthread_mutex_lock(&__keystroke_lock);
+  pthread_mutex_lock(&__keystroke.lock);
 }

 textwindows static void UnlockKeystrokes(void) {
-  _pthread_mutex_unlock(&__keystroke_lock);
+  pthread_mutex_unlock(&__keystroke.lock);
 }

 textwindows int64_t GetConsoleInputHandle(void) {
@ -341,12 +320,9 @@ textwindows static int ProcessKeyEvent(const struct NtInputRecord *r, char *p) {
  // note we define _POSIX_VDISABLE as zero
  // tcsetattr() lets anyone reconfigure these keybindings
  if (c && !(__ttyconf.magic & kTtyNoIsigs) && !__keystroke.bypass_mode) {
-    char b[] = {c};
    if (c == __ttyconf.vintr) {
-      EchoConsoleNt(b, 1, false);
      return AddSignal(SIGINT);
    } else if (c == __ttyconf.vquit) {
-      EchoConsoleNt(b, 1, false);
      return AddSignal(SIGQUIT);
    }
  }
@ -481,8 +457,7 @@ textwindows static void WriteCtl(const char *p, size_t n, bool escape_harder) {
  }
 }

-textwindows void EchoConsoleNt(const char *p, size_t n, bool escape_harder) {
-  InitConsole();
+textwindows static void EchoTty(const char *p, size_t n, bool escape_harder) {
  if (!(__ttyconf.magic & kTtySilence)) {
    if (__ttyconf.magic & kTtyEchoRaw) {
      WriteTty(p, n);
@ -539,12 +514,14 @@ textwindows static void IngestConsoleInputRecord(struct NtInputRecord *r) {
      !(__ttyconf.magic & kTtyNoIexten)) {  // IEXTEN
    if (__keystroke.bypass_mode) {
      struct Keystroke *k = NewKeystroke();
-      if (!k)
-        return;
      memcpy(k->buf, buf, sizeof(k->buf));
      k->buflen = len;
      dll_make_last(&__keystroke.line, &k->elem);
-      EchoConsoleNt(buf, len, true);
+      EchoTty(buf, len, true);
+      if (!__keystroke.freekeys) {
+        dll_make_last(&__keystroke.list, __keystroke.line);
+        __keystroke.line = 0;
+      }
      __keystroke.bypass_mode = false;
      return;
    } else if (len == 1 && buf[0] &&  //
@ -634,14 +611,12 @@ textwindows static void IngestConsoleInputRecord(struct NtInputRecord *r) {

  // allocate object to hold keystroke
  struct Keystroke *k = NewKeystroke();
-  if (!k)
-    return;
  memcpy(k->buf, buf, sizeof(k->buf));
  k->buflen = len;

  // echo input if it was successfully recorded
  // assuming the win32 console isn't doing it already
-  EchoConsoleNt(buf, len, false);
+  EchoTty(buf, len, false);

  // save keystroke to appropriate list
  if (__ttyconf.magic & kTtyUncanon) {
@ -649,12 +624,12 @@ textwindows static void IngestConsoleInputRecord(struct NtInputRecord *r) {
  } else {
    dll_make_last(&__keystroke.line, &k->elem);

-    // flush canonical mode line on enter
-    if (len == 1 && buf[0] &&
-        ((buf[0] & 255) == '\n' ||            //
-         (buf[0] & 255) == __ttyconf.veol ||  //
-         ((buf[0] & 255) == __ttyconf.veol2 &&
-          !(__ttyconf.magic & kTtyNoIexten)))) {
+    // flush canonical mode line if oom or enter
+    if (!__keystroke.freekeys || (len == 1 && buf[0] &&
+                                  ((buf[0] & 255) == '\n' ||            //
+                                   (buf[0] & 255) == __ttyconf.veol ||  //
+                                   ((buf[0] & 255) == __ttyconf.veol2 &&
+                                    !(__ttyconf.magic & kTtyNoIexten))))) {
      dll_make_last(&__keystroke.list, __keystroke.line);
      __keystroke.line = 0;
    }
@ -665,17 +640,15 @@ textwindows static void IngestConsoleInput(void) {
  uint32_t i, n;
  struct NtInputRecord records[16];
  for (;;) {
+    if (!__keystroke.freekeys)
+      return;
    if (__keystroke.end_of_file)
      return;
    if (!GetNumberOfConsoleInputEvents(__keystroke.cin, &n))
      goto UnexpectedEof;
-    if (n > ARRAYLEN(records))
-      n = ARRAYLEN(records);
-    PopulateKeystrokes(n + 1);
-    if (n > __keystroke.free_keys)
-      n = __keystroke.free_keys;
-    if (!n)
+    if (!n || !__keystroke.freekeys)
      return;
+    n = MIN(__keystroke.freekeys, MIN(ARRAYLEN(records), n));
    if (!ReadConsoleInput(__keystroke.cin, records, n, &n))
      goto UnexpectedEof;
    for (i = 0; i < n && !__keystroke.end_of_file; ++i)
@ -997,10 +970,8 @@ textwindows ssize_t ReadBuffer(int fd, void *data, size_t size, int64_t offset,
  if (f->kind == kFdDevNull)
    return 0;

-  if (f->kind == kFdDevRandom) {
-    ProcessPrng(data, size);
-    return size;
-  }
+  if (f->kind == kFdDevRandom)
+    return ProcessPrng(data, size) ? size : __winerr();

  if (f->kind == kFdConsole)
    return ReadFromConsole(f, data, size, waitmask);
--- a/libc/intrin/restore.S
+++ b/libc/intrin/restore.S
--- a/libc/calls/setrlimit.c
+++ b/libc/calls/setrlimit.c
@ -23,7 +23,6 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/describeflags.h"
-#include "libc/intrin/rlimit.h"
 #include "libc/intrin/strace.h"
 #include "libc/macros.h"
 #include "libc/runtime/runtime.h"
@ -89,12 +88,10 @@ int setrlimit(int resource, const struct rlimit *rlim) {
  } else if (!IsWindows() && !(IsNetbsd() && resource == RLIMIT_AS)) {
    rc = sys_setrlimit(resource, rlim);
  } else if (resource == RLIMIT_STACK) {
-    rc = 0;
+    rc = enotsup();
  } else {
    rc = einval();
  }
-  if (!rc && resource == RLIMIT_STACK)
-    __rlimit_stack_set(*rlim);  // so __rlimit_stack_get() works on all OSes
  if (resource == RLIMIT_AS) {
    __virtualmax = rlim->rlim_cur;
    errno = olde;
--- a/libc/calls/shm_path_np.c
+++ b/libc/calls/shm_path_np.c
@ -35,8 +35,9 @@ void shm_path_np(const char *name, char buf[hasatleast 78]) {
  const char *a;
  uint8_t digest[BLAKE2B256_DIGEST_LENGTH];
  a = "/tmp/", n = 5;
-  if (IsLinux() && isdirectory("/dev/shm"))
+  if (IsLinux() && isdirectory("/dev/shm")) {
    a = "/dev/shm/", n = 9;
+  }
  BLAKE2B256(name, strlen(name), digest);
  p = mempcpy(buf, a, n);
  p = hexpcpy(p, digest, BLAKE2B256_DIGEST_LENGTH);
--- a/libc/calls/sig.c
+++ b/libc/calls/sig.c
@ -0,0 +1,717 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/sysv/consts/sig.h"
+#include "ape/sections.internal.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/sig.internal.h"
+#include "libc/calls/state.internal.h"
+#include "libc/calls/struct/sigaction.h"
+#include "libc/calls/struct/siginfo.h"
+#include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/ucontext.internal.h"
+#include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/calls/ucontext.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/bsf.h"
+#include "libc/intrin/describebacktrace.h"
+#include "libc/intrin/dll.h"
+#include "libc/intrin/maps.h"
+#include "libc/intrin/strace.h"
+#include "libc/intrin/weaken.h"
+#include "libc/nt/console.h"
+#include "libc/nt/enum/context.h"
+#include "libc/nt/enum/exceptionhandleractions.h"
+#include "libc/nt/enum/processcreationflags.h"
+#include "libc/nt/enum/signal.h"
+#include "libc/nt/enum/status.h"
+#include "libc/nt/events.h"
+#include "libc/nt/runtime.h"
+#include "libc/nt/signals.h"
+#include "libc/nt/struct/ntexceptionpointers.h"
+#include "libc/nt/synchronization.h"
+#include "libc/nt/thread.h"
+#include "libc/runtime/internal.h"
+#include "libc/runtime/symbols.internal.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/sa.h"
+#include "libc/sysv/consts/sicode.h"
+#include "libc/sysv/consts/ss.h"
+#include "libc/thread/posixthread.internal.h"
+#ifdef __x86_64__
+
+/**
+ * @fileoverview Cosmopolitan Signals for Windows.
+ */
+
+#define STKSZ 65536
+
+struct SignalFrame {
+  unsigned rva;
+  unsigned flags;
+  siginfo_t si;
+  ucontext_t ctx;
+};
+
+static textwindows bool __sig_ignored_by_default(int sig) {
+  return sig == SIGURG ||   //
+         sig == SIGCONT ||  //
+         sig == SIGCHLD ||  //
+         sig == SIGWINCH;
+}
+
+textwindows bool __sig_ignored(int sig) {
+  return __sighandrvas[sig] == (intptr_t)SIG_IGN ||
+         (__sighandrvas[sig] == (intptr_t)SIG_DFL &&
+          __sig_ignored_by_default(sig));
+}
+
+textwindows void __sig_delete(int sig) {
+  struct Dll *e;
+  atomic_fetch_and_explicit(__sig.process, ~(1ull << (sig - 1)),
+                            memory_order_relaxed);
+  _pthread_lock();
+  for (e = dll_last(_pthread_list); e; e = dll_prev(_pthread_list, e))
+    atomic_fetch_and_explicit(&POSIXTHREAD_CONTAINER(e)->tib->tib_sigpending,
+                              ~(1ull << (sig - 1)), memory_order_relaxed);
+  _pthread_unlock();
+}
+
+static textwindows int __sig_getter(atomic_ulong *sigs, sigset_t masked) {
+  int sig;
+  sigset_t bit, pending, deliverable;
+  for (;;) {
+    pending = atomic_load_explicit(sigs, memory_order_acquire);
+    if ((deliverable = pending & ~masked)) {
+      sig = bsfl(deliverable) + 1;
+      bit = 1ull << (sig - 1);
+      if (atomic_fetch_and_explicit(sigs, ~bit, memory_order_acq_rel) & bit)
+        return sig;
+    } else {
+      return 0;
+    }
+  }
+}
+
+textwindows int __sig_get(sigset_t masked) {
+  int sig;
+  if (!(sig = __sig_getter(&__get_tls()->tib_sigpending, masked)))
+    sig = __sig_getter(__sig.process, masked);
+  return sig;
+}
+
+static textwindows bool __sig_should_use_altstack(unsigned flags,
+                                                  struct CosmoTib *tib) {
+  if (!(flags & SA_ONSTACK))
+    return false;  // signal handler didn't enable it
+  if (!tib->tib_sigstack_size)
+    return false;  // sigaltstack() wasn't installed on this thread
+  if (tib->tib_sigstack_flags & SS_DISABLE)
+    return false;  // sigaltstack() on this thread was disabled by user
+  char *bp = __builtin_frame_address(0);
+  if (tib->tib_sigstack_addr <= bp &&
+      bp <= tib->tib_sigstack_addr + tib->tib_sigstack_size)
+    return false;  // we're already on the alternate stack
+  return true;
+}
+
+static textwindows wontreturn void __sig_terminate(int sig) {
+  TerminateThisProcess(sig);
+}
+
+textwindows static bool __sig_wake(struct PosixThread *pt, int sig) {
+  atomic_int *blocker;
+  blocker = atomic_load_explicit(&pt->pt_blocker, memory_order_acquire);
+  if (!blocker)
+    return false;
+  // threads can create semaphores on an as-needed basis
+  if (blocker == PT_BLOCKER_EVENT) {
+    STRACE("%G set %d's event object", sig, _pthread_tid(pt));
+    SetEvent(pt->pt_event);
+    return !!atomic_load_explicit(&pt->pt_blocker, memory_order_acquire);
+  }
+  // all other blocking ops that aren't overlap should use futexes
+  // we force restartable futexes to churn by waking w/o releasing
+  STRACE("%G waking %d's futex", sig, _pthread_tid(pt));
+  WakeByAddressSingle(blocker);
+  return !!atomic_load_explicit(&pt->pt_blocker, memory_order_acquire);
+}
+
+textwindows static bool __sig_start(struct PosixThread *pt, int sig,
+                                    unsigned *rva, unsigned *flags) {
+  *rva = __sighandrvas[sig];
+  *flags = __sighandflags[sig];
+  if (*rva == (intptr_t)SIG_IGN ||
+      (*rva == (intptr_t)SIG_DFL && __sig_ignored_by_default(sig))) {
+    STRACE("ignoring %G", sig);
+    return false;
+  }
+  if (atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
+      (1ull << (sig - 1))) {
+    STRACE("enqueing %G on %d", sig, _pthread_tid(pt));
+    atomic_fetch_or_explicit(&pt->tib->tib_sigpending, 1ull << (sig - 1),
+                             memory_order_relaxed);
+    __sig_wake(pt, sig);
+    return false;
+  }
+  if (*rva == (intptr_t)SIG_DFL) {
+    STRACE("terminating on %G due to no handler", sig);
+    __sig_terminate(sig);
+  }
+  return true;
+}
+
+textwindows static sigaction_f __sig_handler(unsigned rva) {
+  atomic_fetch_add_explicit(&__sig.count, 1, memory_order_relaxed);
+  return (sigaction_f)(__executable_start + rva);
+}
+
+textwindows int __sig_raise(volatile int sig, int sic) {
+
+  // bitset of kinds of handlers called
+  volatile int handler_was_called = 0;
+
+  // loop over pending signals
+  ucontext_t ctx;
+  getcontext(&ctx);
+  if (!sig) {
+    if ((sig = __sig_get(ctx.uc_sigmask))) {
+      sic = SI_KERNEL;
+    } else {
+      return handler_was_called;
+    }
+  }
+
+  // process signal(s)
+  unsigned rva, flags;
+  struct PosixThread *pt = _pthread_self();
+  if (__sig_start(pt, sig, &rva, &flags)) {
+
+    if (flags & SA_RESETHAND) {
+      STRACE("resetting %G handler", sig);
+      __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
+    }
+
+    // update the signal mask in preparation for signal handller
+    sigset_t blocksigs = __sighandmask[sig];
+    if (!(flags & SA_NODEFER))
+      blocksigs |= 1ull << (sig - 1);
+    ctx.uc_sigmask = atomic_fetch_or_explicit(&pt->tib->tib_sigmask, blocksigs,
+                                              memory_order_acquire);
+
+    // call the user's signal handler
+    char ssbuf[128];
+    siginfo_t si = {.si_signo = sig, .si_code = sic};
+    STRACE("__sig_raise(%G, %t) mask %s", sig, __sig_handler(rva),
+           _DescribeSigset(ssbuf, 0, (sigset_t *)&pt->tib->tib_sigmask));
+    __sig_handler(rva)(sig, &si, &ctx);
+
+    // record this handler
+    if (flags & SA_RESTART) {
+      handler_was_called |= SIG_HANDLED_SA_RESTART;
+    } else {
+      handler_was_called |= SIG_HANDLED_NO_RESTART;
+    }
+  }
+
+  // restore sigmask
+  // loop back to top
+  // jump where handler says
+  sig = 0;
+  return setcontext(&ctx);
+}
+
+textwindows int __sig_relay(int sig, int sic, sigset_t waitmask) {
+  sigset_t m;
+  int handler_was_called;
+  m = atomic_exchange_explicit(&__get_tls()->tib_sigmask, waitmask,
+                               memory_order_acquire);
+  handler_was_called = __sig_raise(sig, SI_KERNEL);
+  atomic_store_explicit(&__get_tls()->tib_sigmask, m, memory_order_release);
+  return handler_was_called;
+}
+
+// the user's signal handler callback is wrapped with this trampoline
+static textwindows wontreturn void __sig_tramp(struct SignalFrame *sf) {
+  int sig = sf->si.si_signo;
+  struct CosmoTib *tib = __get_tls();
+  struct PosixThread *pt = (struct PosixThread *)tib->tib_pthread;
+  atomic_store_explicit(&pt->pt_intoff, 0, memory_order_release);
+  for (;;) {
+
+    // update the signal mask in preparation for signal handler
+    sigset_t blocksigs = __sighandmask[sig];
+    if (!(sf->flags & SA_NODEFER))
+      blocksigs |= 1ull << (sig - 1);
+    sf->ctx.uc_sigmask = atomic_fetch_or_explicit(&tib->tib_sigmask, blocksigs,
+                                                  memory_order_acquire);
+
+    // call the user's signal handler
+    char ssbuf[2][128];
+    STRACE("__sig_tramp(%G, %t) mask %s → %s", sig, __sig_handler(sf->rva),
+           _DescribeSigset(ssbuf[0], 0, &sf->ctx.uc_sigmask),
+           _DescribeSigset(ssbuf[1], 0, (sigset_t *)&tib->tib_sigmask));
+    __sig_handler(sf->rva)(sig, &sf->si, &sf->ctx);
+
+    // restore the signal mask that was used by the interrupted code
+    // this may have been modified by the signal handler in the callback
+    atomic_store_explicit(&tib->tib_sigmask, sf->ctx.uc_sigmask,
+                          memory_order_release);
+
+    // jump back into original code if there aren't any pending signals
+    do {
+      if (!(sig = __sig_get(sf->ctx.uc_sigmask)))
+        __sig_restore(&sf->ctx);
+    } while (!__sig_start(pt, sig, &sf->rva, &sf->flags));
+
+    // tail recurse into another signal handler
+    sf->si.si_signo = sig;
+    sf->si.si_code = SI_KERNEL;
+    if (sf->flags & SA_RESETHAND) {
+      STRACE("resetting %G handler", sig);
+      __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
+    }
+  }
+}
+
+// sends signal to another specific thread which is ref'd
+static textwindows int __sig_killer(struct PosixThread *pt, int sig, int sic) {
+  unsigned rva = __sighandrvas[sig];
+  unsigned flags = __sighandflags[sig];
+
+  // do nothing if signal is ignored
+  if (rva == (intptr_t)SIG_IGN ||
+      (rva == (intptr_t)SIG_DFL && __sig_ignored_by_default(sig))) {
+    STRACE("ignoring %G", sig);
+    return 0;
+  }
+
+  // we can't preempt threads that masked sigs or are blocked on i/o
+  while ((atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
+          (1ull << (sig - 1)))) {
+    if (atomic_fetch_or_explicit(&pt->tib->tib_sigpending, 1ull << (sig - 1),
+                                 memory_order_acq_rel) &
+        (1ull << (sig - 1)))
+      // we believe signal was already enqueued
+      return 0;
+    if (__sig_wake(pt, sig))
+      // we believe i/o routine will handle signal
+      return 0;
+    if (atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
+        (1ull << (sig - 1)))
+      // we believe ALLOW_SIGNALS will handle signal
+      return 0;
+    if (!(atomic_fetch_and_explicit(&pt->tib->tib_sigpending,
+                                    ~(1ull << (sig - 1)),
+                                    memory_order_acq_rel) &
+          (1ull << (sig - 1))))
+      // we believe another thread sniped our signal
+      return 0;
+    break;
+  }
+
+  // avoid race conditions and deadlocks with thread suspend process
+  if (atomic_exchange_explicit(&pt->pt_intoff, 1, memory_order_acquire)) {
+    // we believe another thread is asynchronously waking the mark
+    if (atomic_fetch_or_explicit(&pt->tib->tib_sigpending, 1ull << (sig - 1),
+                                 memory_order_acq_rel) &
+        (1ull << (sig - 1)))
+      // we believe our signal is already being delivered
+      return 0;
+    if (atomic_load_explicit(&pt->pt_intoff, memory_order_acquire) ||
+        atomic_exchange_explicit(&pt->pt_intoff, 1, memory_order_acquire))
+      // we believe __sig_tramp will deliver our signal
+      return 0;
+    if (!(atomic_fetch_and_explicit(&pt->tib->tib_sigpending,
+                                    ~(1ull << (sig - 1)),
+                                    memory_order_acq_rel) &
+          (1ull << (sig - 1))))
+      // we believe another thread sniped our signal
+      return 0;
+  }
+
+  // if there's no handler then killing a thread kills the process
+  if (rva == (intptr_t)SIG_DFL) {
+    STRACE("terminating on %G due to no handler", sig);
+    __sig_terminate(sig);
+  }
+
+  // take control of thread
+  // suspending the thread happens asynchronously
+  // however getting the context blocks until it's frozen
+  uintptr_t th = _pthread_syshand(pt);
+  if (SuspendThread(th) == -1u) {
+    STRACE("SuspendThread failed w/ %d", GetLastError());
+    atomic_store_explicit(&pt->pt_intoff, 0, memory_order_release);
+    return ESRCH;
+  }
+  struct NtContext nc;
+  nc.ContextFlags = kNtContextFull;
+  if (!GetThreadContext(th, &nc)) {
+    STRACE("GetThreadContext failed w/ %d", GetLastError());
+    ResumeThread(th);
+    atomic_store_explicit(&pt->pt_intoff, 0, memory_order_release);
+    return ESRCH;
+  }
+
+  // we can't preempt threads that masked sig or are blocked
+  // we can't preempt threads that are running in win32 code
+  // so we shall unblock the thread and let it signal itself
+  if (!((uintptr_t)__executable_start <= nc.Rip &&
+        nc.Rip < (uintptr_t)__privileged_start)) {
+    atomic_fetch_or_explicit(&pt->tib->tib_sigpending, 1ull << (sig - 1),
+                             memory_order_relaxed);
+    ResumeThread(th);
+    atomic_store_explicit(&pt->pt_intoff, 0, memory_order_release);
+    __sig_wake(pt, sig);
+    return 0;
+  }
+
+  // preferring to live dangerously
+  // the thread will be signaled asynchronously
+  if (flags & SA_RESETHAND) {
+    STRACE("resetting %G handler", sig);
+    __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
+  }
+
+  // inject call to trampoline function into thread
+  uintptr_t sp;
+  if (__sig_should_use_altstack(flags, pt->tib)) {
+    sp = (uintptr_t)pt->tib->tib_sigstack_addr + pt->tib->tib_sigstack_size;
+  } else {
+    sp = nc.Rsp;
+  }
+  sp -= sizeof(struct SignalFrame);
+  sp &= -16;
+  struct SignalFrame *sf = (struct SignalFrame *)sp;
+  _ntcontext2linux(&sf->ctx, &nc);
+  bzero(&sf->si, sizeof(sf->si));
+  sf->rva = rva;
+  sf->flags = flags;
+  sf->si.si_code = sic;
+  sf->si.si_signo = sig;
+  *(uintptr_t *)(sp -= sizeof(uintptr_t)) = nc.Rip;
+  nc.Rip = (intptr_t)__sig_tramp;
+  nc.Rdi = (intptr_t)sf;
+  nc.Rsp = sp;
+  if (!SetThreadContext(th, &nc)) {
+    STRACE("SetThreadContext failed w/ %d", GetLastError());
+    atomic_store_explicit(&pt->pt_intoff, 0, memory_order_release);
+    return ESRCH;
+  }
+  ResumeThread(th);
+  __sig_wake(pt, sig);
+  return 0;
+}
+
+// sends signal to another specific thread
+textwindows int __sig_kill(struct PosixThread *pt, int sig, int sic) {
+  int rc;
+  BLOCK_SIGNALS;
+  rc = __sig_killer(pt, sig, sic);
+  ALLOW_SIGNALS;
+  return rc;
+}
+
+// sends signal to any other thread
+// this should only be called by non-posix threads
+textwindows void __sig_generate(int sig, int sic) {
+  struct Dll *e;
+  struct PosixThread *pt, *mark = 0;
+  if (__sig_ignored(sig)) {
+    STRACE("ignoring %G", sig);
+    return;
+  }
+  if (__sighandrvas[sig] == (intptr_t)SIG_DFL) {
+    STRACE("terminating on %G due to no handler", sig);
+    __sig_terminate(sig);
+  }
+  if (atomic_load_explicit(__sig.process, memory_order_acquire) &
+      (1ull << (sig - 1))) {
+    return;
+  }
+  _pthread_lock();
+  for (e = dll_first(_pthread_list); e; e = dll_next(_pthread_list, e)) {
+    pt = POSIXTHREAD_CONTAINER(e);
+    // we don't want to signal ourself
+    if (pt == _pthread_self())
+      continue;
+    // we don't want to signal a thread that isn't running
+    if (atomic_load_explicit(&pt->pt_status, memory_order_acquire) >=
+        kPosixThreadTerminated) {
+      continue;
+    }
+    // choose this thread if it isn't masking sig
+    if (!(atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
+          (1ull << (sig - 1)))) {
+      _pthread_ref(pt);
+      mark = pt;
+      break;
+    }
+    // if a thread is blocking then we check to see if it's planning
+    // to unblock our sig once the wait operation is completed; when
+    // that's the case we can cancel the thread's i/o to deliver sig
+    if (atomic_load_explicit(&pt->pt_blocker, memory_order_acquire) &&
+        !(pt->pt_blkmask & (1ull << (sig - 1)))) {
+      _pthread_ref(pt);
+      mark = pt;
+      break;
+    }
+  }
+  _pthread_unlock();
+  if (mark) {
+    // no lock needed since current thread is nameless and formless
+    __sig_killer(mark, sig, sic);
+    _pthread_unref(mark);
+  } else {
+    atomic_fetch_or_explicit(__sig.process, 1ull << (sig - 1),
+                             memory_order_relaxed);
+  }
+}
+
+static textwindows char *__sig_stpcpy(char *d, const char *s) {
+  size_t i;
+  for (i = 0;; ++i)
+    if (!(d[i] = s[i]))
+      return d + i;
+}
+
+static textwindows wontreturn void __sig_death(int sig, const char *thing) {
+#ifndef TINY
+  intptr_t hStderr;
+  char sigbuf[21], s[128], *p;
+  hStderr = GetStdHandle(kNtStdErrorHandle);
+  p = __sig_stpcpy(s, "Terminating on ");
+  p = __sig_stpcpy(p, thing);
+  p = __sig_stpcpy(p, strsignal_r(sig, sigbuf));
+  p = __sig_stpcpy(p,
+                   ". Pass --strace and/or ShowCrashReports() for details.\n");
+  WriteFile(hStderr, s, p - s, 0, 0);
+#endif
+  __sig_terminate(sig);
+}
+
+static textwindows void __sig_unmaskable(struct NtExceptionPointers *ep,
+                                         int code, int sig,
+                                         struct CosmoTib *tib) {
+
+  // log vital crash information reliably for --strace before doing much
+  // we don't print this without the flag since raw numbers scare people
+  // this needs at least one page of stack memory in order to get logged
+  // otherwise it'll print a warning message about the lack of stack mem
+  STRACE("win32 vectored exception 0x%08Xu raising %G "
+         "cosmoaddr2line %s %lx %s",
+         ep->ExceptionRecord->ExceptionCode, sig,
+         _weaken(FindDebugBinary) ? _weaken(FindDebugBinary)()
+                                  : program_invocation_name,
+         ep->ContextRecord->Rip,
+         DescribeBacktrace((struct StackFrame *)ep->ContextRecord->Rbp));
+
+  // if the user didn't install a signal handler for this unmaskable
+  // exception, then print a friendly helpful hint message to stderr
+  unsigned rva = __sighandrvas[sig];
+  if (rva == (intptr_t)SIG_DFL || rva == (intptr_t)SIG_IGN)
+    __sig_death(sig, "uncaught ");
+
+  // if this signal handler is configured to auto-reset to the default
+  // then that reset needs to happen before the user handler is called
+  unsigned flags = __sighandflags[sig];
+  if (flags & SA_RESETHAND) {
+    STRACE("resetting %G handler", sig);
+    __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
+  }
+
+  // determine the true memory address at which fault occurred
+  // if this is a stack overflow then reapply guard protection
+  void *si_addr;
+  if (ep->ExceptionRecord->ExceptionCode == kNtSignalGuardPage) {
+    si_addr = (void *)ep->ExceptionRecord->ExceptionInformation[1];
+  } else {
+    si_addr = ep->ExceptionRecord->ExceptionAddress;
+  }
+
+  // call the user signal handler
+  // and a modifiable view of the faulting code's cpu state
+  // temporarily replace signal mask while calling crash handler
+  // abort process if sig is already blocked to avoid crash loop
+  // note ucontext_t is a hefty data structures on top of NtContext
+  ucontext_t ctx = {0};
+  siginfo_t si = {.si_signo = sig, .si_code = code, .si_addr = si_addr};
+  _ntcontext2linux(&ctx, ep->ContextRecord);
+  sigset_t blocksigs = __sighandmask[sig];
+  if (!(flags & SA_NODEFER))
+    blocksigs |= 1ull << (sig - 1);
+  ctx.uc_sigmask = atomic_fetch_or_explicit(&tib->tib_sigmask, blocksigs,
+                                            memory_order_acquire);
+  if (ctx.uc_sigmask & (1ull << (sig - 1))) {
+    __sig_death(sig, "masked ");
+    __sig_terminate(sig);
+  }
+  __sig_handler(rva)(sig, &si, &ctx);
+  atomic_store_explicit(&tib->tib_sigmask, ctx.uc_sigmask,
+                        memory_order_release);
+  _ntlinux2context(ep->ContextRecord, &ctx);
+}
+
+void __stack_call(struct NtExceptionPointers *, int, int, struct CosmoTib *,
+                  void (*)(struct NtExceptionPointers *, int, int,
+                           struct CosmoTib *),
+                  void *);
+
+//                         abashed the devil stood
+//                      and felt how awful goodness is
+__msabi dontinstrument unsigned __sig_crash(struct NtExceptionPointers *ep) {
+
+  // translate win32 to unix si_signo and si_code
+  int code, sig = __sig_crash_sig(ep->ExceptionRecord->ExceptionCode, &code);
+
+  // advance the instruction pointer to skip over debugger breakpoints
+  // this behavior is consistent with how unix kernels are implemented
+  if (sig == SIGTRAP) {
+    ep->ContextRecord->Rip++;
+    if (__sig_ignored(sig))
+      return kNtExceptionContinueExecution;
+  }
+
+  // win32 stack overflow detection executes INSIDE the guard page
+  // thus switch to the alternate signal stack as soon as possible
+  struct CosmoTib *tib = __get_tls();
+  unsigned flags = __sighandflags[sig];
+  if (__sig_should_use_altstack(flags, tib)) {
+    __stack_call(ep, code, sig, tib, __sig_unmaskable,
+                 tib->tib_sigstack_addr + tib->tib_sigstack_size);
+  } else {
+    __sig_unmaskable(ep, code, sig, tib);
+  }
+
+  // resume running user program
+  // hopefully the user fixed the cpu state
+  // otherwise the crash will keep happening
+  return kNtExceptionContinueExecution;
+}
+
+static textwindows int __sig_console_sig(uint32_t dwCtrlType) {
+  switch (dwCtrlType) {
+    case kNtCtrlCEvent:
+      return SIGINT;
+    case kNtCtrlBreakEvent:
+      return SIGQUIT;
+    case kNtCtrlCloseEvent:
+    case kNtCtrlLogoffEvent:    // only received by services
+    case kNtCtrlShutdownEvent:  // only received by services
+      return SIGHUP;
+    default:
+      return SIGSTKFLT;
+  }
+}
+
+__msabi textwindows dontinstrument bool32 __sig_console(uint32_t dwCtrlType) {
+  // win32 launches a thread to deliver ctrl-c and ctrl-break when typed
+  // it only happens when kNtEnableProcessedInput is in play on console.
+  // otherwise we need to wait until read-nt.c discovers that keystroke.
+  struct CosmoTib tls;
+  __bootstrap_tls(&tls, __builtin_frame_address(0));
+  __sig_generate(__sig_console_sig(dwCtrlType), SI_KERNEL);
+  return true;
+}
+
+// returns 0 if no signal handlers were called, otherwise a bitmask
+// consisting of `1` which means a signal handler was invoked which
+// didn't have the SA_RESTART flag, and `2`, which means SA_RESTART
+// handlers were called (or `3` if both were the case).
+textwindows int __sig_check(void) {
+  int sig, res = 0;
+  while ((sig = __sig_get(atomic_load_explicit(&__get_tls()->tib_sigmask,
+                                               memory_order_acquire))))
+    res |= __sig_raise(sig, SI_KERNEL);
+  return res;
+}
+
+// background thread for delivering inter-process signals asynchronously
+// this checks for undelivered process-wide signals, once per scheduling
+// quantum, which on windows should be every ~15ms or so, unless somehow
+// the process was tuned to have more fine-grained event timing. we want
+// signals to happen faster when possible; that happens when cancelation
+// points, e.g. read need to wait on i/o; they too check for new signals
+textwindows dontinstrument static uint32_t __sig_worker(void *arg) {
+  struct CosmoTib tls;
+  __bootstrap_tls(&tls, __builtin_frame_address(0));
+  char *sp = __builtin_frame_address(0);
+  __maps_track((char *)(((uintptr_t)sp + __pagesize - 1) & -__pagesize) - STKSZ,
+               STKSZ);
+  for (;;) {
+
+    // dequeue all pending signals and fire them off. if there's no
+    // thread that can handle them then __sig_generate will requeue
+    // those signals back to __sig.process; hence the need for xchg
+    unsigned long sigs =
+        atomic_exchange_explicit(__sig.process, 0, memory_order_acq_rel);
+    while (sigs) {
+      int sig = bsfl(sigs) + 1;
+      sigs &= ~(1ull << (sig - 1));
+      __sig_generate(sig, SI_KERNEL);
+    }
+
+    // unblock stalled asynchronous signals in threads
+    _pthread_lock();
+    for (struct Dll *e = dll_first(_pthread_list); e;
+         e = dll_next(_pthread_list, e)) {
+      struct PosixThread *pt = POSIXTHREAD_CONTAINER(e);
+      if (atomic_load_explicit(&pt->pt_status, memory_order_acquire) >=
+          kPosixThreadTerminated) {
+        break;
+      }
+      sigset_t pending =
+          atomic_load_explicit(&pt->tib->tib_sigpending, memory_order_acquire);
+      sigset_t mask =
+          atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire);
+      if (pending & ~mask) {
+        _pthread_ref(pt);
+        _pthread_unlock();
+        while (!atomic_compare_exchange_weak_explicit(
+            &pt->tib->tib_sigpending, &pending, pending & ~mask,
+            memory_order_acq_rel, memory_order_relaxed)) {
+        }
+        while ((pending = pending & ~mask)) {
+          int sig = bsfl(pending) + 1;
+          pending &= ~(1ull << (sig - 1));
+          __sig_killer(pt, sig, SI_KERNEL);
+        }
+        _pthread_lock();
+        _pthread_unref(pt);
+      }
+    }
+    _pthread_unlock();
+
+    // wait until next scheduler quantum
+    Sleep(POLL_INTERVAL_MS);
+  }
+  return 0;
+}
+
+__attribute__((__constructor__(10))) textstartup void __sig_init(void) {
+  if (!IsWindows())
+    return;
+  AddVectoredExceptionHandler(true, (void *)__sig_crash);
+  SetConsoleCtrlHandler((void *)__sig_console, true);
+  CreateThread(0, STKSZ, __sig_worker, 0, kNtStackSizeParamIsAReservation, 0);
+}
+
+#endif /* __x86_64__ */
--- a/libc/calls/sigaction.c
+++ b/libc/calls/sigaction.c
@ -423,7 +423,7 @@ static int __sigaction(int sig, const struct sigaction *act,
 *     }
 *
 *     void ContinueOnCrash(void) {
- *       struct sigaction sa = {.sa_sigaction = OnCrash,
+ *       struct sigaction sa = {.sa_handler = OnSigSegv,
 *                              .sa_flags = SA_SIGINFO | SA_RESETHAND};
 *       sigaction(SIGSEGV, &sa, 0);
 *       sigaction(SIGFPE, &sa, 0);
--- a/libc/calls/sigaltstack.c
+++ b/libc/calls/sigaltstack.c
@ -113,7 +113,7 @@ static int sigaltstack_bsd(const struct sigaltstack *neu,
 *     struct sigaction sa;
 *     struct sigaltstack ss;
 *     ss.ss_flags = 0;
- *     ss.ss_size = sysconf(_SC_SIGSTKSZ);
+ *     ss.ss_size = sysconf(_SC_MINSIGSTKSZ) + 8192;
 *     ss.ss_sp = malloc(ss.ss_size);
 *     sigaltstack(&ss, 0);
 *     sigemptyset(&sa.ss_mask);
@ -121,16 +121,11 @@ static int sigaltstack_bsd(const struct sigaltstack *neu,
 *     sa.sa_handler = OnStackOverflow;
 *     sigaction(SIGSEGV, &sa, 0);
 *
- * Your stack size should be `sysconf(_SC_SIGSTKSZ)` which should be
- * somewhere in the ballpark of 32kb to 64kb. You should go no lower
- * than `sysconf(_SC_MINSIGSTKSZ) + 2048` which could be 4kb - 34kb.
- * Cosmo also defines `SIGSTKSZ` as 32kb, which should also be safe.
- *
 * @param neu if non-null will install new signal alt stack
 * @param old if non-null will receive current signal alt stack
 * @return 0 on success, or -1 w/ errno
 * @raise EFAULT if bad memory was supplied
- * @raise ENOMEM if `neu->ss_size` is beneath `sysconf(_SC_MINSIGSTKSZ)`
+ * @raise ENOMEM if `neu->ss_size` is less than `MINSIGSTKSZ`
 */
 int sigaltstack(const struct sigaltstack *neu, struct sigaltstack *old) {
  int rc;
--- a/libc/intrin/sigcrashsig.c
+++ b/libc/intrin/sigcrashsig.c
--- a/libc/calls/sigenter-xnu.c
+++ b/libc/calls/sigenter-xnu.c
@ -33,7 +33,6 @@
 #include "libc/runtime/syslib.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sa.h"
-#include "libc/sysv/consts/sig.h"

 /**
 * @fileoverview XNU kernel callback normalization.
@ -514,7 +513,6 @@ privileged void __sigenter_xnu(int sig, struct siginfo_xnu *xnuinfo,
    flags = __sighandflags[sig];

 #ifdef __aarch64__
-
    // xnu silicon claims to support sa_resethand but it does nothing
    // this can be tested, since it clears the bit from flags as well
    if (flags & SA_RESETHAND) {
@ -523,13 +521,6 @@ privileged void __sigenter_xnu(int sig, struct siginfo_xnu *xnuinfo,
      __sighandflags[sig] = 0;
      __sighandrvas[sig] = 0;
    }
-
-    // unlike amd64, the instruction pointer on arm64 isn't advanced
-    // past the debugger breakpoint instruction automatically. we need
-    // this so execution can resume after __builtin_trap().
-    if (xnuctx && sig == SIGTRAP)
-      xnuctx->uc_mcontext->__ss.__pc += 4;
-
 #endif

    if (~flags & SA_SIGINFO) {
--- a/libc/calls/sigsuspend.c
+++ b/libc/calls/sigsuspend.c
@ -21,7 +21,6 @@
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
-#include "libc/calls/struct/timespec.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
@ -60,7 +59,8 @@ int sigsuspend(const sigset_t *ignore) {
      // using SetEvent() whereas it takes ~30us to use SuspendThread(),
      // GetThreadContext(), SetThreadContext(), and ResumeThread().
      BLOCK_SIGNALS;
-      rc = _park_norestart(timespec_max, waitmask);
+      while (!(rc = _park_norestart(-1u, waitmask)))
+        donothing;
      ALLOW_SIGNALS;
    } else {
      rc = sys_sigsuspend((uint64_t[2]){waitmask}, 8);
--- a/libc/calls/state.internal.h
+++ b/libc/calls/state.internal.h
@ -13,6 +13,7 @@ extern unsigned __sighandflags[NSIG + 1];
 extern uint64_t __sighandmask[NSIG + 1];
 extern const struct NtSecurityAttributes kNtIsInheritable;

+void __fds_wipe(void);
 void __fds_lock(void);
 void __fds_unlock(void);

--- a/libc/calls/struct/sigset.h
+++ b/libc/calls/struct/sigset.h
@ -4,21 +4,19 @@ COSMOPOLITAN_C_START_

 typedef uint64_t sigset_t;

-/* clang-format off */
-int sigaddset(sigset_t *, int) libcesque paramsnonnull();
-int sigdelset(sigset_t *, int) libcesque paramsnonnull();
-int sigemptyset(sigset_t *) libcesque paramsnonnull();
-int sigfillset(sigset_t *) libcesque paramsnonnull();
-int sigandset(sigset_t *, const sigset_t *, const sigset_t *) libcesque paramsnonnull();
-int sigorset(sigset_t *, const sigset_t *, const sigset_t *) libcesque paramsnonnull();
-int sigisemptyset(const sigset_t *) libcesque paramsnonnull() nosideeffect;
-int sigismember(const sigset_t *, int) libcesque paramsnonnull() nosideeffect;
-int sigcountset(const sigset_t *) libcesque paramsnonnull() nosideeffect;
-int sigprocmask(int, const sigset_t *, sigset_t *) dontthrow;
-int sigsuspend(const sigset_t *) dontthrow;
-int sigpending(sigset_t *) libcesque;
-int pthread_sigmask(int, const sigset_t *, sigset_t *) dontthrow;
-/* clang-format on */
+int sigaddset(sigset_t *, int) paramsnonnull();
+int sigdelset(sigset_t *, int) paramsnonnull();
+int sigemptyset(sigset_t *) paramsnonnull();
+int sigfillset(sigset_t *) paramsnonnull();
+int sigandset(sigset_t *, const sigset_t *, const sigset_t *) paramsnonnull();
+int sigorset(sigset_t *, const sigset_t *, const sigset_t *) paramsnonnull();
+int sigisemptyset(const sigset_t *) paramsnonnull() nosideeffect;
+int sigismember(const sigset_t *, int) paramsnonnull() nosideeffect;
+int sigcountset(const sigset_t *) paramsnonnull() nosideeffect;
+int sigprocmask(int, const sigset_t *, sigset_t *);
+int sigsuspend(const sigset_t *);
+int sigpending(sigset_t *);
+int pthread_sigmask(int, const sigset_t *, sigset_t *);

 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGSET_H_ */
--- a/libc/calls/struct/sigset.internal.h
+++ b/libc/calls/struct/sigset.internal.h
@ -5,15 +5,27 @@
 #include "libc/sysv/consts/sig.h"
 COSMOPOLITAN_C_START_

+#ifndef MODE_DBG
+/* block sigs because theoretical edge cases */
 #define BLOCK_SIGNALS  \
  do {                 \
    sigset_t _SigMask; \
  _SigMask = __sig_block()
-
 #define ALLOW_SIGNALS      \
  __sig_unblock(_SigMask); \
  }                        \
  while (0)
+#else
+/* doesn't block signals so we can get a crash
+   report, when a core runtime library crashes */
+#define BLOCK_SIGNALS  \
+  do {                 \
+    sigset_t _SigMask; \
+  sigprocmask(SIG_SETMASK, 0, &_SigMask)
+#define ALLOW_SIGNALS \
+  }                   \
+  while (0)
+#endif

 sigset_t __sig_block(void);
 void __sig_unblock(sigset_t);
--- a/libc/calls/struct/ucontext.internal.h
+++ b/libc/calls/struct/ucontext.internal.h
@ -1,14 +1,13 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_UCONTEXT_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_STRUCT_UCONTEXT_INTERNAL_H_
 #include "libc/calls/ucontext.h"
+#include "libc/nt/struct/context.h"
 COSMOPOLITAN_C_START_

 #ifdef __x86_64__
 #define PC   rip
 #define SP   rsp
 #define BP   rbp
-#define RES0 rax
-#define RES1 rdx
 #define ARG0 rdi
 #define ARG1 rsi
 #define ARG2 rdx
@ -19,8 +18,6 @@ COSMOPOLITAN_C_START_
 #define PC   pc
 #define SP   sp
 #define BP   regs[29]
-#define RES0 regs[0]
-#define RES1 regs[1]
 #define ARG0 regs[0]
 #define ARG1 regs[1]
 #define ARG2 regs[2]
@ -31,5 +28,8 @@ COSMOPOLITAN_C_START_
 #error "unsupported architecture"
 #endif

+void _ntcontext2linux(struct ucontext *, const struct NtContext *);
+void _ntlinux2context(struct NtContext *, const ucontext_t *);
+
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_UCONTEXT_INTERNAL_H_ */
--- a/libc/calls/struct/user_regs_struct.h
+++ b/libc/calls/struct/user_regs_struct.h
@ -0,0 +1,71 @@
+#ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_USER_REGS_STRUCT_H_
+#define COSMOPOLITAN_LIBC_CALLS_STRUCT_USER_REGS_STRUCT_H_
+COSMOPOLITAN_C_START_
+
+/**
+ * Linux Kernel user registers.
+ *
+ * @note superset of struct pt_regs
+ * @see ptrace() w/ PTRACE_SYSCALL
+ */
+struct user_regs_struct {
+  uint64_t r15;
+  uint64_t r14;
+  uint64_t r13;
+  uint64_t r12;
+  uint64_t rbp;
+  uint64_t rbx;
+  uint64_t r11;
+  uint64_t r10;
+  uint64_t r9;
+  uint64_t r8;
+  uint64_t rax;
+  uint64_t rcx;
+  uint64_t rdx;
+  uint64_t rsi;
+  uint64_t rdi;
+  uint64_t orig_rax;
+  uint64_t rip;
+  uint64_t cs;
+  uint64_t eflags;
+  uint64_t rsp;
+  uint64_t ss;
+  uint64_t fs_base;
+  uint64_t gs_base;
+  uint64_t ds;
+  uint64_t es;
+  uint64_t fs;
+  uint64_t gs;
+};
+
+struct useregs_struct_freebsd {
+  int64_t r15;
+  int64_t r14;
+  int64_t r13;
+  int64_t r12;
+  int64_t r11;
+  int64_t r10;
+  int64_t r9;
+  int64_t r8;
+  int64_t rdi;
+  int64_t rsi;
+  int64_t rbp;
+  int64_t rbx;
+  int64_t rdx;
+  int64_t rcx;
+  int64_t rax;
+  uint32_t trapno;
+  uint16_t fs;
+  uint16_t gs;
+  uint32_t err;
+  uint16_t es;
+  uint16_t ds;
+  int64_t rip;
+  int64_t cs;
+  int64_t rflags;
+  int64_t rsp;
+  int64_t ss;
+};
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_USER_REGS_STRUCT_H_ */
--- a/libc/intrin/swapcontext.S
+++ b/libc/intrin/swapcontext.S
@ -31,17 +31,17 @@
 //	@returnstwice
 	.ftrace1
 swapcontext:
-	beg
 	.ftrace2
-#include "libc/intrin/getcontext.inc"
+#include "libc/calls/getcontext.inc"
 #ifdef __x86_64__
-	pro
-	cpush	%rsi
-	cpush	%rsi
+	push	%rbp
+	mov	%rsp,%rbp
+	push	%rsi
+	push	%rsi
 	call	__swapcontextsig
-	cpop	%rdi
-	cpop	%rdi
-	epi
+	pop	%rdi
+	pop	%rdi
+	pop	%rbp
 	test	%eax,%eax
 	jnz	1f
 #elif defined(__aarch64__)
@ -56,5 +56,4 @@ swapcontext:
 #endif
 	jmp	__tailcontext
 1:	ret
-	end
 	.endfn	swapcontext,globl
--- a/libc/calls/syscall-nt.internal.h
+++ b/libc/calls/syscall-nt.internal.h
@ -2,9 +2,6 @@
 #define COSMOPOLITAN_LIBC_CALLS_SYSCALL_NT_INTERNAL_H_
 COSMOPOLITAN_C_START_

-extern int sys_getppid_nt_cosmo;
-extern int sys_getppid_nt_win32;
-
 bool32 sys_isatty(int);
 int sys_chdir_nt(const char *);
 int sys_dup_nt(int, int, int, int);
@ -40,7 +37,6 @@ int sys_unlinkat_nt(int, const char *, int);
 int64_t sys_lseek_nt(int, int64_t, int);
 ssize_t sys_read_nt_impl(int, void *, size_t, int64_t);
 ssize_t sys_readlinkat_nt(int, const char *, char *, size_t);
-void sys_getppid_nt_wipe(int, int);

 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_SYSCALL_NT_INTERNAL_H_ */
--- a/libc/intrin/tailcontext.S
+++ b/libc/intrin/tailcontext.S
@ -57,7 +57,8 @@ __tailcontext:
 	mov	80(%rax),%rsp
 	push	88(%rax)
 	mov	24(%rax),%rdi
-	mov	64(%rax),%rax
+
+	xor	%eax,%eax
 	ret

 #elif defined(__aarch64__)
--- a/libc/calls/time.c
+++ b/libc/calls/time.c
@ -16,9 +16,10 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/sysv/consts/clock.h"
+#include "libc/time.h"
+#include "libc/calls/struct/timeval.h"
+#include "libc/dce.h"
+#include "libc/sysv/errfuns.h"

 /**
 * Returns time as seconds from UNIX epoch.
@ -28,11 +29,15 @@
 * @asyncsignalsafe
 */
 int64_t time(int64_t *opt_out_ret) {
-  int64_t secs = -1;
-  struct timespec ts;
-  if (!clock_gettime(CLOCK_REALTIME, &ts))
-    secs = ts.tv_sec;
-  if (opt_out_ret)
-    *opt_out_ret = secs;
+  int64_t secs;
+  struct timeval tv;
+  if (gettimeofday(&tv, 0) != -1) {
+    secs = tv.tv_sec;
+    if (opt_out_ret) {
+      *opt_out_ret = secs;
+    }
+  } else {
+    secs = -1;
+  }
  return secs;
 }
--- a/libc/intrin/timespec_add.c
+++ b/libc/intrin/timespec_add.c
--- a/libc/intrin/timespec_cmp.c
+++ b/libc/intrin/timespec_cmp.c
--- a/libc/intrin/timespec_frommicros.c
+++ b/libc/intrin/timespec_frommicros.c
--- a/libc/intrin/timespec_frommillis.c
+++ b/libc/intrin/timespec_frommillis.c
--- a/libc/intrin/timespec_fromnanos.c
+++ b/libc/intrin/timespec_fromnanos.c
--- a/libc/intrin/timespec_sub.c
+++ b/libc/intrin/timespec_sub.c
--- a/libc/intrin/timespec_subz.c
+++ b/libc/intrin/timespec_subz.c
--- a/libc/intrin/timespec_tomicros.c
+++ b/libc/intrin/timespec_tomicros.c
--- a/libc/intrin/timespec_tomillis.c
+++ b/libc/intrin/timespec_tomillis.c
--- a/libc/intrin/timespec_tonanos.c
+++ b/libc/intrin/timespec_tonanos.c
--- a/libc/intrin/timespec_totimeval.c
+++ b/libc/intrin/timespec_totimeval.c
--- a/libc/intrin/timeval_add.c
+++ b/libc/intrin/timeval_add.c
--- a/libc/intrin/timeval_cmp.c
+++ b/libc/intrin/timeval_cmp.c
--- a/libc/intrin/timeval_frommicros.c
+++ b/libc/intrin/timeval_frommicros.c
--- a/libc/intrin/timeval_frommillis.c
+++ b/libc/intrin/timeval_frommillis.c
--- a/libc/intrin/timeval_sub.c
+++ b/libc/intrin/timeval_sub.c
--- a/libc/intrin/timeval_subz.c
+++ b/libc/intrin/timeval_subz.c
--- a/libc/intrin/timeval_tomicros.c
+++ b/libc/intrin/timeval_tomicros.c
--- a/libc/intrin/timeval_tomillis.c
+++ b/libc/intrin/timeval_tomillis.c
--- a/libc/intrin/timeval_toseconds.c
+++ b/libc/intrin/timeval_toseconds.c
--- a/libc/intrin/ucontext.c
+++ b/libc/intrin/ucontext.c
@ -23,7 +23,7 @@
 #include "libc/sysv/consts/sig.h"
 #include "libc/thread/tls.h"

-int __tailcontext(const ucontext_t *) wontreturn;
+int __tailcontext(const ucontext_t *);

 /**
 * Sets machine context.
@ -40,7 +40,7 @@ int setcontext(const ucontext_t *uc) {
  } else {
    sys_sigprocmask(SIG_SETMASK, &uc->uc_sigmask, 0);
  }
-  __tailcontext(uc);
+  return __tailcontext(uc);
 }

 int __getcontextsig(ucontext_t *uc) {
--- a/libc/calls/vdsofunc.greg.c
+++ b/libc/calls/vdsofunc.greg.c
--- a/libc/calls/winexec.c
+++ b/libc/calls/winexec.c
@ -80,8 +80,7 @@ textwindows int IsWindowsExecutable(int64_t handle, const char16_t *path) {
  uint32_t got;
  BLOCK_SIGNALS;
  struct NtOverlapped overlap = {.hEvent = CreateEvent(0, 0, 0, 0)};
-  ok = overlap.hEvent &&
-       (ReadFile(handle, buf, 2, 0, &overlap) ||
+  ok = (ReadFile(handle, buf, 2, 0, &overlap) ||
        GetLastError() == kNtErrorIoPending) &&
       GetOverlappedResult(handle, &overlap, &got, true);
  CloseHandle(overlap.hEvent);
--- a/libc/cosmo.h
+++ b/libc/cosmo.h
@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_LIBC_COSMO_H_
 #define COSMOPOLITAN_LIBC_COSMO_H_
-#include "libc/calls/struct/timespec.h"
 COSMOPOLITAN_C_START_

 #ifndef __cplusplus
@ -9,33 +8,14 @@ COSMOPOLITAN_C_START_
 #define _COSMO_ATOMIC(x) x
 #endif

-errno_t cosmo_once(_COSMO_ATOMIC(unsigned) *, void (*)(void));
+errno_t cosmo_once(_COSMO_ATOMIC(unsigned) *, void (*)(void)) libcesque;
 int systemvpe(const char *, char *const[], char *const[]) libcesque;
 char *GetProgramExecutableName(void) libcesque;
 void unleaf(void) libcesque;
-bool32 IsLinuxModern(void) libcesque;
-
 int __demangle(char *, const char *, size_t) libcesque;
 int __is_mangled(const char *) libcesque;
-
-int cosmo_args(const char *, char ***) libcesque;
+bool32 IsLinuxModern(void) libcesque;
 int LoadZipArgs(int *, char ***) libcesque;

-int cosmo_futex_wake(_COSMO_ATOMIC(int) *, int, char);
-int cosmo_futex_wait(_COSMO_ATOMIC(int) *, int, char, int,
-                     const struct timespec *);
-
-errno_t cosmo_stack_alloc(size_t *, size_t *, void **) libcesque;
-errno_t cosmo_stack_free(void *, size_t, size_t) libcesque;
-void cosmo_stack_clear(void) libcesque;
-void cosmo_stack_setmaxstacks(int) libcesque;
-int cosmo_stack_getmaxstacks(void) libcesque;
-
-int __deadlock_check(void *, int) libcesque;
-int __deadlock_tracked(void *) libcesque;
-void __deadlock_record(void *, int) libcesque;
-void __deadlock_track(void *, int) libcesque;
-void __deadlock_untrack(void *) libcesque;
-
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_COSMO_H_ */
--- a/libc/crt/crt.S
+++ b/libc/crt/crt.S
@ -47,14 +47,7 @@ __oops_win32:
 //	@note	ape.S and ape-loader both set RCX to XNU on Darwin
 //	@noreturn
 _start:
-	.cfi_startproc
-#if defined(__x86_64__)
-	.cfi_undefined rip
-#elif defined(__aarch64__)
-	.cfi_undefined x30
-#endif /* __x86_64__ */
-
-#if defined(__x86_64__)
+#ifdef __x86_64__

 #if SupportsFreebsd()
 //	detect free besiyata dishmaya
@ -166,5 +159,4 @@ _start:
 #else
 #error "architecture unsupported"
 #endif /* __x86_64__ */
-	.cfi_endproc
 	.endfn	_start,weak,hidden
--- a/libc/dlopen/dlopen.c
+++ b/libc/dlopen/dlopen.c
@ -57,7 +57,6 @@
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/temp.h"
-#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"

@ -132,8 +131,6 @@ struct {

 long __sysv2nt14();
 long foreign_tramp();
-void __dlopen_lock(void);
-void __dlopen_unlock(void);

 static _Thread_local char dlerror_buf[128];

@ -254,7 +251,7 @@ static bool elf_slurp(struct Loaded *l, int fd, const char *file) {
  return true;
 }

-dontinline static bool elf_load(struct Loaded *l, const char *file, long pagesz,
+static dontinline bool elf_load(struct Loaded *l, const char *file, long pagesz,
                                char *interp_path, size_t interp_size) {
  int fd;
  if ((fd = open(file, O_RDONLY | O_CLOEXEC)) == -1)
@ -280,7 +277,7 @@ static long *push_strs(long *sp, char **list, int count) {
  return sp;
 }

-wontreturn dontinstrument static void foreign_helper(void **p) {
+static wontreturn dontinstrument void foreign_helper(void **p) {
  __foreign.dlopen = p[0];
  __foreign.dlsym = p[1];
  __foreign.dlclose = p[2];
@ -288,7 +285,7 @@ wontreturn dontinstrument static void foreign_helper(void **p) {
  _longjmp(__foreign.jb, 1);
 }

-dontinline static void elf_exec(const char *file, char **envp) {
+static dontinline void elf_exec(const char *file, char **envp) {

  // get microprocessor page size
  long pagesz = __pagesize;
@ -412,7 +409,7 @@ static char *dlerror_set(const char *str) {
  return dlerror_buf;
 }

-dontinline static char *foreign_alloc_block(void) {
+static dontinline char *foreign_alloc_block(void) {
  char *p = 0;
  size_t sz = 65536;
  if (!IsWindows()) {
@ -435,16 +432,17 @@ dontinline static char *foreign_alloc_block(void) {
  return p;
 }

-dontinline static void *foreign_alloc(size_t n) {
+static dontinline void *foreign_alloc(size_t n) {
  void *res;
  static char *block;
-  __dlopen_lock();
+  static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+  pthread_mutex_lock(&lock);
  if (!block || READ32LE(block) + n > 65536)
    if (!(block = foreign_alloc_block()))
      return 0;
  res = block + READ32LE(block);
  WRITE32LE(block, READ32LE(block) + n);
-  __dlopen_unlock();
+  pthread_mutex_unlock(&lock);
  return res;
 }

@ -548,7 +546,7 @@ static void *foreign_thunk_nt(void *func) {
  return code;
 }

-dontinline static bool foreign_compile(char exe[hasatleast PATH_MAX]) {
+static dontinline bool foreign_compile(char exe[hasatleast PATH_MAX]) {

  // construct path
  strlcpy(exe, get_tmp_dir(), PATH_MAX);
@ -810,7 +808,7 @@ void *cosmo_dlopen(const char *path, int mode) {
  }
  ALLOW_CANCELATION;
  ALLOW_SIGNALS;
-  STRACE("cosmo_dlopen(%#s, %d) → %p% m", path, mode, res);
+  STRACE("dlopen(%#s, %d) → %p% m", path, mode, res);
  return res;
 }

@ -855,7 +853,7 @@ void *cosmo_dlsym(void *handle, const char *name) {
  } else {
    func = 0;
  }
-  STRACE("cosmo_dlsym(%p, %#s) → %p", handle, name, func);
+  STRACE("dlsym(%p, %#s) → %p", handle, name, func);
  return func;
 }

@ -890,7 +888,7 @@ int cosmo_dlclose(void *handle) {
  } else {
    res = -1;
  }
-  STRACE("cosmo_dlclose(%p) → %d", handle, res);
+  STRACE("dlclose(%p) → %d", handle, res);
  return res;
 }

@ -909,6 +907,6 @@ char *cosmo_dlerror(void) {
  } else {
    res = dlerror_buf;
  }
-  STRACE("cosmo_dlerror() → %#s", res);
+  STRACE("dlerror() → %#s", res);
  return res;
 }
--- a/libc/dlopen/stubs.c
+++ b/libc/dlopen/stubs.c
@ -17,10 +17,6 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dlopen/dlfcn.h"
-#include "libc/intrin/strace.h"
-
-#define DLOPEN_ERROR \
-  "dlopen() isn't supported; consider using cosmo_dlopen() and read its docs"

 /**
 * Opens dynamic shared object using host platform libc.
@ -31,13 +27,12 @@
 *
 * @return null always
 */
-void *dlopen(const char *path, int mode) {
-  STRACE("dlopen(%#s, %d) → 0 [%s]", path, mode, DLOPEN_ERROR);
+void *dlopen(const char *, int) {
  return 0;
 }

 char *dlerror(void) {
-  return DLOPEN_ERROR;
+  return "dlopen() isn't supported by cosmo; try using cosmo_dlopen()";
 }

 void *dlsym(void *, const char *) {
--- a/libc/elf/def.h
+++ b/libc/elf/def.h
@ -68,7 +68,6 @@
 #define EM_NONE      0
 #define EM_M32       1
 #define EM_386       3
-#define EM_MIPS      8
 #define EM_PPC64     21
 #define EM_S390      22
 #define EM_ARM       40
--- a/libc/errno.h
+++ b/libc/errno.h
@ -26,11 +26,11 @@ COSMOPOLITAN_C_START_
 /* this header is included by 700+ files; therefore we */
 /* hand-roll &__get_tls()->tib_errno to avoid #include */
 /* cosmopolitan uses x28 as the tls register b/c apple */
-#define errno                                       \
-  (*__extension__({                                 \
-    errno_t *__ep;                                  \
-    __asm__("sub\t%0,x28,#1024-0x3c" : "=r"(__ep)); \
-    __ep;                                           \
+#define errno                                      \
+  (*__extension__({                                \
+    errno_t *__ep;                                 \
+    __asm__("sub\t%0,x28,#512-0x3c" : "=r"(__ep)); \
+    __ep;                                          \
  }))
 #else
 #define errno (*__errno_location())
--- a/libc/fmt/internal.h
+++ b/libc/fmt/internal.h
@ -49,6 +49,6 @@
 int __vcscanf(int (*)(void *), int (*)(int, void *), void *, const char *,
              va_list);
 int __fmt(void *, void *, const char *, va_list, int *);
-char16_t *__itoa16(char16_t[21], uint64_t) __msabi;
+__msabi char16_t *__itoa16(char16_t[21], uint64_t);

 #endif /* COSMOPOLITAN_LIBC_FMT_STRTOL_H_ */
--- a/libc/integral/c.inc
+++ b/libc/integral/c.inc
@ -135,7 +135,7 @@ typedef struct {
 #define strftimeesque(n) __attribute__((__format__(__strftime__, n, 0)))

 #ifndef privileged
-#define privileged _Section(".privileged") dontinstrument dontubsan
+#define privileged _Section(".privileged") dontinline dontinstrument dontubsan
 #endif

 #ifndef wontreturn
--- a/libc/integral/normalize.inc
+++ b/libc/integral/normalize.inc
@ -2,9 +2,9 @@
 #undef __COSMOPOLITAN__
 #endif

-#define __COSMOPOLITAN_MAJOR__ 4
-#define __COSMOPOLITAN_MINOR__ 0
-#define __COSMOPOLITAN_PATCH__ 2
+#define __COSMOPOLITAN_MAJOR__ 3
+#define __COSMOPOLITAN_MINOR__ 9
+#define __COSMOPOLITAN_PATCH__ 5
 #define __COSMOPOLITAN__                                                   \
  (100000000 * __COSMOPOLITAN_MAJOR__ + 1000000 * __COSMOPOLITAN_MINOR__ + \
   __COSMOPOLITAN_PATCH__)
--- a/libc/intrin/BUILD.mk
+++ b/libc/intrin/BUILD.mk
@ -30,11 +30,9 @@ LIBC_INTRIN_A_CHECKS =					\
 LIBC_INTRIN_A_DIRECTDEPS =				\
 	LIBC_NEXGEN32E					\
 	LIBC_NT_KERNEL32				\
-	LIBC_NT_REALTIME				\
-	LIBC_NT_SYNCHRONIZATION				\
 	LIBC_NT_WS2_32					\
 	LIBC_SYSV					\
-	LIBC_SYSV_CALLS					\
+	LIBC_SYSV_CALLS

 LIBC_INTRIN_A_DEPS :=					\
 	$(call uniq,$(foreach x,$(LIBC_INTRIN_A_DIRECTDEPS),$($(x))))
@ -108,30 +106,14 @@ o//libc/intrin/demangle.o: private			\
 		CFLAGS +=				\
 			-mgeneral-regs-only

-# ensure that division is optimized
-o/$(MODE)/libc/intrin/windowsdurationtotimeval.o	\
-o/$(MODE)/libc/intrin/windowsdurationtotimespec.o	\
-o/$(MODE)/libc/intrin/timevaltowindowstime.o		\
-o/$(MODE)/libc/intrin/timespectowindowstime.o		\
-o/$(MODE)/libc/intrin/windowstimetotimeval.o		\
-o/$(MODE)/libc/intrin/windowstimetotimespec.o: private	\
-		CFLAGS +=				\
-			-O2
-
 # these assembly files are safe to build on aarch64
-o/$(MODE)/libc/intrin/getcontext.o: libc/intrin/getcontext.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/libc/intrin/swapcontext.o: libc/intrin/swapcontext.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/libc/intrin/tailcontext.o: libc/intrin/tailcontext.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/aarch64/%.o: libc/intrin/aarch64/%.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/fenv.o: libc/intrin/fenv.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/gcov.o: libc/intrin/gcov.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/libc/intrin/cosmo_futex_thunk.o: libc/intrin/cosmo_futex_thunk.S
+o/$(MODE)/libc/intrin/futex.o: libc/intrin/futex.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/typeinfo.o: libc/intrin/typeinfo.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
--- a/libc/intrin/__getenv.c
+++ b/libc/intrin/__getenv.c
@ -20,7 +20,7 @@
 #include "libc/intrin/getenv.h"
 #include "libc/intrin/kprintf.h"

-privileged optimizesize struct Env __getenv(char **p, const char *k) {
+privileged struct Env __getenv(char **p, const char *k) {
  char *t;
  int i, j;
  for (i = 0; (t = p[i]); ++i) {
--- a/libc/intrin/bzero.c
+++ b/libc/intrin/bzero.c
@ -16,18 +16,155 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/dce.h"
+#include "libc/nexgen32e/nexgen32e.h"
+#include "libc/nexgen32e/x86feature.h"
 #include "libc/str/str.h"

+typedef char xmm_t __attribute__((__vector_size__(16), __aligned__(1)));
+typedef long long xmm_a __attribute__((__vector_size__(16), __aligned__(16)));
+
+static void bzero128(char *p, size_t n) {
+  xmm_t v = {0};
+  if (n <= 32) {
+    *(xmm_t *)(p + n - 16) = v;
+    *(xmm_t *)p = v;
+  } else {
+    do {
+      n -= 32;
+      *(xmm_t *)(p + n) = v;
+      *(xmm_t *)(p + n + 16) = v;
+    } while (n > 32);
+    *(xmm_t *)(p + 16) = v;
+    *(xmm_t *)p = v;
+  }
+}
+
+#if defined(__x86_64__) && !defined(__chibicc__)
+_Microarchitecture("avx") static void bzero_avx(char *p, size_t n) {
+  xmm_t v = {0};
+  if (n <= 32) {
+    *(xmm_t *)(p + n - 16) = v;
+    *(xmm_t *)p = v;
+  } else if (n >= 1024 && X86_HAVE(ERMS)) {
+    asm("rep stosb" : "+D"(p), "+c"(n), "=m"(*(char(*)[n])p) : "a"(0));
+  } else {
+    if (n < kHalfCache3 || !kHalfCache3) {
+      do {
+        n -= 32;
+        *(xmm_t *)(p + n) = v;
+        *(xmm_t *)(p + n + 16) = v;
+      } while (n > 32);
+    } else {
+      while ((uintptr_t)(p + n) & 15) {
+        p[--n] = 0;
+      }
+      do {
+        n -= 32;
+        __builtin_ia32_movntdq((xmm_a *)(p + n), (xmm_a)v);
+        __builtin_ia32_movntdq((xmm_a *)(p + n + 16), (xmm_a)v);
+      } while (n > 32);
+      asm("sfence");
+    }
+    *(xmm_t *)(p + 16) = v;
+    *(xmm_t *)p = v;
+  }
+}
+#endif
+
 /**
 * Sets memory to zero.
 *
+ *     bzero n=0                          661 picoseconds
+ *     bzero n=1                          661 ps/byte          1,476 mb/s
+ *     bzero n=2                          330 ps/byte          2,952 mb/s
+ *     bzero n=3                          220 ps/byte          4,428 mb/s
+ *     bzero n=4                          165 ps/byte          5,904 mb/s
+ *     bzero n=7                           94 ps/byte         10,333 mb/s
+ *     bzero n=8                           41 ps/byte         23,618 mb/s
+ *     bzero n=15                          44 ps/byte         22,142 mb/s
+ *     bzero n=16                          20 ps/byte         47,236 mb/s
+ *     bzero n=31                          21 ps/byte         45,760 mb/s
+ *     bzero n=32                          20 ps/byte         47,236 mb/s
+ *     bzero n=63                          10 ps/byte         92,997 mb/s
+ *     bzero n=64                          15 ps/byte         62,982 mb/s
+ *     bzero n=127                         15 ps/byte         62,490 mb/s
+ *     bzero n=128                         10 ps/byte         94,473 mb/s
+ *     bzero n=255                         14 ps/byte         68,439 mb/s
+ *     bzero n=256                          9 ps/byte            105 gb/s
+ *     bzero n=511                         15 ps/byte         62,859 mb/s
+ *     bzero n=512                         11 ps/byte         83,976 mb/s
+ *     bzero n=1023                        15 ps/byte         61,636 mb/s
+ *     bzero n=1024                        10 ps/byte         88,916 mb/s
+ *     bzero n=2047                         9 ps/byte            105 gb/s
+ *     bzero n=2048                         8 ps/byte            109 gb/s
+ *     bzero n=4095                         8 ps/byte            115 gb/s
+ *     bzero n=4096                         8 ps/byte            118 gb/s
+ *     bzero n=8191                         7 ps/byte            129 gb/s
+ *     bzero n=8192                         7 ps/byte            130 gb/s
+ *     bzero n=16383                        6 ps/byte            136 gb/s
+ *     bzero n=16384                        6 ps/byte            137 gb/s
+ *     bzero n=32767                        6 ps/byte            140 gb/s
+ *     bzero n=32768                        6 ps/byte            141 gb/s
+ *     bzero n=65535                       15 ps/byte         64,257 mb/s
+ *     bzero n=65536                       15 ps/byte         64,279 mb/s
+ *     bzero n=131071                      15 ps/byte         63,166 mb/s
+ *     bzero n=131072                      15 ps/byte         63,115 mb/s
+ *     bzero n=262143                      15 ps/byte         62,052 mb/s
+ *     bzero n=262144                      15 ps/byte         62,097 mb/s
+ *     bzero n=524287                      15 ps/byte         61,699 mb/s
+ *     bzero n=524288                      15 ps/byte         61,674 mb/s
+ *     bzero n=1048575                     16 ps/byte         60,179 mb/s
+ *     bzero n=1048576                     15 ps/byte         61,330 mb/s
+ *     bzero n=2097151                     15 ps/byte         61,071 mb/s
+ *     bzero n=2097152                     15 ps/byte         61,065 mb/s
+ *     bzero n=4194303                     16 ps/byte         60,942 mb/s
+ *     bzero n=4194304                     16 ps/byte         60,947 mb/s
+ *     bzero n=8388607                     16 ps/byte         60,872 mb/s
+ *     bzero n=8388608                     16 ps/byte         60,879 mb/s
+ *
 * @param p is memory address
 * @param n is byte length
 * @return p
 * @asyncsignalsafe
 */
 void bzero(void *p, size_t n) {
-  memset(p, 0, n);
+  char *b;
+  uint64_t x;
+  b = p;
+#ifdef __x86_64__
+  asm("xorl\t%k0,%k0" : "=r"(x));
+#else
+  if (1) {
+    memset(p, 0, n);
+    return;
+  }
+  x = 0;
+#endif
+  if (n <= 16) {
+    if (n >= 8) {
+      __builtin_memcpy(b, &x, 8);
+      __builtin_memcpy(b + n - 8, &x, 8);
+    } else if (n >= 4) {
+      __builtin_memcpy(b, &x, 4);
+      __builtin_memcpy(b + n - 4, &x, 4);
+    } else if (n) {
+      do {
+        asm volatile("" ::: "memory");
+        b[--n] = x;
+      } while (n);
+    }
+#if defined(__x86_64__) && !defined(__chibicc__)
+  } else if (IsTiny()) {
+    asm("rep stosb" : "+D"(b), "+c"(n), "=m"(*(char(*)[n])b) : "a"(0));
+    return;
+  } else if (X86_HAVE(AVX)) {
+    bzero_avx(b, n);
+#endif
+  } else {
+    bzero128(b, n);
+  }
 }

 __weak_reference(bzero, explicit_bzero);
--- a/libc/intrin/count.c
+++ b/libc/intrin/count.c
@ -1,26 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/atomic.h"
-#include "libc/stdalign.h"
-#include "libc/thread/thread.h"
-
-// this counter is important because pthread_exit() needs to know if
-// it's an orphan thread, without needing to acquire _pthread_lock()
-// which causes contention and a file descriptor explosion on netbsd
-alignas(64) atomic_uint _pthread_count = 1;
--- a/Show more
+++ b/Show more