Fix the build

Add posix semaphores support
There's still some bugs to work out on Windows and OpenBSD.
2026-11-08 01:58:20 -10:00 · 2022-10-14 11:18:40 -07:00 · 2022-10-14 09:21:02 -07:00 · 2022-10-13 15:54:05 -07:00 · 2022-10-13 13:44:41 -07:00 · 2022-10-12 11:07:11 -07:00
10887 changed files with 549786 additions and 66118 deletions
@@ -0,0 +1,31 @@
+name: build
+
+on:
+  push:
+    branches:
+      - "master"
+      - "flake"
+  pull_request:
+    branches:
+      - "master"
+
+  # run workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  matrix_on_mode:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        mode: ["", tiny, opt, rel]
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: support ape bins 1
+        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 }}
@@ -11,3 +11,5 @@ __pycache__
 /TAGS
 /bx_enh_dbg.ini
 /tool/emacs/*.elc
+/perf.data
+/perf.data.old
@@ -1,6 +0,0 @@
-virt: lxd
-os: linux
-language: c
-script: make -j4 V=0
-notifications:
-  email: false
@@ -43,10 +43,10 @@
 				"forcealignargpointer=",
 				"noasan=",
 				"noubsan=",
-				"testonly=",
 				"donothing=",
 				"nosideeffect=",
-				"unreachable=",
+				"unreachable=",,
+				"notpossible=",
 				"thatispacked=",
 				"dontthrow=",
 				"nocallback=",
@@ -59,15 +59,21 @@
 #
 #   build/config.mk

-SHELL   = build/bootstrap/cocmd.com
-HOSTS  ?= freebsd openbsd netbsd rhel7 rhel5 win7 win10 xnu
-#SANITY := $(shell build/sanitycheck $$PPID)
+SHELL      = build/bootstrap/cocmd.com
+HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 win10 xnu
+MAKEFLAGS += -j --no-builtin-rules

 .SUFFIXES:
 .DELETE_ON_ERROR:
 .FEATURES: output-sync
 .PHONY: all o bins check test depend tags

+ifneq ($(m),)
+ifeq ($(MODE),)
+MODE := $(m)
+endif
+endif
+
 all:	o
 o:	o/$(MODE)

@@ -81,6 +87,21 @@ o/$(MODE):			\
 	o/$(MODE)/examples	\
 	o/$(MODE)/third_party

+.STRICT = 1
+.PLEDGE = stdio rpath wpath cpath fattr proc
+.UNVEIL =			\
+	libc/integral		\
+	libc/disclaimer.inc	\
+	rx:build/bootstrap	\
+	rx:o/third_party/gcc	\
+	/proc/stat		\
+	rw:/dev/null		\
+	w:o/stack.log		\
+	/etc/hosts		\
+	~/.runit.psk		\
+	/proc/self/status	\
+	/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
+
 PKGS =

 -include ~/.cosmo.mk
@@ -97,25 +118,25 @@ include libc/intrin/intrin.mk			# │  You can use the stack
 include libc/linux/linux.mk			# │  You can manipulate arrays
 include libc/tinymath/tinymath.mk		# │  You can issue raw system calls
 include third_party/compiler_rt/compiler_rt.mk	# │
-include libc/bits/bits.mk			# │
 include libc/str/str.mk				# │
 include third_party/xed/xed.mk			# │
 include third_party/zlib/zlib.mk		# │
+include third_party/double-conversion/dc.mk	# │
 include libc/elf/elf.mk				# │
 include ape/ape.mk				# │
-include libc/fmt/fmt.mk				#─┘
+include libc/fmt/fmt.mk				# │
+include libc/vga/vga.mk				#─┘
 include libc/calls/calls.mk			#─┐
 include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
 include libc/crt/crt.mk				# │  You can issue system calls
-include libc/rand/rand.mk			# │
-include libc/unicode/unicode.mk			# │
+include third_party/nsync/nsync.mk		# │
 include third_party/dlmalloc/dlmalloc.mk	#─┘
 include libc/mem/mem.mk				#─┐
 include libc/zipos/zipos.mk			# ├──DYNAMIC RUNTIME
 include third_party/gdtoa/gdtoa.mk		# │  You can now use stdio
 include libc/time/time.mk			# │  You can finally call malloc()
+include third_party/nsync/mem/mem.mk		# │
 include libc/thread/thread.mk			# │
-include libc/alg/alg.mk				# │
 include libc/stdio/stdio.mk			# │
 include third_party/libcxx/libcxx.mk		# │
 include net/net.mk				# │
@@ -140,14 +161,20 @@ include net/https/https.mk			# │
 include third_party/regex/regex.mk		#─┘
 include third_party/tidy/tidy.mk
 include third_party/third_party.mk
+include third_party/nsync/testing/testing.mk
 include libc/testlib/testlib.mk
 include tool/viz/lib/vizlib.mk
 include tool/args/args.mk
 include test/tool/args/test.mk
 include third_party/linenoise/linenoise.mk
 include third_party/maxmind/maxmind.mk
+include net/finger/finger.mk
+include third_party/double-conversion/test/test.mk
 include third_party/lua/lua.mk
+include third_party/sed/sed.mk
+include third_party/awk/awk.mk
 include third_party/make/make.mk
+include third_party/finger/finger.mk
 include third_party/argon2/argon2.mk
 include third_party/smallz4/smallz4.mk
 include third_party/sqlite3/sqlite3.mk
@@ -177,7 +204,7 @@ include tool/hash/hash.mk
 include tool/net/net.mk
 include tool/viz/viz.mk
 include tool/tool.mk
-include test/libc/alg/test.mk
+include net/turfwar/turfwar.mk
 include test/libc/tinymath/test.mk
 include test/libc/intrin/test.mk
 include test/libc/mem/test.mk
@@ -185,22 +212,22 @@ include test/libc/nexgen32e/test.mk
 include test/libc/runtime/test.mk
 include test/libc/thread/test.mk
 include test/libc/sock/test.mk
-include test/libc/bits/test.mk
 include test/libc/str/test.mk
 include test/libc/log/test.mk
-include test/libc/unicode/test.mk
+include test/libc/str/test.mk
 include test/libc/calls/test.mk
 include test/libc/x/test.mk
 include test/libc/xed/test.mk
 include test/libc/fmt/test.mk
 include test/libc/dns/test.mk
-include test/libc/rand/test.mk
 include test/libc/time/test.mk
 include test/libc/stdio/test.mk
+include test/libc/zipos/test.mk
 include test/libc/release/test.mk
 include test/libc/test.mk
 include test/net/http/test.mk
 include test/net/https/test.mk
+include test/net/finger/test.mk
 include test/net/test.mk
 include test/tool/build/lib/test.mk
 include test/tool/build/test.mk
@@ -248,119 +275,125 @@ o/$(MODE)/srcs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS
 o/$(MODE)/hdrs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(HDRS) $(INCS),$(file >>$@,$(x)))

+TAGS: private .UNSANDBOXED = 1
 TAGS:	o/$(MODE)/srcs-old.txt $(SRCS)
 	@$(RM) $@
-	@$(COMPILE) -ATAGS -T$@ $(TAGS) $(TAGSFLAGS) -L $< -o $@
+	@$(TAGS) $(TAGSFLAGS) -L $< -o $@

+HTAGS: private .UNSANDBOXED = 1
 HTAGS:	o/$(MODE)/hdrs-old.txt $(HDRS)
 	@$(RM) $@
-	@$(COMPILE) -ATAGS -T$@ build/htags -L $< -o $@
+	@build/htags -L $< -o $@

+loc: private .UNSANDBOXED = 1
 loc: o/$(MODE)/tool/build/summy.com
 	find -name \*.h -or -name \*.c -or -name \*.S | \
 	$(XARGS) wc -l | grep total | awk '{print $$1}' | $<

-COSMOPOLITAN_OBJECTS =		\
-	NET_HTTP		\
-	LIBC_DNS		\
-	LIBC_SOCK		\
-	LIBC_NT_WS2_32		\
-	LIBC_NT_IPHLPAPI	\
-	LIBC_NT_MSWSOCK		\
-	LIBC_X			\
-	THIRD_PARTY_GETOPT	\
-	LIBC_LOG		\
-	LIBC_UNICODE		\
-	LIBC_TIME		\
-	LIBC_ZIPOS		\
-	THIRD_PARTY_ZLIB	\
-	THIRD_PARTY_MUSL	\
-	LIBC_STDIO		\
-	THIRD_PARTY_GDTOA	\
-	THIRD_PARTY_REGEX	\
-	LIBC_ALG		\
-	LIBC_MEM		\
-	THIRD_PARTY_DLMALLOC	\
-	LIBC_BITS		\
-	LIBC_RUNTIME		\
-	LIBC_ELF		\
-	LIBC_CALLS		\
-	LIBC_RAND		\
-	LIBC_SYSV_CALLS		\
-	LIBC_NT_PSAPI		\
-	LIBC_NT_POWRPROF	\
-	LIBC_NT_PDH		\
-	LIBC_NT_SHELL32		\
-	LIBC_NT_GDI32		\
-	LIBC_NT_COMDLG32	\
-	LIBC_NT_NETAPI32	\
-	LIBC_NT_URL		\
-	LIBC_NT_USER32		\
-	LIBC_NT_NTDLL		\
-	LIBC_NT_ADVAPI32	\
-	LIBC_FMT		\
-	THIRD_PARTY_COMPILER_RT	\
-	LIBC_THREAD		\
-	LIBC_TINYMATH		\
-	THIRD_PARTY_XED		\
-	LIBC_STR		\
-	LIBC_SYSV		\
-	LIBC_INTRIN		\
-	LIBC_NT_KERNEL32	\
+# PLEASE: MAINTAIN TOPOLOGICAL ORDER
+# FROM HIGHEST LEVEL TO LOWEST LEVEL
+COSMOPOLITAN_OBJECTS =			\
+	NET_HTTP			\
+	LIBC_DNS			\
+	LIBC_SOCK			\
+	LIBC_NT_WS2_32			\
+	LIBC_NT_IPHLPAPI		\
+	LIBC_NT_MSWSOCK			\
+	LIBC_X				\
+	THIRD_PARTY_GETOPT		\
+	LIBC_LOG			\
+	LIBC_TIME			\
+	LIBC_ZIPOS			\
+	THIRD_PARTY_ZLIB		\
+	THIRD_PARTY_MUSL		\
+	LIBC_STDIO			\
+	THIRD_PARTY_GDTOA		\
+	THIRD_PARTY_REGEX		\
+	LIBC_THREAD			\
+	THIRD_PARTY_NSYNC_MEM		\
+	LIBC_MEM			\
+	THIRD_PARTY_DLMALLOC		\
+	LIBC_RUNTIME			\
+	THIRD_PARTY_NSYNC		\
+	LIBC_ELF			\
+	LIBC_CALLS			\
+	LIBC_SYSV_CALLS			\
+	LIBC_VGA			\
+	LIBC_NT_PSAPI			\
+	LIBC_NT_POWRPROF		\
+	LIBC_NT_PDH			\
+	LIBC_NT_GDI32			\
+	LIBC_NT_COMDLG32		\
+	LIBC_NT_URL			\
+	LIBC_NT_USER32			\
+	LIBC_NT_NTDLL			\
+	LIBC_NT_ADVAPI32		\
+	LIBC_NT_SYNCHRONIZATION		\
+	LIBC_FMT			\
+	THIRD_PARTY_COMPILER_RT		\
+	LIBC_TINYMATH			\
+	THIRD_PARTY_XED			\
+	LIBC_STR			\
+	LIBC_SYSV			\
+	LIBC_INTRIN			\
+	LIBC_NT_KERNEL32		\
 	LIBC_NEXGEN32E

-COSMOPOLITAN_HEADERS =		\
-	LIBC			\
-	LIBC_ALG		\
-	LIBC_BITS		\
-	LIBC_CALLS		\
-	LIBC_DNS		\
-	LIBC_ELF		\
-	LIBC_FMT		\
-	LIBC_INTRIN		\
-	LIBC_LOG		\
-	LIBC_MEM		\
-	LIBC_NEXGEN32E		\
-	LIBC_NT			\
-	LIBC_RAND		\
-	LIBC_RUNTIME		\
-	LIBC_SOCK		\
-	LIBC_STDIO		\
-	THIRD_PARTY_XED		\
-	LIBC_STR		\
-	LIBC_SYSV		\
-	LIBC_THREAD		\
-	LIBC_TIME		\
-	LIBC_TINYMATH		\
-	LIBC_UNICODE		\
-	LIBC_X			\
-	LIBC_ZIPOS		\
-	NET_HTTP		\
-	THIRD_PARTY_DLMALLOC	\
-	THIRD_PARTY_GDTOA	\
-	THIRD_PARTY_GETOPT	\
-	THIRD_PARTY_MUSL	\
-	THIRD_PARTY_ZLIB	\
-	THIRD_PARTY_ZLIB_GZ	\
+COSMOPOLITAN_HEADERS =			\
+	APE				\
+	LIBC				\
+	LIBC_CALLS			\
+	LIBC_DNS			\
+	LIBC_ELF			\
+	LIBC_FMT			\
+	LIBC_INTRIN			\
+	LIBC_LOG			\
+	LIBC_MEM			\
+	LIBC_NEXGEN32E			\
+	LIBC_NT				\
+	LIBC_RUNTIME			\
+	LIBC_SOCK			\
+	LIBC_STDIO			\
+	THIRD_PARTY_NSYNC		\
+	THIRD_PARTY_XED			\
+	LIBC_STR			\
+	LIBC_SYSV			\
+	LIBC_THREAD			\
+	LIBC_TIME			\
+	LIBC_TINYMATH			\
+	LIBC_X				\
+	LIBC_ZIPOS			\
+	LIBC_VGA			\
+	NET_HTTP			\
+	THIRD_PARTY_DLMALLOC		\
+	THIRD_PARTY_GDTOA		\
+	THIRD_PARTY_GETOPT		\
+	THIRD_PARTY_MUSL		\
+	THIRD_PARTY_ZLIB		\
+	THIRD_PARTY_ZLIB_GZ		\
 	THIRD_PARTY_REGEX

 o/$(MODE)/cosmopolitan.a:	\
 		$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS))

-o/cosmopolitan.h:				\
-		o/$(MODE)/tool/build/rollup.com	\
-		libc/integral/normalize.inc	\
-		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS))
-	$(file >$@.args,libc/integral/normalize.inc $(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS)))
-	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$@.args >$@
+o/cosmopolitan.h:							\
+		o/$(MODE)/tool/build/rollup.com				\
+		libc/integral/normalize.inc				\
+		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS))	\
+		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_INCS))
+	$(file >$(TMPDIR)/$(subst /,_,$@),libc/integral/normalize.inc $(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS)))
+	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >$@

+o/cosmopolitan.html: private .UNSANDBOXED = 1
 o/cosmopolitan.html:							\
 		o/$(MODE)/third_party/chibicc/chibicc.com.dbg		\
-		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))
-	$(file >$@.args,$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS))))
+		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))	\
+		$(SRCS)							\
+		$(HDRS)
+	$(file >$(TMPDIR)/$(subst /,_,$@),$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS))))
 	o/$(MODE)/third_party/chibicc/chibicc.com.dbg -J		\
 		-fno-common -include libc/integral/normalize.inc -o $@	\
-		@$@.args
+		@$(TMPDIR)/$(subst /,_,$@)

 $(SRCS):					\
 	libc/integral/normalize.inc		\
@@ -370,6 +403,15 @@ $(SRCS):					\
 	libc/integral/lp64arg.inc		\
 	libc/integral/lp64.inc

+.PHONY: toolchain
+toolchain:	o/cosmopolitan.h				\
+		o/$(MODE)/ape/public/ape.lds			\
+		o/$(MODE)/libc/crt/crt.o			\
+		o/$(MODE)/ape/ape.o				\
+		o/$(MODE)/ape/ape-copy-self.o			\
+		o/$(MODE)/ape/ape-no-modify-self.o		\
+		o/$(MODE)/cosmopolitan.a
+
 # UNSPECIFIED PREREQUISITES TUTORIAL
 #
 # A build rule must exist for all files that make needs to consider in
@@ -1,5 +1,6 @@
 ![Cosmopolitan Honeybadger](usr/share/img/honeybadger.png)

+[![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
@@ -22,12 +23,12 @@ If you're doing your development work on Linux or BSD then you need just
 five files to get started. Here's what you do on Linux:

 ```sh
-wget https://justine.lol/cosmopolitan/cosmopolitan.zip
-unzip cosmopolitan.zip
+wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-2.1.1.zip
+unzip cosmopolitan-amalgamation-2.1.1.zip
 printf 'main() { printf("hello world\\n"); }\n' >hello.c
 gcc -g -Os -static -nostdlib -nostdinc -fno-pie -no-pie -mno-red-zone \
-  -fno-omit-frame-pointer -pg -mnop-mcount \
-  -o hello.com.dbg hello.c -fuse-ld=bfd -Wl,-T,ape.lds \
+  -fno-omit-frame-pointer -pg -mnop-mcount -mno-tls-direct-seg-refs -gdwarf-4 \
+  -o hello.com.dbg hello.c -fuse-ld=bfd -Wl,-T,ape.lds -Wl,--gc-sections \
  -include cosmopolitan.h crt.o ape-no-modify-self.o cosmopolitan.a
 objcopy -S -O binary hello.com.dbg hello.com
 ```
@@ -39,29 +40,43 @@ You now have a portable program.
 bash -c './hello.com'  # zsh/fish workaround (we patched them in 2021)
 ```

-Since we used the `ape-no-modify-self.o` bootloader (rather than
-`ape.o`) your executable will not modify itself when it's run. What
-it'll instead do, is extract a 4kb program to `${TMPDIR:-/tmp}` that
-maps your program into memory without needing to copy it. It's possible
-to install the APE loader systemwide as follows.
+If `./hello.com` executed on Linux throws an error about not finding an
+interpreter, it should be fixed by running the following command (although
+note that it may not survive a system restart):

 ```sh
-# (1) linux systems that want binfmt_misc
-ape/apeinstall.sh
-
-# (2) for linux/freebsd/netbsd/openbsd systems
-cp build/bootstrap/ape.elf /usr/bin/ape
-
-# (3) for mac os x systems
-cp build/bootstrap/ape.macho /usr/bin/ape
+sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
 ```

-If you followed steps (2) and (3) then there's going to be a slight
-constant-time startup latency each time you run an APE binary. Your
-system might also prevent your APE program from being installed to a
-system directory as a setuid binary or a script interpreter. To solve
-that, you can use the following flag to turn your binary into the
-platform local format (ELF or Mach-O):
+If the same command produces puzzling errors on WSL or WINE when using
+Redbean 2.x, they may be fixed by disabling binfmt_misc:
+
+```sh
+sudo sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/status'
+```
+
+Since we used the `ape-no-modify-self.o` bootloader (rather than
+`ape.o`) your executable will not modify itself when it's run. What
+it'll instead do, is extract a 4kb program to `${TMPDIR:-${HOME:-.}}`
+that maps your program into memory without needing to copy it. It's
+possible to install the APE loader systemwide as follows.
+
+```sh
+# System-Wide APE Install
+# for Linux, Darwin, and BSDs
+# 1. Copies APE Loader to /usr/bin/ape
+# 2. Registers w/ binfmt_misc too if Linux
+ape/apeinstall.sh
+
+# System-Wide APE Uninstall
+# for Linux, Darwin, and BSDs
+ape/apeuninstall.sh
+```
+
+It's also possible to convert APE binaries into the system-local format
+by using the `--assimilate` flag. Please note that if binfmt_misc is in
+play, you'll need to unregister it temporarily before doing this, since
+the assimilate feature is part of the shell script header.

 ```sh
 $ file hello.com
@@ -71,18 +86,27 @@ $ file hello.com
 hello.com: ELF 64-bit LSB executable
 ```

-There's also some other useful flags that get baked into your binary by
-default:
+Now that you're up and running with Cosmopolitan Libc and APE, here's
+some of the most important troubleshooting tools APE offers that you
+should know, in case you encounter any issues:

 ```sh
 ./hello.com --strace   # log system calls to stderr
 ./hello.com --ftrace   # log function calls to stderr
 ```

-If you want your `hello.com` program to be much tinier, more on the
-order of 16kb rather than 60kb, then all you have to do is use
-<https://justine.lol/cosmopolitan/cosmopolitan-tiny.zip> instead. See
-<https://justine.lol/cosmopolitan/download.html>.
+Do you love tiny binaries? If so, you may not be happy with Cosmo adding
+heavyweight features like tracing to your binaries by default. In that
+case, you may want to consider using our build system:
+
+```sh
+make m=tiny
+```
+
+Which will cause programs such as `hello.com` and `life.com` to shrink
+from 60kb in size to about 16kb. There's also a prebuilt amalgamation
+online <https://justine.lol/cosmopolitan/cosmopolitan-tiny.zip> hosted
+on our download page <https://justine.lol/cosmopolitan/download.html>.

 ### MacOS

@@ -131,7 +155,7 @@ cd cosmopolitan
 This will build the entire repository and run all the tests:

 ```sh
-build/bootstrap/make.com -j16
+build/bootstrap/make.com
 o//examples/hello.com
 find o -name \*.com | xargs ls -rShal | less
 ```
@@ -150,7 +174,7 @@ having minimal deterministic builds. For example, if you wanted to build
 only hello.com then you could do that as follows:

 ```sh
-build/bootstrap/make.com -j16 o//examples/hello.com
+build/bootstrap/make.com o//examples/hello.com
 ```

 Sometimes it's desirable to build a subset of targets, without having to
@@ -159,7 +183,7 @@ directory name. For example, if you wanted to build only the targets and
 subtargets of the chibicc package including its tests, you would say:

 ```sh
-build/bootstrap/make.com -j16 o//third_party/chibicc
+build/bootstrap/make.com o//third_party/chibicc
 o//third_party/chibicc/chibicc.com --help
 ```

@@ -167,18 +191,19 @@ 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
-build/bootstrap/make.com -j16 MODE=tiny
+build/bootstrap/make.com m=tiny
 ```

 Here's some other build modes you can try:

 ```sh
-build/bootstrap/make.com -j16 MODE=dbg       # asan + ubsan + debug
-build/bootstrap/make.com -j16 MODE=asan      # production memory safety
-build/bootstrap/make.com -j16 MODE=opt       # -march=native optimizations
-build/bootstrap/make.com -j16 MODE=rel       # traditional release binaries
-build/bootstrap/make.com -j16 MODE=optlinux  # optimal linux-only performance
-build/bootstrap/make.com -j16 MODE=tinylinux # tiniest linux-only 4kb binaries
+build/bootstrap/make.com m=dbg       # asan + ubsan + debug
+build/bootstrap/make.com m=asan      # production memory safety
+build/bootstrap/make.com m=opt       # -march=native optimizations
+build/bootstrap/make.com m=rel       # traditional release binaries
+build/bootstrap/make.com m=optlinux  # optimal linux-only performance
+build/bootstrap/make.com m=fastbuild # build 28% faster w/o debugging
+build/bootstrap/make.com m=tinylinux # tiniest linux-only 4kb binaries
 ```

 For further details, see [//build/config.mk](build/config.mk).
@@ -187,7 +212,7 @@ For further details, see [//build/config.mk](build/config.mk).

 Here's the recommended `~/.gdbinit` config:

-```
+```gdb
 set host-charset UTF-8
 set target-charset UTF-8
 set target-wide-charset UTF-8
@@ -220,9 +245,23 @@ gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
 | :---            | ---:        | ---:  |
 | AMD             | K8 Venus    | 2005  |
 | Intel           | Core        | 2006  |
-| New Technology  | Vista       | 2006  |
-| GNU/Systemd     | 2.6.18      | 2007  |
-| XNU's Not UNIX! | 15.6        | 2018  |
-| FreeBSD         | 13          | 2020  |
+| Linux           | 2.6.18      | 2007  |
+| Windows         | 8           | 2012  |
+| Mac OS X        | 15.6        | 2018  |
 | OpenBSD         | 6.4         | 2018  |
+| FreeBSD         | 13          | 2020  |
 | NetBSD          | 9.2         | 2021  |
+
+## Special Thanks
+
+Funding for this project is crowdsourced using
+[GitHub Sponsors](https://github.com/sponsors/jart) and
+[Patreon](https://www.patreon.com/jart). Your support is what makes this
+project possible. Thank you! We'd also like to give special thanks to
+the following groups and individuals:
+
+- [Joe Drumgoole](https://github.com/jdrumgoole)
+- [Rob Figueiredo](https://github.com/robfig)
+- [Wasmer](https://wasmer.io/)
+
+For publicly sponsoring our work at the highest tier.
@@ -39,7 +39,6 @@
 #include "libc/elf/def.h"
 #include "libc/macho.internal.h"
 #include "libc/nexgen32e/uart.internal.h"
-#include "libc/nexgen32e/vidya.internal.h"
 #include "libc/nt/pedef.internal.h"
 #include "libc/runtime/pc.internal.h"
 #include "libc/sysv/consts/prot.h"
@@ -51,7 +50,7 @@
 	.previous
 	.section .rodata,"a",@progbits
 	.align	__SIZEOF_POINTER__
-__ro:	.endobj	__ro,globl,hidden		# ←for gdb readibility
+__ro:	.endobj	__ro,globl,hidden		# ←for gdb readability
 	.previous
 	.section .data,"aw",@progbits
 	.align	__SIZEOF_POINTER__
@@ -60,7 +59,7 @@ __ro:	.endobj	__ro,globl,hidden		# ←for gdb readibility
 	.align	__SIZEOF_POINTER__
 	.previous
 	.section .rodata.str1.1,"a",@progbits
-cstr:	.endobj	cstr,globl,hidden		# ←for gdb readibility
+cstr:	.endobj	cstr,globl,hidden		# ←for gdb readability
 	.previous
 	.section .head,"ax",@progbits

@@ -126,6 +125,7 @@ ape_mz:	.asciz	"MZqFpD='\n"		# Mark 'Zibo' Joseph Zbikowski
 	.org	0x24			# MZ: bytes reserved for you
 	.ascii	"JT"			# MZ: OEM identifier
 	.short	0			# MZ: OEM information
+	.ascii	"' <<'@'\n"
 	.org	0x40-4			# MZ: bytes reserved for you
 #if SupportsWindows() || SupportsMetal()
 	.long	RVA(ape_pe)		# PE: the new technology
@@ -193,12 +193,12 @@ stub:	mov	$0x40,%dl		# *literally* dos
 	to a program as soon as its first sector is loaded. That gives
 	us control over user-facing latency, even though the next step
 	will generally be asking the BIOS to load more.
-	
+
 	The process is trivial enough that this entrypoint can support
 	handoffs from alternative program-loaders e.g. Grub and MS-DOS
 	so long as they either load our full program, or implement the
 	PC BIOS disk service API.
-	
+
 	Since so many different implementations of these APIs have been
 	built the last forty years these routines also canonicalize the
 	cpu and program state, as it is written in the System V ABI. */
@@ -236,8 +236,9 @@ pc:	cld
 #endif
 	ljmp	$0,$REAL(1f)
 1:	mov	%cx,%ds
-	mov	$IMAGE_BASE_REAL-0x0500,%cx	# clears bss
-	mov	$0x0500>>4,%ax			# struct mman
+	.set	mm,0x0500			# struct mman
+	mov	$IMAGE_BASE_REAL-mm,%cx		# clears bss
+	mov	$mm>>4,%ax
 	mov	%ax,%es
 	xor	%ax,%ax
 	xor	%di,%di
@@ -301,7 +302,21 @@ pc:	cld
 //	@since	IBM Personal Computer XT
 dsknfo:	push	%bx
 1:	push	%dx
-	mov	$0x08,%ah		# get disk params
+	mov	$0x16,%ah		# make sure there is disk in drive,
+	int	$0x13			# by querying change-line status
+	jnc	2f
+	xor	%ax,%ax			# if error or change line active,
+	int	$0x13			# do a reset...
+	jc	9f
+	mov	$0x0201,%ax		# ...then do a read, to confirm that
+	mov	$0x0001,%cx		# there is disk in drive
+	mov	$0,%dh			# (verify (%ah = 4) does not work
+	mov	$IMAGE_BASE_REAL>>4,%bx	# under QEMU, which always returns
+	mov	%bx,%es			# success)
+	xor	%bx,%bx
+	int	$0x13
+	jc	9f
+2:	mov	$0x08,%ah		# get disk params
 	int	$0x13
 	jc	9f
 	mov	%cl,%bh
@@ -314,7 +329,7 @@ dsknfo:	push	%bx
 	movpp	%es,%ds
 	xor	%si,%si
 	mov	%si,%es
-	mov	$0x1510,%si		# mman::pc_drive_base_table
+	mov	$mm+"struct mman::pc_drive_base_table",%si
 	xchg	%si,%di
 	movsw	#→ headunloadtime, headloadtime
 	movsw	#→ shutofftime, bytespersector
@@ -367,11 +382,11 @@ pcread:	push	%ax
 	add	$512>>4,%si
 	mov	%si,%es
 	inc	%al			# ++sector
-	cmp	0x151c,%al		# mman::pc_drive_last_sector
+	cmp	mm+"struct mman::pc_drive_last_sector",%al
 	jbe	2f
 	mov	$1,%al
 	inc	%dh			# ++head
-	cmp	0x1520,%dh		# mman::pc_drive_last_head
+	cmp	mm+"struct mman::pc_drive_last_head",%dh
 	jbe	2f
 	xor	%dh,%dh
 	inc	%cx			# ++cylinder
@@ -470,19 +485,19 @@ ape.mbrpad:
 ape_disk:
 	.stub	ape.diskid,quad
 	.org	0x1be,0x00
-	.macro	.partn	x
-	.stub	ape.part\x\().status,byte	# 0=absent / 0x80=present
-	.stub	ape.part\x\().first.head,byte	# in low 6 bits
-	.stub	ape.part\x\().first.cylinder,byte
-	.stub	ape.part\x\().first.sector,byte
-	.stub	ape.part\x\().filesystem,byte
-	.stub	ape.part\x\().last.head,byte
-	.stub	ape.part\x\().last.cylinder,byte
-	.stub	ape.part\x\().last.sector,byte
-	.stub	ape.part\x\().lba,long          # c₀*Cₙ + h₀*Hₙ + s₀*Sₙ
-	.stub	ape.part\x\().sector.count,long # sectors are 512 bytes
+	.macro	.partn	x:req sta h0 s0 c0 fs h9 s9 c9 lba0 nsec
+	.stub	ape.part\x\().status,byte,\sta	# 0=non-boot / 0x80=active
+	.stub	ape.part\x\().first.head,byte,\h0
+	.stub	ape.part\x\().first.sector,byte,\s0 # in low 6 bits
+	.stub	ape.part\x\().first.cylinder,byte,\c0
+	.stub	ape.part\x\().filesystem,byte,\fs
+	.stub	ape.part\x\().last.head,byte,\h9
+	.stub	ape.part\x\().last.sector,byte,\s9
+	.stub	ape.part\x\().last.cylinder,byte,\c9
+	.stub	ape.part\x\().lba,long,\lba0	# c₀*Cₙ + h₀*Hₙ + s₀*Sₙ
+	.stub	ape.part\x\().sector.count,long,\nsec # sectors are 512 bytes
 	.endm
-	.partn	1
+	.partn	1,0x80,0,1,0,0x7f,0xff,0xff,0xff,0,0xffffffff
 	.partn	2
 	.partn	3
 	.partn	4
@@ -534,7 +549,7 @@ ape_disk:
 	the bourne executable & linkable format */

 #if SupportsWindows() || SupportsMetal() || SupportsXnu()
-apesh:	.ascii	"'\n#'\"\n"			# sixth edition shebang
+apesh:	.ascii	"\n@\n#'\"\n"			# sixth edition shebang
 //	Until all operating systems can be updated to support APE,
 //	we have a beautiful, yet imperfect workaround, which is to
 //	modify the binary to follow the local system's convention.
@@ -551,14 +566,14 @@ apesh:	.ascii	"'\n#'\"\n"			# sixth edition shebang
 //	extract the loader into a temp folder, and use it to
 //	load the APE without modifying it.
 	.ascii	"[ x\"$1\" != x--assimilate ] && {\n"
-	.ascii	  "t=\"${TMPDIR:-/tmp}/ape\"\n"
+	.ascii	  "t=\"${TMPDIR:-${HOME:-.}}/.ape\"\n"
 	.ascii	  "[ -x \"$t\" ] || {\n"
 	.ascii	    "mkdir -p \"${t%/*}\" &&\n"
-	.ascii	    "dd if=\"$o\" of=\"$t.$$\" skip=\""
+	.ascii	    "dd if=\"$o\" of=\"$t.$$\" skip="
 	.shstub	      ape_loader_dd_skip,2
-	.ascii	      "\" count=\""
+	.ascii	      " count="
 	.shstub	      ape_loader_dd_count,2
-	.ascii	      "\" bs=64 2>/dev/null\n"
+	.ascii	      " bs=64 2>/dev/null\n"
 #if SupportsXnu()
 	.ascii	    "[ -d /Applications ] && "
 	.ascii	      "dd if=\"$t.$$\""
@@ -580,20 +595,10 @@ apesh:	.ascii	"'\n#'\"\n"			# sixth edition shebang
 //	We prefer this because it's a tiny constant one time cost.
 //	We simply printf a 64-byte header and call execve() again.
 #else
-//	The alternative behavior is to copy to $TMPDIR and edit.
-//	This imposes a variety of caveats of its own that should
-//	be considered by the user beforehand, such as whether or
-//	not /tmp is considered trustworthy on a given system, or
-//	if the administrator chose to mount it with noexec. It's
-//	up to the user to decide what's best in those situations
-//	and also note that argv[0] and getauxval(AT_EXECFN) will
-//	change as a result of this, and lastly note we don't try
-//	to cleanup the tmp copies for the sake of efficiency. It
-//	should also be noted that if $0 has directory components
-//	then permission clashes can happen between system users,
-//	since only root is able to set the sticky bit, which can
-//	be addressed simply by overriding the TMPDIR environment
-	.ascii	"t=\"${TMPDIR:-/tmp}/$0\"\n"
+//	The alternative behavior is to copy to $TMPDIR or $HOME or
+//	the current directory. We like TMPDIR because it's part of
+//	the IEEE POSIX standard whereas alternatives (XDG) aren't.
+	.ascii	"t=\"${TMPDIR:-${HOME:-.}}/$0\"\n"
 	.ascii	"[ x\"$1\" != x--assimilate ] || [ ! -e \"$t\" ] && {\n"
 	.ascii	  "[ x\"$1\" != x--assimilate ] && {\n"
 	.ascii	    "mkdir -p \"${t%/*}\" 2>/dev/null\n"
@@ -632,11 +637,11 @@ apesh:	.ascii	"'\n#'\"\n"			# sixth edition shebang
 	.ascii	  "dd if=\"$o\""
 	.ascii	    " of=\"$o\""
 	.ascii	    " bs=8"
-	.ascii	    " skip=\""
+	.ascii	    " skip="
 	.shstub	    ape_macho_dd_skip,2
-	.ascii	    "\" count=\""
+	.ascii	    " count="
 	.shstub	    ape_macho_dd_count,2
-	.ascii	    "\" conv=notrunc 2>/dev/null\n"
+	.ascii	    " conv=notrunc 2>/dev/null\n"
 #endif /* XNU */
 	.ascii	"[ x\"$1\" = x--assimilate ] && exit 0\n"
 #ifndef APE_NO_MODIFY_SELF
@@ -869,7 +874,7 @@ ape_macho:
 	.long	(520f-510f)/4			# count
 510:	.quad	0				# rax
 	.quad	IMAGE_BASE_VIRTUAL		# rbx
-	.quad	XNU				# rcx
+	.quad	_HOSTXNU			# rcx
 	.quad	0				# rdx
 	.quad	0				# rdi
 	.quad	0				# rsi
@@ -920,7 +925,7 @@ ape_macho:
 │ αcτµαlly pδrταblε εxεcµταblε § the new technology                        ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│─╝
 	The Portable Executable Format
-	
+
 	@see https://docs.microsoft.com/en-us/windows/desktop/debug/pe-format
 	@see "The Portable Executable File Format from Top to Bottom",
 	     Randy Kath, Microsoft Developer Network Technology Group. */
@@ -1132,12 +1137,17 @@ sconf:	.short	1843200/*hz*/ / 16/*wut*/ / 9600/*baud*/
 	.endobj	sconf,global,hidden

 //	Global Descriptor Table
-//
-//	@note address portion only concern legacy modes
 	.align	8
-gdt:	.short	2f-1f		# table byte length
-	.long	REAL(1f),0	# table address
-	.zero	2
+_gdtrphy:
+	.short	2f-1f-1		# table byte length
+	.long	REAL(1f)	# table address (physical space)
+	.endobj	_gdtrphy,global,hidden
+_gdtr:
+	.short	2f-1f-1		# table byte length
+	.quad	1f		# table address (final virtual space)
+	.endobj	_gdtr,global,hidden
+	.align	8
+_gdt:
 1:
 //	          ┌G:granularity (1 → limit *= 0x1000)
 //	          │┌D/B:default operation size (0 = 16|64bit, 1 = 32-bit)
@@ -1167,7 +1177,9 @@ gdt:	.short	2f-1f		# table byte length
 .quad	0b0000000011001111100100100000000000000000000000001111111111111111 #32
 .quad	0b0000000010101111100110110000000000000000000000001111111111111111 #40
 .quad	0b0000000010101111100100110000000000000000000000001111111111111111 #48
-2:	.endobj	gdt,global,hidden
+.tssdescstub _tss							#56,64
+2:
+	.endobj	_gdt,global,hidden

 /*─────────────────────────────────────────────────────────────────────────────╗
 │ αcτµαlly pδrταblε εxεcµταblε § real mode                                     │
@@ -1273,8 +1285,8 @@ lcheck:	pushf				# check for i8086 / i8088 / i80186
 	jl	10f
 	mov	%edi,%eax
 	cpuid
-	mov	$1<<29,%edi		# need nexgen32e long mode support
-	and	%edi,%edx
+	mov	$1<<29|1<<20,%edi	# need nexgen32e long mode support
+	and	%edi,%edx		# & nx support
 	cmp	%edi,%edx
 	jne	10f
 	xor	%ax,%ax
@@ -1284,29 +1296,39 @@ lcheck:	pushf				# check for i8086 / i8088 / i80186
 	.endfn	lcheck

 //	Gets memory map from BIOS.
-e820:	mov	$0x0510>>4,%di		# mman::e820
-	mov	%di,%es
-	xor	%edi,%edi		# es:di is destination buffer
-	xor	%ebx,%ebx		# ebx is an api state tracker
+e820:	xor	%ebx,%ebx		# %ebx is an api state tracker
+	mov	%bx,%es
+	mov	$mm+"struct mman::e820",%di # es:di is destination buffer
 1:	mov	$0xE820,%eax		# magic
 	mov	$8+8+4+4,%ecx		# sizeof(struct SmapEntry)
 	mov	$0x534d4150,%edx	# magic number
+	movl	$1,8+8+4/*SmapEntry::acpi3*/(%di) # prefill ACPI attributes;
+					# apparently some buggy BIOSes say
+					# that they return this field, yet
+					# do not fill it correctly
 	int	$0x15			# ax,bx,cx,dx,di → ax,bx,cx
 	jc	9f			# cf = unsupported or abuse
 	cmp	%edx,%eax		# more magic means success
 	jne	9f
 	test	%cx,%cx			# discard empty results
 	jz	5f
+	mov	8/*LODWORD(SmapEntry::size)*/(%di),%eax
+	or	8+4/*HIDWORD(SmapEntry::size)*/(%di),%eax
+	jz	5f
 	cmp	$8+8+4+1,%cx		# discard if ignore flag
 	jb	4f
-	testb	$1/*ignore*/,8+8+4/*SmapEntry::__acpi3*/(%di)
-	jnz	5f
+	testb	$1/*don't ignore*/,8+8+4/*SmapEntry::acpi3*/(%di)
+	jz	5f
 4:	add	$8+8+4+4,%di		# keep entry
 5:	test	%ebx,%ebx		# last entry?
 	jz	8f
-	cmp	$0x1000,%di
+	cmp	$mm+"struct mman::e820_end"-(8+8+4+4),%di
 	jb	1b
-8:	ret
+8:	xor	%ax,%ax			# add a blank sentinel entry
+	mov	$(8+8)/2,%cx
+	cld
+	rep stosw
+	ret
 9:	mov	$REAL(str.e820),%di
 	call	rldie
 	.endfn	e820
@@ -1376,9 +1398,16 @@ a20:	cli

 //	Initializes long mode paging.
 pinit:	push	%ds
+	push	%es
 #define	SEG 0x79000
 	mov	$SEG>>4,%ax
 	mov	%ax,%ds
+	mov	%ax,%es
+	xor	%di,%di
+	xor	%ax,%ax
+	mov	$(0x7f000-SEG)/2,%cx
+	cld
+	rep stosw
 	movl	$0x7d000+PAGE_V+PAGE_RW,0x7e000-SEG	# PDPT←PML4T (+)
 	movl	$0x7c000+PAGE_V+PAGE_RW,0x7e800-SEG	# PDPT←PML4T (-)
 	movl	$0x7b000+PAGE_V+PAGE_RW,0x7d000-SEG	# PDT←PDPT   (+)
@@ -1386,14 +1415,15 @@ pinit:	push	%ds
 	movl	$0x79000+PAGE_V+PAGE_RW,0x7b000-SEG	# PD←PDT     (+)
 	movl	$0x79000+PAGE_V+PAGE_RW,0x7a000-SEG	# PD←PDT     (-)
 	mov	$512,%cx				# PD±2MB
-	mov	$PAGE_V+PAGE_RW,%eax
-	xor	%si,%si
-0:	mov	%eax,(%si)
+	mov	$PAGE_V+PAGE_RSRV+PAGE_RW,%eax
+	xor	%di,%di
+0:	stosl
 	add	$0x1000,%eax
-	add	$8,%si
+	scasl						# di += 4
 	loop	0b
 	mov	$0x7e000,%eax				# PML4T←CR3
 	mov	%eax,%cr3
+	pop	%es
 	pop	%ds
 	ret
 	.endfn	pinit
@@ -1402,15 +1432,15 @@ pinit:	push	%ds
 //
 //	@see	Intel Manual V3A §4.1.2
 golong:	cli
-	lidt	0x1522					# mman::bad_idt
+	lidt	mm+"struct mman::bad_idt"
 	mov	%cr4,%eax
 	or	$CR4_PAE|CR4_PGE|CR4_OSFXSR,%eax
 	mov	%eax,%cr4
 	movl	$EFER,%ecx
 	rdmsr
-	or	$EFER_LME|EFER_SCE,%eax
+	or	$EFER_LME|EFER_SCE|EFER_NXE,%eax
 	wrmsr
-	lgdt	REAL(gdt)
+	lgdt	REAL(_gdtrphy)
 	mov	%cr0,%eax
 	or	$CR0_PE|CR0_PG|CR0_MP,%eax
 	and	$~CR0_EM,%eax
@@ -1420,14 +1450,16 @@ golong:	cli

 //	Long mode is long.
 	.code64
-long:	push	$GDT_LONG_DATA
-	pop	%rax
+long:	xor	%eax,%eax
+	mov	$GDT_LONG_DATA,%al
 	mov	%eax,%ds
 	mov	%eax,%ss
 	mov	%eax,%es
 	mov	%eax,%fs
 	mov	%eax,%gs
 	mov	$0x80000,%esp
+	mov	$GDT_LONG_TSS,%al
+	ltr	%ax
 	xor	%r12d,%r12d
 	xor	%r13d,%r13d
 	xor	%r14d,%r14d
@@ -1435,12 +1467,14 @@ long:	push	$GDT_LONG_DATA
 	xor	%ebx,%ebx
 	xor	%ebp,%ebp
 	push	%rbp
-	mov	$0x0500,%rdi			# mman
+	mov	$mm,%rdi
 	mov	%cr3,%rsi
 	mov	$IMAGE_BASE_REAL,%edx
 	call	__map_phdrs
 	push	$0x037f
 	fldcw	(%rsp)
+	lgdt	_gdtr					# reload GDTR for
+							# virtual memory space
 	movabs	$kernel,%rax
 	jmp	*%rax
 	.endfn	long
@@ -1521,7 +1555,7 @@ kernel:	movabs	$ape_stack_vaddr,%rsp
 	.byte	0x0f,0x1f,0207			# nop rdi binbase
 	.long	(IMAGE_BASE_VIRTUAL-IMAGE_BASE_REAL)/512
 #endif
-	push	$METAL				# sets __hostos in crt.S
+	push	$_HOSTMETAL			# sets __hostos in crt.S
 	pop	%rcx
 	push	$0
 	mov	%rsp,%rbp
@@ -180,6 +180,7 @@
 #include "libc/elf/def.h"
 #include "libc/elf/pf2prot.internal.h"
 #include "libc/nt/pedef.internal.h"
+#include "libc/thread/tls.h"
 #include "libc/zip.h"

 ENTRY(_start)
@@ -279,6 +280,7 @@ SECTIONS {
    KEEP(*(.keep.text))
    *(.text .stub .text.*)
    KEEP(*(SORT_BY_NAME(.sort.text.*)))
+    *(.subrs)

    KEEP(*(.ape.pad.test));
    *(.test.unlikely)
@@ -380,6 +382,7 @@ SECTIONS {
    PROVIDE_HIDDEN(edata = .);
    KEEP(*(SORT_BY_NAME(.zip.*)))
    HIDDEN(_ezip = .);
+    . = ALIGN(PAGESIZE);
  } :Ram

  .tdata . : {
@@ -388,8 +391,7 @@ SECTIONS {
    *(SORT_BY_ALIGNMENT(.tdata.*))
    _tdata_end = .;
    . = ALIGN(PAGESIZE);
-  } :Tls
-  . = ALIGN(PAGESIZE);
+  } :Tls :Ram

 /*END:   file content that's loaded by o/s */
 /*BEGIN: bss memory void */
@@ -398,6 +400,8 @@ SECTIONS {
    _tbss_start = .;
    *(SORT_BY_ALIGNMENT(.tbss))
    *(SORT_BY_ALIGNMENT(.tbss.*))
+    . = ALIGN(TLS_ALIGNMENT);
+    /* the %fs register is based on this location */
    _tbss_end = .;
  } :Tls

@@ -423,7 +427,7 @@ SECTIONS {

    KEEP(*(.bssepilogue))
 /*END: NT FORK COPYING */
-    . = ALIGN(FRAMESIZE); /* for brk()/sbrk() allocation */
+    . = ALIGN(PAGESIZE);
    HIDDEN(_end = .);
    PROVIDE_HIDDEN(end = .);
  } :Bss
@@ -454,6 +458,7 @@ SECTIONS {
  .debug_line        0 : { *(.debug_line .debug_line.* .debug_line_end ) }
  .debug_frame       0 : { *(.debug_frame) }
  .debug_str         0 : { *(.debug_str) }
+  .debug_line_str    0 : { *(.debug_line_str) }
  .debug_loc         0 : { *(.debug_loc) }
  .debug_macinfo     0 : { *(.debug_macinfo) }
  .debug_weaknames   0 : { *(.debug_weaknames) }
@@ -462,6 +467,7 @@ SECTIONS {
  .debug_varnames    0 : { *(.debug_varnames) }
  .debug_pubtypes    0 : { *(.debug_pubtypes) }
  .debug_ranges      0 : { *(.debug_ranges) }
+  .debug_rnglists    0 : { *(.debug_rnglists) }
  .debug_macro       0 : { *(.debug_macro) }
  .debug_addr        0 : { *(.debug_addr) }
  .gnu.attributes    0 : { KEEP(*(.gnu.attributes)) }
@@ -482,8 +488,11 @@ PFSTUB4(ape_elf_phnum, (ape_phdrs_end - ape_phdrs) / 56);
 PFSTUB4(ape_elf_shnum, 0);
 PFSTUB4(ape_elf_shstrndx, 0);

-HIDDEN(_tdata_size = _tdata_end - _tdata_start);
 HIDDEN(_tls_size = _tbss_end - _tdata_start);
+HIDDEN(_tdata_size = _tdata_end - _tdata_start);
+HIDDEN(_tbss_size = _tbss_end - _tbss_start);
+HIDDEN(_tbss_offset = _tbss_start - _tdata_start);
+HIDDEN(_tls_content = (_tdata_end - _tdata_start) + (_tbss_end - _tbss_start));

 HIDDEN(__privileged_addr = ROUNDDOWN(__privileged_start, PAGESIZE));
 HIDDEN(__privileged_size = (ROUNDUP(__privileged_end, PAGESIZE) -
@@ -553,39 +562,14 @@ SHSTUB2(ape_loader_dd_count,
            ? ROUNDUP(ape_loader_end - ape_loader, PAGESIZE) / 64
            : 0);

-#if SupportsXnu()
-SHSTUB2(ape_macho_dd_skip, RVA(ape_macho) / 8);
-SHSTUB2(ape_macho_dd_count, (ape_macho_end - ape_macho) / 8);
-#endif
-
-#if SupportsWindows() || SupportsMetal()
-#define LINK_WINDOWS (SupportsWindows() && !DEFINED(EfiMain))
-PFSTUB4(ape_pe_offset, ape_pe - ape_mz);
-HIDDEN(ape_pe_optsz = ape_pe_sections - (ape_pe + 24));
-HIDDEN(ape_pe_shnum = (ape_pe_sections_end - ape_pe_sections) / 40);
-HIDDEN(ape_pe_base = IMAGE_BASE_VIRTUAL);
-HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_iat) : 0);
-HIDDEN(ape_idata_iatsize = LINK_WINDOWS ? ape_idata_iatend - ape_idata_iat : 0);
-HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_idt) : 0);
-HIDDEN(ape_idata_idtsize = LINK_WINDOWS ? ape_idata_idtend - ape_idata_idt : 0);
-HIDDEN(v_ntversion = LINK_WINDOWS ? 6 : 1);
-HIDDEN(v_ntdllchar = LINK_WINDOWS ? 288 : 0);
-HIDDEN(v_ntsubversion = LINK_WINDOWS ? 6 : 5);
-HIDDEN(v_ntsubsystem = (LINK_WINDOWS
-                        ? (DEFINED(GetMessage)
-                           ? kNtImageSubsystemWindowsGui
-                           : kNtImageSubsystemWindowsCui)
-                        : kNtImageSubsystemEfiApplication));
-HIDDEN(ape_pe_entry = LINK_WINDOWS ? WinMain : EfiMain);
-#endif
-
 #if SupportsMetal()
 HIDDEN(v_ape_realsectors =
           MIN(0x70000 - IMAGE_BASE_REAL,
-               ROUNDUP(RVA(_edata), 4096)) / 512);
+               ROUNDUP(RVA(_edata), 512)) / 512);
 HIDDEN(v_ape_realpages = v_ape_realsectors / (4096 / 512));
 HIDDEN(v_ape_highsectors =
           (ROUNDUP(RVA(_edata), 512) / 512) - v_ape_realsectors);
+TSSDESCSTUB2(_tss, _tss, _tss_end ? _tss_end - _tss - 1 : 0);
 #endif

 /* ZIP End of Central Directory header */
@@ -685,6 +669,32 @@ CHURN(WinMain);
 #endif /* SupportsWindows() */
 #endif /* SupportsXnu() */

+#if SupportsWindows() || SupportsMetal()
+#define LINK_WINDOWS (SupportsWindows() && !DEFINED(EfiMain))
+PFSTUB4(ape_pe_offset, ape_pe - ape_mz);
+HIDDEN(ape_pe_optsz = ape_pe_sections - (ape_pe + 24));
+HIDDEN(ape_pe_shnum = (ape_pe_sections_end - ape_pe_sections) / 40);
+HIDDEN(ape_pe_base = IMAGE_BASE_VIRTUAL);
+HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_iat) : 0);
+HIDDEN(ape_idata_iatsize = LINK_WINDOWS ? ape_idata_iatend - ape_idata_iat : 0);
+HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_idt) : 0);
+HIDDEN(ape_idata_idtsize = LINK_WINDOWS ? ape_idata_idtend - ape_idata_idt : 0);
+HIDDEN(v_ntversion = LINK_WINDOWS ? 6 : 1);
+HIDDEN(v_ntdllchar = LINK_WINDOWS ? 288 : 0);
+HIDDEN(v_ntsubversion = LINK_WINDOWS ? 6 : 5);
+HIDDEN(v_ntsubsystem = (LINK_WINDOWS
+                        ? (DEFINED(GetMessage)
+                           ? kNtImageSubsystemWindowsGui
+                           : kNtImageSubsystemWindowsCui)
+                        : kNtImageSubsystemEfiApplication));
+HIDDEN(ape_pe_entry = LINK_WINDOWS ? WinMain : EfiMain);
+#endif
+
+#if SupportsXnu()
+SHSTUB2(ape_macho_dd_skip, RVA(ape_macho) / 8);
+SHSTUB2(ape_macho_dd_count, (ape_macho_end - ape_macho) / 8);
+#endif
+
 ASSERT(DEFINED(ape_mz) ? ape_mz == IMAGE_BASE_VIRTUAL : 1, "linker panic");
 ASSERT((DEFINED(__init_bss_end) ? __init_bss_end : 0) % __SIZEOF_POINTER__ == 0,
       "__init_bss misalign");
@@ -704,8 +714,11 @@ ASSERT(!DEFINED(_start16) || REAL(_end) < 65536,
 ASSERT(IS2POW(ape_stack_memsz),
       "ape_stack_memsz must be a two power");

-ASSERT(!(ape_stack_vaddr & (ape_stack_memsz - 1)),
-       "ape_stack_vaddr must have ape_stack_memsz alignment; try using STATIC_STACK_ADDR(0x700000000000 - ape_stack_memsz);");
+ASSERT(ape_stack_vaddr % ape_stack_memsz == 0,
+       "ape_stack_vaddr must have ape_stack_memsz alignment; try using STATIC_STACK_ADDR(0x700000040000 - ape_stack_memsz);");
+
+ASSERT(ALIGNOF(.tdata) <= TLS_ALIGNMENT && ALIGNOF(.tbss) <= TLS_ALIGNMENT,
+       "_Thread_local _Alignof can't exceed TLS_ALIGNMENT");

 /* Let's not be like Knight Capital. */
 /* NOCROSSREFS_TO(.test .text) */
@@ -15,38 +15,38 @@

 PKGS += APE

-APE =	o/$(MODE)/ape/ape.o				\
+APE =	o/$(MODE)/ape/ape.o			\
 	o/$(MODE)/ape/ape.lds

-APE_NO_MODIFY_SELF =					\
-	o/$(MODE)/ape/ape.lds				\
+APE_NO_MODIFY_SELF =				\
+	o/$(MODE)/ape/ape.lds			\
 	o/$(MODE)/ape/ape-no-modify-self.o

-APE_COPY_SELF =						\
-	o/$(MODE)/ape/ape.lds				\
+APE_COPY_SELF =					\
+	o/$(MODE)/ape/ape.lds			\
 	o/$(MODE)/ape/ape-copy-self.o

-APELINK =						\
-	$(COMPILE)					\
-	-ALINK.ape					\
-	$(LINK)						\
-	$(LINKARGS)					\
+APELINK =					\
+	$(COMPILE)				\
+	-ALINK.ape				\
+	$(LINK)					\
+	$(LINKARGS)				\
 	$(OUTPUT_OPTION)

-APE_LOADER_FLAGS =					\
-	-DNDEBUG					\
-	-iquote.					\
-	-Wall						\
-	-Wextra						\
-	-fpie						\
-	-Os						\
-	-ffreestanding					\
-	-mgeneral-regs-only				\
-	-mno-red-zone					\
-	-fno-ident					\
-	-fno-gnu-unique					\
-	-c						\
-	 $(OUTPUT_OPTION)				\
+APE_LOADER_FLAGS =				\
+	-DNDEBUG				\
+	-iquote.				\
+	-Wall					\
+	-Wextra					\
+	-fpie					\
+	-Os					\
+	-ffreestanding				\
+	-mgeneral-regs-only			\
+	-mno-red-zone				\
+	-fno-ident				\
+	-fno-gnu-unique				\
+	-c					\
+	 $(OUTPUT_OPTION)			\
 	$<

 APE_FILES := $(wildcard ape/*.*)
@@ -58,42 +58,102 @@ APE_SRCS = $(APE_SRCS_C) $(APE_SRCS_S)
 APE_OBJS = $(APE_SRCS_S:%.S=o/$(MODE)/%.o)
 APE_CHECKS = $(APE_HDRS:%=o/%.ok)

-o/$(MODE)/ape/ape.lds:					\
-		ape/ape.lds				\
-		ape/macros.internal.h			\
-		libc/dce.h				\
+o/$(MODE)/ape/ape.lds:				\
+		ape/ape.lds			\
+		ape/macros.internal.h		\
+		ape/relocations.h		\
+		libc/intrin/bits.h		\
+		libc/thread/tls.h		\
+		libc/calls/struct/timespec.h	\
+		libc/thread/thread.h		\
+		libc/dce.h			\
+		libc/elf/def.h			\
+		libc/elf/pf2prot.internal.h	\
+		libc/macros.internal.h		\
+		libc/nt/pedef.internal.h	\
+		libc/str/str.h			\
 		libc/zip.h

-o/ape/idata.inc:					\
-		ape/idata.internal.h			\
+o/$(MODE)/ape/public/ape.lds: OVERRIDE_CPPFLAGS += -UCOSMO
+o/$(MODE)/ape/public/ape.lds:			\
+		ape/public/ape.lds		\
+		ape/ape.lds			\
+		ape/macros.internal.h		\
+		ape/relocations.h		\
+		libc/intrin/bits.h		\
+		libc/thread/tls.h		\
+		libc/calls/struct/timespec.h	\
+		libc/thread/thread.h		\
+		libc/dce.h			\
+		libc/elf/def.h			\
+		libc/elf/pf2prot.internal.h	\
+		libc/macros.internal.h		\
+		libc/nt/pedef.internal.h	\
+		libc/str/str.h			\
+		libc/zip.h
+
+o/ape/idata.inc:				\
+		ape/idata.internal.h		\
 		ape/relocations.h

-o/$(MODE)/ape/ape-no-modify-self.o:			\
-		ape/ape.S				\
+o/$(MODE)/ape/ape-no-modify-self.o:		\
+		ape/ape.S			\
+		ape/macros.internal.h		\
+		ape/notice.inc			\
+		ape/relocations.h		\
+		libc/dce.h			\
+		libc/elf/def.h			\
+		libc/intrin/asancodes.h		\
+		libc/macho.internal.h		\
+		libc/macros.internal.h		\
+		libc/nexgen32e/uart.internal.h	\
+		libc/nexgen32e/vidya.internal.h	\
+		libc/nt/pedef.internal.h	\
+		libc/runtime/e820.internal.h	\
+		libc/runtime/mman.internal.h	\
+		libc/runtime/pc.internal.h	\
+		libc/runtime/symbolic.h		\
+		libc/sysv/consts/prot.h		\
 		o/$(MODE)/ape/ape.elf
-	@$(COMPILE)					\
-		-AOBJECTIFY.S				\
-		$(OBJECTIFY.S)				\
-		$(OUTPUT_OPTION)			\
-		-DAPE_NO_MODIFY_SELF			\
+	@$(COMPILE)				\
+		-AOBJECTIFY.S			\
+		$(OBJECTIFY.S)			\
+		$(OUTPUT_OPTION)		\
+		-DAPE_NO_MODIFY_SELF		\
 		-DAPE_LOADER='"o/$(MODE)/ape/ape.elf"' $<

-o/$(MODE)/ape/ape-copy-self.o:				\
-		ape/ape.S
-	@$(COMPILE)					\
-		-AOBJECTIFY.S				\
-		$(OBJECTIFY.S)				\
-		$(OUTPUT_OPTION)			\
+o/$(MODE)/ape/ape-copy-self.o:			\
+		ape/ape.S			\
+		ape/macros.internal.h		\
+		ape/notice.inc			\
+		ape/relocations.h		\
+		libc/dce.h			\
+		libc/elf/def.h			\
+		libc/intrin/asancodes.h		\
+		libc/macho.internal.h		\
+		libc/macros.internal.h		\
+		libc/nexgen32e/uart.internal.h	\
+		libc/nexgen32e/vidya.internal.h	\
+		libc/nt/pedef.internal.h	\
+		libc/runtime/e820.internal.h	\
+		libc/runtime/mman.internal.h	\
+		libc/runtime/pc.internal.h	\
+		libc/runtime/symbolic.h		\
+		libc/sysv/consts/prot.h
+	@$(COMPILE)				\
+		-AOBJECTIFY.S			\
+		$(OBJECTIFY.S)			\
+		$(OUTPUT_OPTION)		\
 		-DAPE_NO_MODIFY_SELF $<

-o/$(MODE)/ape/loader.o: ape/loader.c
+o/$(MODE)/ape/loader.o: ape/loader.c ape/loader.h
 	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b01111001 -g $(APE_LOADER_FLAGS)
 o/$(MODE)/ape/loader-gcc.asm: ape/loader.c
 	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b01111001 -S -g0 $(APE_LOADER_FLAGS)
 o/$(MODE)/ape/loader-clang.asm: ape/loader.c
 	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=0b01111001 -S -g0 $(APE_LOADER_FLAGS)

-o/$(MODE)/ape/loader-xnu.o: ape/loader.c
+o/$(MODE)/ape/loader-xnu.o: ape/loader.c ape/loader.h
 	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b00001000 -g $(APE_LOADER_FLAGS)
 o/$(MODE)/ape/loader-xnu-gcc.asm: ape/loader.c
 	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b00001000 -S -g0 $(APE_LOADER_FLAGS)
@@ -103,23 +163,24 @@ o/$(MODE)/ape/loader-xnu-clang.asm: ape/loader.c
 o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
 o/$(MODE)/ape/ape.macho: o/$(MODE)/ape/ape.macho.dbg

-o/$(MODE)/ape/ape.elf.dbg:				\
-		o/$(MODE)/ape/loader.o			\
-		o/$(MODE)/ape/loader-elf.o		\
+o/$(MODE)/ape/ape.elf.dbg:			\
+		o/$(MODE)/ape/loader.o		\
+		o/$(MODE)/ape/loader-elf.o	\
 		ape/loader.lds
 	@$(ELFLINK) -z max-page-size=0x10

-o/$(MODE)/ape/ape.macho.dbg:				\
-		o/$(MODE)/ape/loader-xnu.o		\
-		o/$(MODE)/ape/loader-macho.o		\
+o/$(MODE)/ape/ape.macho.dbg:			\
+		o/$(MODE)/ape/loader-xnu.o	\
+		o/$(MODE)/ape/loader-macho.o	\
 		ape/loader-macho.lds
 	@$(ELFLINK) -z max-page-size=0x10

 .PHONY: o/$(MODE)/ape
-o/$(MODE)/ape:	$(APE_CHECKS)				\
-		o/$(MODE)/ape/ape.o			\
-		o/$(MODE)/ape/ape.lds			\
-		o/$(MODE)/ape/ape.elf			\
-		o/$(MODE)/ape/ape.macho			\
-		o/$(MODE)/ape/ape-copy-self.o		\
+o/$(MODE)/ape:	$(APE_CHECKS)			\
+		o/$(MODE)/ape/ape.o		\
+		o/$(MODE)/ape/ape.lds		\
+		o/$(MODE)/ape/public/ape.lds	\
+		o/$(MODE)/ape/ape.elf		\
+		o/$(MODE)/ape/ape.macho		\
+		o/$(MODE)/ape/ape-copy-self.o	\
 		o/$(MODE)/ape/ape-no-modify-self.o
@@ -1,63 +1,126 @@
 #!/bin/sh

-if ! [ x"$(uname -s)" = xLinux ]; then
-  echo this script is intended for linux binfmt_misc >&2
-  echo freebsd/netbsd/openbsd users can use release binary >&2
-  exit 1
+if [ $UID -eq 0 ]; then
+  SUDO=
+else
+  SUDO=sudo
 fi

+echo "Actually Portable Executable (APE) Installer" >&2
+echo "Author:  Justine Tunney <[email protected]>"  >&2
+
+################################################################################
+# INSTALL APE LOADER SYSTEMWIDE
+
 if [ -f o/depend ]; then
  # mkdeps.com build was successfully run so assume we can build
  echo >&2
-  echo running: make -j8 o//ape/ape.elf >&2
-  make -j8 o//ape/ape.elf || exit
-  echo done >&2
-else
-  # no evidence we can build, use prebuilt one
+  echo "recompiling ape loader" >&2
+  echo "running: make -j8 o//ape" >&2
+  make -j8 o//ape || exit
+  echo "done" >&2
+elif [ -d build/bootstrap ]; then
+  # if make isn't being used then it's unlikely the user changed the sources
+  # in that case the prebuilt binaries should be completely up-to-date
+  echo "using prebuilt ape loader from cosmo repo" >&2
  mkdir -p o//ape || exit
-  cp -af build/bootstrap/ape.elf o//ape/ape.elf
+  cp -af build/bootstrap/ape.elf o//ape/ape.elf || exit
+  cp -af build/bootstrap/ape.macho o//ape/ape.macho || exit
+else
+  echo "no cosmopolitan libc repository here" >&2
+  echo "fetching ape loader from justine.lol"  >&2
+  mkdir -p o//ape || exit
+  if command -v wget >/dev/null 2>&1; then
+    wget -qO o//ape/ape.elf https://justine.lol/ape.elf || exit
+    wget -qO o//ape/ape.macho https://justine.lol/ape.macho || exit
+  else
+    curl -Rso o//ape/ape.elf https://justine.lol/ape.elf || exit
+    curl -Rso o//ape/ape.macho https://justine.lol/ape.macho || exit
+  fi
+  chmod +x o//ape/ape.elf || exit
+  chmod +x o//ape/ape.macho || exit
 fi

-echo >&2
-echo installing o//ape/ape.elf to /usr/bin/ape >&2
-echo sudo mv -f o//ape/ape.elf /usr/bin/ape >&2
-sudo mv -f o//ape/ape.elf /usr/bin/ape || exit
-echo done >&2
-
-if [ -e /proc/sys/fs/binfmt_misc/APE ]; then
-  echo >&2
-  echo it looks like APE is already registered with binfmt_misc >&2
-  echo please check that it is mapped to ape not /bin/sh >&2
-  echo cat /proc/sys/fs/binfmt_misc/APE >&2
-  cat /proc/sys/fs/binfmt_misc/APE >&2
-  # TODO: we need better uninstall recommendations
-  #       the following works fine for justine
-  #       but might remove unrelated software?
-  # sudo sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/status'
-  exit
+if [ "$(uname -s)" = "Darwin" ]; then
+  if ! [ /usr/bin/ape -nt o//ape/ape.macho ]; then
+    echo >&2
+    echo "installing o//ape/ape.elf to /usr/bin/ape" >&2
+    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
+    $SUDO cp -f o//ape/ape.macho /usr/bin/ape || exit
+    echo "done" >&2
+  fi
+else
+  if ! [ /usr/bin/ape -nt o//ape/ape.elf ]; then
+    echo >&2
+    echo "installing o//ape/ape.elf to /usr/bin/ape" >&2
+    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
+    $SUDO cp -f o//ape/ape.elf /usr/bin/ape || exit
+    echo "done" >&2
+  fi
 fi

-if ! [ -e /proc/sys/fs/binfmt_misc ]; then
+################################################################################
+# REGISTER APE LOADER WITH BINFMT_MISC TOO (LINUX-ONLY)
+
+if [ x"$(uname -s)" = xLinux ]; then
+
+  if [ -e /proc/sys/fs/binfmt_misc/APE ]; then
+    echo >&2
+    echo it looks like APE is already registered with binfmt_misc >&2
+    echo To reinstall please run ape/apeuninstall.sh first >&2
+    echo please check that it is mapped to ape not /bin/sh >&2
+    echo cat /proc/sys/fs/binfmt_misc/APE >&2
+    cat /proc/sys/fs/binfmt_misc/APE >&2
+    exit
+  fi
+
+  if ! [ -e /proc/sys/fs/binfmt_misc ]; then
+    echo >&2
+    echo loading binfmt_misc into your kernel >&2
+    echo you may need to edit configs to persist across reboot >&2
+    echo $SUDO modprobe binfmt_misc >&2
+    $SUDO modprobe binfmt_misc || exit
+    echo done >&2
+  fi
+
+  if ! [ -e /proc/sys/fs/binfmt_misc/register ]; then
+    echo >&2
+    echo mounting binfmt_misc into your kernel >&2
+    echo you may need to edit configs to persist across reboot >&2
+    echo $SUDO mount -t binfmt_misc none /proc/sys/fs/binfmt_misc >&2
+    $SUDO mount -t binfmt_misc none /proc/sys/fs/binfmt_misc || exit
+    echo done >&2
+  fi
+
  echo >&2
-  echo loading binfmt_misc into your kernel >&2
+  echo registering APE with binfmt_misc >&2
  echo you may need to edit configs to persist across reboot >&2
-  echo sudo modprobe binfmt_misc >&2
-  sudo modprobe binfmt_misc || exit
+  echo '$SUDO sh -c "echo '"'"':APE:M::MZqFpD::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
+  $SUDO sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
  echo done >&2
+
+  if [ x"$(cat /proc/sys/fs/binfmt_misc/status)" = xdisabled ]; then
+    echo >&2
+    echo enabling binfmt_misc >&2
+    echo you may need to edit configs to persist across reboot >&2
+    echo $SUDO sh -c 'echo 1 >/proc/sys/fs/binfmt_misc/status' >&2
+    $SUDO sh -c 'echo 1 >/proc/sys/fs/binfmt_misc/status' || exit
+    echo done >&2
+  fi
+
 fi

-if ! [ -e /proc/sys/fs/binfmt_misc/register ]; then
-  echo >&2
-  echo mounting binfmt_misc into your kernel >&2
-  echo you may need to edit configs to persist across reboot >&2
-  echo sudo mount -t binfmt_misc none /proc/sys/fs/binfmt_misc >&2
-  sudo mount -t binfmt_misc none /proc/sys/fs/binfmt_misc || exit
-  echo done >&2
-fi
+################################################################################

-echo >&2
-echo registering APE with binfmt_misc >&2
-echo you may need to edit configs to persist across reboot >&2
-echo 'sudo sh -c "echo '"'"':APE:M::MZqFpD::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
-sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
-echo done >&2
+{
+  echo
+  echo "------------------------------------------------------------------"
+  echo
+  echo "APE INSTALL COMPLETE"
+  echo
+  echo "If you decide to uninstall APE later on"
+  echo "you may do so using ape/apeuninstall.sh"
+  echo
+  echo "Enjoy your APE loader (>'.')>"
+  echo
+} >&2
@@ -0,0 +1,24 @@
+#!/bin/sh
+
+if [ "$UID" = "0" ]; then
+  SUDO=
+else
+  SUDO=sudo
+fi
+
+{
+  echo
+  echo "APE Uninstaller intends to run"
+  echo
+  echo "    $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE'"
+  echo "    $SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape /tmp/.ape"
+  echo
+  echo "You may then use ape/apeinstall.sh to reinstall it"
+  echo
+} >&2
+
+set -ex
+if [ -f /proc/sys/fs/binfmt_misc/APE ]; then
+  $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE' || exit
+fi
+$SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape o/tmp/ape /tmp/.ape /tmp/ape || exit
@@ -32,23 +32,23 @@
 //	@see	ape/ape.lds
 //	@see	winimp
 .macro	.imp	dll:req fn:req actual:req hint
-	.dll	\dll
-	.section .piro.data.sort.iat.2.\dll\().2.\actual,"aw",@progbits
+	.dll	"\dll"
+	.section ".piro.data.sort.iat.2.\dll\().2.\actual","aw",@progbits
 	.type	\fn,@object
 	.align	__SIZEOF_POINTER__
-\fn:	.quad	RVA((\dll\().\actual))
+\fn:	.quad	RVA(("\dll\().\actual"))
 	.size	\fn,.-\fn
 	.globl	\fn
 	.hidden	\fn
 	.previous
-	.section .idata.ro.ilt.\dll\().2.\actual,"a",@progbits
-.Lidata.ilt.\dll\().\actual:
-	.quad	RVA((\dll\().\actual))
-	.type	.Lidata.ilt.\dll\().\actual,@object
-	.size	.Lidata.ilt.\dll\().\actual,.-.Lidata.ilt.\dll\().\actual
+	.section ".idata.ro.ilt.\dll\().2.\actual","a",@progbits
+".Lidata.ilt.\dll\().\actual":
+	.quad	RVA("\dll\().\actual")
+	.type	".Lidata.ilt.\dll\().\actual",@object
+	.size	".Lidata.ilt.\dll\().\actual",.-".Lidata.ilt.\dll\().\actual"
 	.previous
-	.section .idata.ro.hnt.\dll\().2.\actual,"a",@progbits
-\dll\().\actual:
+	.section ".idata.ro.hnt.\dll\().2.\actual","a",@progbits
+"\dll\().\actual":
 	.ifnb	\hint			# hint i.e. guess function ordinal
 	.short	\hint
 	.else
@@ -56,55 +56,55 @@
 	.endif
 	.asciz	"\actual"
 	.align	2			# documented requirement
-	.globl	\dll\().\actual
-	.hidden	\dll\().\actual
-	.type	\dll\().\actual,@object
-	.size	\dll\().\actual,.-\dll\().\actual
+	.globl	"\dll\().\actual"
+	.hidden	"\dll\().\actual"
+	.type	"\dll\().\actual",@object
+	.size	"\dll\().\actual",.-"\dll\().\actual"
 	.previous
 .endm

 //	Defines DLL import.
 //	@note	this is an implementation detail of .imp
 .macro	.dll	name:req
-  .section .idata.ro.idt.2.\name,"aG",@progbits,\name,comdat
-	.equ	.Lidata.idt.\name,.
-	.long	RVA(idata.ilt.\name)		# ImportLookupTable
+  .section ".idata.ro.idt.2.\name","aG",@progbits,"\name",comdat
+	.equ	".Lidata.idt.\name",.
+	.long	RVA("idata.ilt.\name")		# ImportLookupTable
 	.long	0				# TimeDateStamp
 	.long	0				# ForwarderChain
-	.long	RVA(.Lidata.str.\name)		# DllNameRva
-	.long	RVA(idata.iat.\name)		# ImportAddressTable
-	.type	.Lidata.idt.\name,@object
-	.size	.Lidata.idt.\name,.-.Lidata.idt.\name
+	.long	RVA(".Lidata.str.\name")	# DllNameRva
+	.long	RVA("idata.iat.\name")		# ImportAddressTable
+	.type	".Lidata.idt.\name",@object
+	.size	".Lidata.idt.\name",.-".Lidata.idt.\name"
  .previous
-  .section .idata.ro.ilt.\name\().1,"aG",@progbits,\name,comdat
+  .section ".idata.ro.ilt.\name\().1","aG",@progbits,"\name",comdat
 	.align	__SIZEOF_POINTER__
-	.type	idata.ilt.\name,@object
-idata.ilt.\name:
+	.type	"idata.ilt.\name",@object
+"idata.ilt.\name":
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section .idata.ro.ilt.\name\().3,"aG",@progbits,\name,comdat
+	*/.section ".idata.ro.ilt.\name\().3","aG",@progbits,"\name",comdat
 	.quad	0
  .previous
-  .section .idata.ro.hnt.\name\().1,"aG",@progbits,\name,comdat
+  .section ".idata.ro.hnt.\name\().1","aG",@progbits,"\name",comdat
 	.align	__SIZEOF_POINTER__
-	.type	idata.hnt.\name,@object
-	.equ	idata.hnt.\name,.
+	.type	"idata.hnt.\name",@object
+	.equ	"idata.hnt.\name",.
  .previous
-  .section .piro.data.sort.iat.2.\name\().1,"awG",@progbits,\name,comdat
+  .section ".piro.data.sort.iat.2.\name\().1","awG",@progbits,"\name",comdat
 	.align	__SIZEOF_POINTER__
-	.type	idata.iat.\name,@object
-idata.iat.\name:
+	.type	"idata.iat.\name",@object
+"idata.iat.\name":
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section .piro.data.sort.iat.2.\name\().3,"awG",@progbits,\name,comdat
+	*/.section ".piro.data.sort.iat.2.\name\().3","awG",@progbits,"\name",comdat
 	.quad	0
  .previous
  .section .rodata.str1.1,"aSM",@progbits,1
-.Lidata.str.\name:
+".Lidata.str.\name":
 	.asciz	"\name\().dll"
  .previous
 .endm
@@ -175,7 +175,7 @@ macho:	.long	0xFEEDFACE+1
 510:	.quad	0				# rax
 	.quad	0				# rbx
 	.quad	0				# rcx
-	.quad	XNU				# rdx
+	.quad	_HOSTXNU			# rdx
 	.quad	0				# rdi
 	.quad	0				# rsi
 	.quad	0				# rbp
@@ -213,7 +213,18 @@ macho:	.long	0xFEEDFACE+1
 //
 //	@see	APE_LOADER_ENTRY
 //	@see	ape/loader.h
-_start:	mov	%rsp,%rsi
+_start:
+
+//	Hack for detecting M1 Rosetta environment.
+//	https://github.com/jart/cosmopolitan/issues/429#issuecomment-1166704377
+	cmp	$-1,%ebx
+	jne	0f
+	cmp	$+1,%edx
+	jne	0f
+	mov	$_HOSTXNU,%dl
+	xor	%ecx,%ecx
+
+0:	mov	%rsp,%rsi
 	jmp	ApeLoader
 	.endfn	_start,globl

@@ -90,7 +90,7 @@ macho:	.long	0xFEEDFACE+1
 510:	.quad	0				# rax
 	.quad	0				# rbx
 	.quad	0				# rcx
-	.quad	XNU				# rdx
+	.quad	_HOSTXNU			# rdx
 	.quad	0				# rdi
 	.quad	0				# rsi
 	.quad	0				# rbp
@@ -113,7 +113,18 @@ macho:	.long	0xFEEDFACE+1
 	.endobj	macho,globl

 	.align	64
-_start:	mov	%rsp,%rsi
+_start:
+
+//	Hack for detecting M1 Rosetta environment.
+//	https://github.com/jart/cosmopolitan/issues/429#issuecomment-1166704377
+	cmp	$-1,%ebx
+	jne	0f
+	cmp	$+1,%edx
+	jne	0f
+	mov	$_HOSTXNU,%dl
+	xor	%ecx,%ecx
+
+0:	mov	%rsp,%rsi
 	jmp	ApeLoader
 	.endfn	_start,globl

@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "ape/loader.h"

+#define SET_EXE_FILE    0 /* needs root ;_; */
 #define TROUBLESHOOT    0
 #define TROUBLESHOOT_OS LINUX

@@ -36,7 +37,7 @@
 * `ape/ape.S` bootloader embeds this binary inside each binary that's
 * linked using `$(APE_NO_MODIFY_SELF)` so it is an automated seamless
 * process. the shell script at the top of the .COM files will copy it
- * to `${TMPDIR:-/tmp}/ape` and call execve(). It's a zero copy
+ * to `${TMPDIR:-${HOME:-.}}/.ape` and call execve(). It's a zero copy
 * operation in praxis since this payload uses mmap() to load the rest
 * of your executable the same way the kernel does, based on ELF phdrs
 * which are located in accordance with the first sh printf statement.
@@ -99,30 +100,32 @@
 #define IsOpenbsd() (SupportsOpenbsd() && os == OPENBSD)
 #define IsNetbsd()  (SupportsNetbsd() && os == NETBSD)

-#define O_RDONLY         0
-#define PROT_READ        1
-#define PROT_WRITE       2
-#define PROT_EXEC        4
-#define MAP_SHARED       1
-#define MAP_PRIVATE      2
-#define MAP_FIXED        16
-#define MAP_ANONYMOUS    (IsLinux() ? 32 : 4096)
-#define AT_EXECFN_LINUX  31
-#define AT_EXECFN_NETBSD 2014
-#define ELFCLASS64       2
-#define ELFDATA2LSB      1
-#define EM_NEXGEN32E     62
-#define ET_EXEC          2
-#define PT_LOAD          1
-#define PT_DYNAMIC       2
-#define EI_CLASS         4
-#define EI_DATA          5
-#define PF_X             1
-#define PF_W             2
-#define PF_R             4
-#define X_OK             1
-#define XCR0_SSE         2
-#define XCR0_AVX         4
+#define O_RDONLY           0
+#define PROT_READ          1
+#define PROT_WRITE         2
+#define PROT_EXEC          4
+#define MAP_SHARED         1
+#define MAP_PRIVATE        2
+#define MAP_FIXED          16
+#define MAP_ANONYMOUS      (IsLinux() ? 32 : 4096)
+#define AT_EXECFN_LINUX    31
+#define AT_EXECFN_NETBSD   2014
+#define ELFCLASS64         2
+#define ELFDATA2LSB        1
+#define EM_NEXGEN32E       62
+#define ET_EXEC            2
+#define PT_LOAD            1
+#define PT_DYNAMIC         2
+#define EI_CLASS           4
+#define EI_DATA            5
+#define PF_X               1
+#define PF_W               2
+#define PF_R               4
+#define X_OK               1
+#define XCR0_SSE           2
+#define XCR0_AVX           4
+#define PR_SET_MM          35
+#define PR_SET_MM_EXE_FILE 13

 #define Read32(S)                                                      \
  ((unsigned)(255 & (S)[3]) << 030 | (unsigned)(255 & (S)[2]) << 020 | \
@@ -174,7 +177,10 @@ struct ElfPhdr {
  unsigned long p_align;
 };

-static void *syscall;
+extern char ehdr[];
+extern char _end[];
+static void *syscall_;
+static char relocated;
 static struct PathSearcher ps;
 extern char __syscall_loader[];

@@ -182,7 +188,7 @@ static int ToLower(int c) {
  return 'A' <= c && c <= 'Z' ? c + ('a' - 'A') : c;
 }

-static char *MemCpy(char *d, const char *s, unsigned long n) {
+char *MemCpy(char *d, const char *s, unsigned long n) {
  unsigned long i = 0;
  for (; i < n; ++i) d[i] = s[i];
  return d + n;
@@ -269,7 +275,7 @@ __attribute__((__noreturn__)) static void Exit(int rc, int os) {
  asm volatile("call\t*%2"
               : /* no outputs */
               : "a"((IsLinux() ? 60 : 1) | (IsXnu() ? 0x2000000 : 0)), "D"(rc),
-                 "rm"(syscall)
+                 "rm"(syscall_)
               : "memory");
  __builtin_unreachable();
 }
@@ -279,7 +285,7 @@ static void Close(int fd, int os) {
  asm volatile("call\t*%4"
               : "=a"(ax), "=D"(di)
               : "0"((IsLinux() ? 3 : 6) | (IsXnu() ? 0x2000000 : 0)), "1"(fd),
-                 "rm"(syscall)
+                 "rm"(syscall_)
               : "rcx", "rdx", "rsi", "r8", "r9", "r10", "r11", "memory", "cc");
 }

@@ -289,7 +295,7 @@ static int Read(int fd, void *data, int size, int os) {
  asm volatile("call\t*%8"
               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx)
               : "0"((IsLinux() ? 0 : 3) | (IsXnu() ? 0x2000000 : 0)), "1"(fd),
-                 "2"(data), "3"(size), "rm"(syscall)
+                 "2"(data), "3"(size), "rm"(syscall_)
               : "rcx", "r8", "r9", "r10", "r11", "memory");
  return ax;
 }
@@ -300,7 +306,7 @@ static void Write(int fd, const void *data, int size, int os) {
  asm volatile("call\t*%8"
               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx)
               : "0"((IsLinux() ? 1 : 4) | (IsXnu() ? 0x2000000 : 0)), "1"(fd),
-                 "2"(data), "3"(size), "rm"(syscall)
+                 "2"(data), "3"(size), "rm"(syscall_)
               : "rcx", "r8", "r9", "r10", "r11", "memory", "cc");
 }

@@ -309,7 +315,7 @@ static void Execve(const char *prog, char **argv, char **envp, int os) {
  asm volatile("call\t*%8"
               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx)
               : "0"(59 | (IsXnu() ? 0x2000000 : 0)), "1"(prog), "2"(argv),
-                 "3"(envp), "rm"(syscall)
+                 "3"(envp), "rm"(syscall_)
               : "rcx", "r8", "r9", "r10", "r11", "memory", "cc");
 }

@@ -319,7 +325,7 @@ static int Access(const char *path, int mode, int os) {
  asm volatile("call\t*%7"
               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx)
               : "0"((IsLinux() ? 21 : 33) | (IsXnu() ? 0x2000000 : 0)),
-                 "1"(path), "2"(mode), "rm"(syscall)
+                 "1"(path), "2"(mode), "rm"(syscall_)
               : "rcx", "r8", "r9", "r10", "r11", "memory", "cc");
  return ax;
 }
@@ -332,7 +338,7 @@ static int Msyscall(long p, long n, int os) {
  } else {
    asm volatile("call\t*%6"
                 : "=a"(ax), "=D"(di), "=S"(si)
-                 : "0"(37), "1"(p), "2"(n), "rm"(syscall)
+                 : "0"(37), "1"(p), "2"(n), "rm"(syscall_)
                 : "rcx", "rdx", "r8", "r9", "r10", "r11", "memory", "cc");
    return ax;
  }
@@ -344,7 +350,7 @@ static int Open(const char *path, int flags, int mode, int os) {
  asm volatile("call\t*%8"
               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx)
               : "0"((IsLinux() ? 2 : 5) | (IsXnu() ? 0x2000000 : 0)),
-                 "1"(path), "2"(flags), "3"(mode), "rm"(syscall)
+                 "1"(path), "2"(flags), "3"(mode), "rm"(syscall_)
               : "rcx", "r8", "r9", "r10", "r11", "memory", "cc");
  return ax;
 }
@@ -363,7 +369,7 @@ __attribute__((__noinline__)) static long Mmap(long addr, long size, int prot,
               "pop\t%%r9"
               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx), "+r"(flags_),
                 "+r"(fd_), "+r"(off_)
-               : "rm"(syscall),
+               : "rm"(syscall_),
                 "0"((IsLinux()     ? 9
                      : IsFreebsd() ? 477
                                    : 197) |
@@ -373,6 +379,26 @@ __attribute__((__noinline__)) static long Mmap(long addr, long size, int prot,
  return ax;
 }

+int MunmapLinux(const void *addr, unsigned long size) {
+  int ax;
+  asm volatile("syscall"
+               : "=a"(ax)
+               : "0"(11), "D"(addr), "S"(size)
+               : "rcx", "r11", "memory");
+  return ax;
+}
+
+int PrctlLinux(int op, long a, long b, long c, long d) {
+  int rc;
+  asm volatile("mov\t%5,%%r10\n\t"
+               "mov\t%6,%%r8\n\t"
+               "syscall"
+               : "=a"(rc)
+               : "0"(157), "D"(op), "S"(a), "d"(b), "g"(c), "g"(d)
+               : "rcx", "r8", "r10", "r11", "memory");
+  return rc;
+}
+
 static void Emit(int os, const char *s) {
  Write(2, s, StrLen(s), os);
 }
@@ -539,6 +565,23 @@ __attribute__((__noreturn__)) static void Spawn(int os, const char *exe, int fd,
  if (!code) {
    Pexit(os, exe, 0, "ELF needs PT_LOAD phdr w/ PF_X");
  }
+
+#if SET_EXE_FILE
+  // change /proc/pid/exe to new executable path
+  if (IsLinux() && relocated) {
+    MunmapLinux((char *)0x200000, (long)(_end - ehdr));
+    PrctlLinux(PR_SET_MM, PR_SET_MM_EXE_FILE, fd, 0, 0);
+  }
+#endif
+
+  if (relocated) {
+    int ax;
+    asm volatile("syscall"
+                 : "=a"(ax)
+                 : "0"(1), "D"(1), "S"("hello\n"), "d"(6)
+                 : "rcx", "r11", "memory");
+  }
+
  Close(fd, os);

  // authorize only the loaded program to issue system calls. if this
@@ -546,7 +589,7 @@ __attribute__((__noreturn__)) static void Spawn(int os, const char *exe, int fd,
  // since it probably means a userspace program executed this loader
  // and passed us a custom syscall function earlier.
  if (Msyscall(code, codesize, os) != -1) {
-    syscall = 0;
+    syscall_ = 0;
  }

 #if TROUBLESHOOT
@@ -557,16 +600,16 @@ __attribute__((__noreturn__)) static void Spawn(int os, const char *exe, int fd,
  // to extend the behavior of this loader in the future. we don't need
  // to clear the xmm registers since the ape loader should be compiled
  // with the -mgeneral-regs-only flag.
-  register void *r8 asm("r8") = syscall;
+  register void *r8 asm("r8") = syscall_;
  asm volatile("xor\t%%eax,%%eax\n\t"
               "xor\t%%r9d,%%r9d\n\t"
               "xor\t%%r10d,%%r10d\n\t"
               "xor\t%%r11d,%%r11d\n\t"
-               "xor\t%%ebx,%%ebx\n\t"    // netbsd dosen't clear this
-               "xor\t%%r12d,%%r12d\n\t"  // netbsd dosen't clear this
-               "xor\t%%r13d,%%r13d\n\t"  // netbsd dosen't clear this
-               "xor\t%%r14d,%%r14d\n\t"  // netbsd dosen't clear this
-               "xor\t%%r15d,%%r15d\n\t"  // netbsd dosen't clear this
+               "xor\t%%ebx,%%ebx\n\t"    // netbsd doesnt't clear this
+               "xor\t%%r12d,%%r12d\n\t"  // netbsd doesnt't clear this
+               "xor\t%%r13d,%%r13d\n\t"  // netbsd doesnt't clear this
+               "xor\t%%r14d,%%r14d\n\t"  // netbsd doesnt't clear this
+               "xor\t%%r15d,%%r15d\n\t"  // netbsd doesnt't clear this
               "mov\t%%rdx,%%rsp\n\t"
               "xor\t%%edx,%%edx\n\t"
               "push\t%%rsi\n\t"
@@ -584,7 +627,7 @@ __attribute__((__noreturn__)) void ApeLoader(long di, long *sp, char dl,
                                             struct ApeLoader *handoff) {
  int rc;
  long *auxv;
-  struct ElfEhdr *ehdr;
+  struct ElfEhdr *eh;
  int c, i, fd, os, argc;
  char *p, *exe, *prog, **argv, **envp, *page;
  static union {
@@ -595,11 +638,11 @@ __attribute__((__noreturn__)) void ApeLoader(long di, long *sp, char dl,
  // detect freebsd
  if (handoff) {
    os = handoff->os;
+  } else if (SupportsXnu() && dl == XNU) {
+    os = XNU;
  } else if (SupportsFreebsd() && di) {
    os = FREEBSD;
    sp = (long *)di;
-  } else if (SupportsXnu() && dl == XNU) {
-    os = XNU;
  } else {
    os = 0;
  }
@@ -616,10 +659,10 @@ __attribute__((__noreturn__)) void ApeLoader(long di, long *sp, char dl,
  }

  // get syscall function pointer
-  if (handoff && handoff->syscall) {
-    syscall = handoff->syscall;
+  if (handoff && handoff->systemcall) {
+    syscall_ = handoff->systemcall;
  } else {
-    syscall = __syscall_loader;
+    syscall_ = __syscall_loader;
  }

  if (handoff) {
@@ -630,7 +673,7 @@ __attribute__((__noreturn__)) void ApeLoader(long di, long *sp, char dl,
    fd = handoff->fd;
    exe = handoff->prog;
    page = handoff->page;
-    ehdr = (struct ElfEhdr *)handoff->page;
+    eh = (struct ElfEhdr *)handoff->page;
  } else {

    // detect openbsd
@@ -653,6 +696,20 @@ __attribute__((__noreturn__)) void ApeLoader(long di, long *sp, char dl,
      os = LINUX;
    }

+#if SET_EXE_FILE
+    if (IsLinux() && !relocated) {
+      char *b1 = (char *)0x200000;
+      char *b2 = (char *)0x300000;
+      void (*pApeLoader)(long, long *, char, struct ApeLoader *);
+      Mmap((long)b2, (long)(_end - ehdr), PROT_READ | PROT_WRITE | PROT_EXEC,
+           MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0, os);
+      relocated = 1;
+      MemCpy(b2, b1, (long)(_end - ehdr));
+      pApeLoader = (void *)((char *)&ApeLoader - b1 + b2);
+      pApeLoader(di, sp, dl, handoff);
+    }
+#endif
+
    // we can load via shell, shebang, or binfmt_misc
    if (argc >= 3 && !StrCmp(argv[1], "-")) {
      // if the first argument is a hyphen then we give the user the
@@ -686,7 +743,7 @@ __attribute__((__noreturn__)) void ApeLoader(long di, long *sp, char dl,
    }

    page = u.p;
-    ehdr = &u.ehdr;
+    eh = &u.ehdr;
  }

 #if TROUBLESHOOT
@@ -726,7 +783,7 @@ __attribute__((__noreturn__)) void ApeLoader(long di, long *sp, char dl,
      page[i++] = c;
    }
    if (i >= 64 && Read32(page) == Read32("\177ELF")) {
-      Spawn(os, exe, fd, sp, page, ehdr);
+      Spawn(os, exe, fd, sp, page, eh);
    }
  }

@@ -14,7 +14,7 @@ struct ApeLoader {
  int os;
  char *prog;
  char *page;
-  void *syscall;
+  void *systemcall;
 };

 #endif /* COSMOPOLITAN_APE_LOADER_H_ */
@@ -32,7 +32,8 @@ SECTIONS {
    *(.bss)
    . = ALIGN(4096);
  }
-  memsz = . - ehdr;
+  _end = .;
+  memsz = _end - ehdr;
  /DISCARD/ : {
    *(.*)
  }
@@ -54,7 +54,7 @@
 	jmp	297f
 	.byte	0xbf			# mov $0x????xxxx,%edi
 	.long	\address
-297:	
+297:
 .endm

 //	Loads 16-bit CONSTEXPR into Qw-register w/ optional zero-extend.
@@ -180,6 +180,20 @@
 .stub	\name\()_bcs\n,long
 .endm

+//	Task State Segment Descriptor Entries.
+.macro	.tssdescstub name:req
+ .ifndef \name
+  .weak	\name
+  .set	\name,0
+ .endif
+ .ifndef \name\()_end
+  .weak	\name\()_end
+  .set	\name\()_end,0
+ .endif
+ .stub	\name\()_desc_ent0,quad
+ .stub	\name\()_desc_ent1,quad
+.endm
+
 /* clang-format on */
 #elif defined(__LINKER__)

@@ -221,44 +235,58 @@
 /**
 * Binary coded decimal support.
 *
- * <p>This allows linker scripts to generate dd commands. Leading spaces
- * need to be inserted so Mac doesn't consider them octal; therefore,
- * parameters must be quoted; and eight digits should be good enough.
+ * <p>This allows linker scripts to generate dd commands, e.g. ape.lds.
+ * There are a few ways to pad each number to the necessary 8 bytes.
+ * Spaces cannot be prepended because busybox refuses to parse them.
+ * Zeros cannot be prepended because Mac will take numbers as octal.
+ * That leaves appending spaces. The user's shell ought to treat any
+ * unquoted run of spaces as if there was only one, so this is safe.
 */
-#define SHSTUB2(SYM, X)           \
-  HIDDEN(SYM##_bcs0 = BCD10K(X)); \
-  HIDDEN(SYM##_bcs1 = BCD(X))
-#define BCD(X)                                                                 \
-  ((X) == 0                                                                    \
-       ? 0x20202030                                                            \
-       : (X) < 10 ? 0x30202020 + (((X) % 10) << 24)                            \
-                  : (X) < 100 ? 0x30302020 + (((X) % 10) << 24) +              \
-                                    (((X) / 10 % 10) << 16)                    \
-                              : (X) < 1000 ? 0x30303020 + (((X) % 10) << 24) + \
-                                                 (((X) / 10 % 10) << 16) +     \
-                                                 (((X) / 100 % 10) << 8)       \
-                                           : 0x30303030 + (((X) % 10) << 24) + \
-                                                 (((X) / 10 % 10) << 16) +     \
-                                                 (((X) / 100 % 10) << 8) +     \
-                                                 (((X) / 1000 % 10) << 0))
-#define BCD10K(X)                                                          \
-  ((X) < 10000                                                             \
-       ? 0x20202020                                                        \
-       : (X) < 100000                                                      \
-             ? 0x30202020 + (((X) / 10000 % 10) << 24)                     \
-             : (X) < 1000000                                               \
-                   ? 0x30302020 + (((X) / 10000 % 10) << 24) +             \
-                         (((X) / 100000 % 10) << 16)                       \
-                   : (X) < 10000000                                        \
-                         ? 0x30303020 + (((X) / 10000 % 10) << 24) +       \
-                               (((X) / 100000 % 10) << 16) +               \
-                               (((X) / 1000000 % 10) << 8)                 \
-                         : (X) < 100000000                                 \
-                               ? 0x30303030 + (((X) / 10000 % 10) << 24) + \
-                                     (((X) / 100000 % 10) << 16) +         \
-                                     (((X) / 1000000 % 10) << 8) +         \
-                                     (((X) / 10000000 % 10) << 0)          \
-                               : 0xffffffffffffffff)
+#define SHSTUB2(SYM, X)             \
+  HIDDEN(SYM##_bcs0 = BCD_LEFT(X)); \
+  HIDDEN(SYM##_bcs1 = BCD_RIGHT(X))
+#define BCD_SMEAR(X) ((X) + (X) * 10000)
+#define BCD_LEFT(X)                                      \
+  (((X)) < 10000     ? BCD_RIGHT(BCD_SMEAR(X)) | 0x10    \
+   : (X) < 100000    ? BCD_RIGHT(BCD_SMEAR((X) / 10))    \
+   : (X) < 1000000   ? BCD_RIGHT(BCD_SMEAR((X) / 100))   \
+   : (X) < 10000000  ? BCD_RIGHT(BCD_SMEAR((X) / 1000))  \
+   : (X) < 100000000 ? BCD_RIGHT(BCD_SMEAR((X) / 10000)) \
+                     : 0xffffffffffffffff)
+#define BCD_RIGHT(X) \
+  (((X)) < 10000     ? 0x20202020                  \
+   : (X) < 100000    ? 0x20202030 +                \
+                       (X) % 10                    \
+   : (X) < 1000000   ? 0x20203030 +                \
+                       ((X) / 10) % 10 +           \
+                       (X) % 10 * 0x100            \
+   : (X) < 10000000  ? 0x20303030 +                \
+                       ((X) / 100) % 10 +          \
+                       ((X) / 10) % 10 * 0x100 +   \
+                       (X) % 10 * 0x10000          \
+   : (X) < 100000000 ? 0x30303030 +                \
+                       ((X) / 1000) % 10 +         \
+                       ((X) / 100) % 10 * 0x100 +  \
+                       ((X) / 10) % 10 * 0x10000 + \
+                       (X) % 10 * 0x1000000        \
+                     : 0xffffffffffffffff)
+
+/**
+ * Laying out the GDT entries for a TSS for bare metal operation.
+ */
+#define TSSDESCSTUB2(SYM, BASE, LIM)                 \
+  HIDDEN(SYM##_desc_ent0 = TSSDESC_ENT0(BASE, LIM)); \
+  HIDDEN(SYM##_desc_ent1 = TSSDESC_ENT1(BASE));      \
+  ASSERT((LIM) >= 0 && (LIM) <= 0xffff, "bare metal TSS is suspiciously fat")
+#define TSSDESC_ENT0(BASE, LIM)                \
+  (((LIM)        <<  0 & 0x000000000000ffff) | \
+   ((BASE)       << 16 & 0x000000ffffff0000) | \
+    0x89         << 40                       | \
+   ((LIM)  >> 16 << 48 & 0x000f000000000000) | \
+    0x2          << 52                       | \
+   ((BASE) >> 24 << 56 & 0xff00000000000000))
+#define TSSDESC_ENT1(BASE)                     \
+   ((BASE) >> 32 <<  0 & 0x00000000ffffffff)

 #endif /* __ASSEMBLER__ */
 #endif /* APE_MACROS_H_ */
@@ -0,0 +1 @@
+#include "ape/ape.lds"
@@ -36,8 +36,8 @@
 */
 #define REAL(x) ((x) - (IMAGE_BASE_VIRTUAL - IMAGE_BASE_REAL))

-#if IMAGE_BASE_VIRTUAL % 0x200000 != 0
-#error "IMAGE_BASE_VIRTUAL must be 2mb aligned"
+#if IMAGE_BASE_VIRTUAL % 0x1000 != 0
+#error "IMAGE_BASE_VIRTUAL must be 4kb aligned"
 #endif
 #if IMAGE_BASE_PHYSICAL % 0x1000 != 0
 #error "IMAGE_BASE_PHYSICAL must be 4kb aligned"
@@ -4,20 +4,35 @@
 # Default Mode
 #
 #   - `make`
+#   - Optimized
 #   - Backtraces
+#   - Debuggable
 #   - Syscall tracing
 #   - Function tracing
 #   - Reasonably small
-#   - Reasonably optimized
-#   - Reasonably debuggable
+#
 ifeq ($(MODE),)
-CONFIG_CCFLAGS +=		\
-	$(BACKTRACES)		\
-	$(FTRACE)		\
-	-DSYSDEBUG		\
-	-Og
-TARGET_ARCH ?=			\
-	-msse3
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2
+CONFIG_CPPFLAGS += -DSYSDEBUG
+TARGET_ARCH ?= -msse3
+endif
+
+# Fast Build Mode
+#
+#   - `make MODE=fastbuild`
+#   - No debugging
+#   - Syscall tracing
+#   - Function tracing
+#   - Some optimizations
+#   - Limited Backtraces
+#   - Compiles 28% faster
+#
+ifeq ($(MODE),fastbuild)
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O
+CONFIG_CPPFLAGS += -DSYSDEBUG
+CONFIG_OFLAGS += -g0
+CONFIG_LDFLAGS += -S
+TARGET_ARCH ?= -msse3
 endif

 # Optimized Mode
@@ -31,19 +46,11 @@ endif
 #   - No memory corruption detection
 #   - assert() / CHECK_xx() may leak code into binary for debuggability
 #   - GCC 8+ hoists check fails into .text.cold, thus minimizing impact
+#
 ifeq ($(MODE), opt)
-CONFIG_CPPFLAGS +=		\
-	-DNDEBUG		\
-	-msse2avx		\
-	-Wa,-msse2avx
-CONFIG_CCFLAGS +=		\
-	$(BACKTRACES)		\
-	$(FTRACE)		\
-	-DSYSDEBUG		\
-	-O3			\
-	-fmerge-all-constants
-TARGET_ARCH ?=			\
-	-march=native
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -msse2avx -Wa,-msse2avx
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O3 -fmerge-all-constants
+TARGET_ARCH ?= -march=native
 endif

 # Optimized Linux Mode
@@ -54,18 +61,12 @@ endif
 #   - Turns off function tracing
 #   - Turns off support for older cpu models
 #   - Turns off support for other operating systems
+#
 ifeq ($(MODE), optlinux)
-CONFIG_CPPFLAGS +=		\
-	-DNDEBUG		\
-	-msse2avx		\
-	-Wa,-msse2avx		\
-	-DSUPPORT_VECTOR=1
-CONFIG_CCFLAGS +=		\
-	-O3 -fmerge-all-constants
-DEFAULT_COPTS +=		\
-	-mred-zone
-TARGET_ARCH ?=			\
-	-march=native
+CONFIG_CPPFLAGS += -DNDEBUG -msse2avx -Wa,-msse2avx -DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS += -O3 -fmerge-all-constants
+DEFAULT_COPTS += -mred-zone
+TARGET_ARCH ?= -march=native
 endif

 # Release Mode
@@ -81,16 +82,12 @@ endif
 #   - DCHECK_xx() statements removed
 #   - No memory corruption detection
 #   - CHECK_xx() won't leak strings into binary
+#
 ifeq ($(MODE), rel)
-CONFIG_CPPFLAGS +=		\
-	-DNDEBUG
-CONFIG_CCFLAGS +=		\
-	$(BACKTRACES)		\
-	-O2
-TARGET_ARCH ?=			\
-	-msse3
-PYFLAGS +=			\
-	-O1
+CONFIG_CPPFLAGS += -DNDEBUG
+CONFIG_CCFLAGS += $(BACKTRACES) -O2
+TARGET_ARCH ?= -msse3
+PYFLAGS += -O1
 endif

 # Asan Mode
@@ -103,14 +100,11 @@ endif
 #   - Backtraces
 #   - Debuggability
 #   - Larger binaries
+#
 ifeq ($(MODE), asan)
-CONFIG_CCFLAGS +=		\
-	$(BACKTRACES)		\
-	-O2
-CONFIG_COPTS +=			\
-	-fsanitize=address
-TARGET_ARCH ?=			\
-	-msse3
+CONFIG_CCFLAGS += $(BACKTRACES) -O2 -DSYSDEBUG
+CONFIG_COPTS += -fsanitize=address
+TARGET_ARCH ?= -msse3
 endif

 # Debug Mode
@@ -122,22 +116,13 @@ endif
 #   - Stack canaries
 #   - No optimization (TODO)
 #   - Enormous binaries
+#
 ifeq ($(MODE), dbg)
-CONFIG_CPPFLAGS +=		\
-	-DMODE_DBG
-CONFIG_CCFLAGS +=		\
-	$(BACKTRACES)		\
-	$(FTRACE)		\
-	-DSYSDEBUG		\
-	-O2			\
-	-fno-inline
-CONFIG_COPTS +=			\
-	-fsanitize=address	\
-	-fsanitize=undefined
-TARGET_ARCH ?=			\
-	-msse3
-OVERRIDE_CCFLAGS +=		\
-	-fno-pie
+CONFIG_CPPFLAGS += -DMODE_DBG
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -DSYSDEBUG -O -fno-inline
+CONFIG_COPTS += -fsanitize=address -fsanitize=undefined
+TARGET_ARCH ?= -msse3
+OVERRIDE_CCFLAGS += -fno-pie
 endif

 # Tiny Mode
@@ -151,6 +136,7 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
+#
 ifeq ($(MODE), tiny)
 CONFIG_CPPFLAGS +=			\
 	-DTINY				\
@@ -166,6 +152,10 @@ CONFIG_CCFLAGS +=			\
 	-fomit-frame-pointer		\
 	-momit-leaf-frame-pointer	\
 	-foptimize-sibling-calls
+CONFIG_OFLAGS +=			\
+	-g0
+CONFIG_LDFLAGS +=			\
+	-S
 TARGET_ARCH ?=				\
 	-msse3
 PYFLAGS +=				\
@@ -185,6 +175,7 @@ endif
 #   - No portability
 #   - No algorithmics
 #   - YOLO
+#
 ifeq ($(MODE), tinylinux)
 CONFIG_CPPFLAGS +=			\
 	-DTINY				\
@@ -193,6 +184,10 @@ CONFIG_CPPFLAGS +=			\
 	-DSUPPORT_VECTOR=1
 DEFAULT_COPTS +=			\
 	-mred-zone
+CONFIG_OFLAGS +=			\
+	-g0
+CONFIG_LDFLAGS +=			\
+	-S
 CONFIG_CCFLAGS +=			\
 	-Os				\
 	-fno-align-functions		\
@@ -216,6 +211,7 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
+#
 ifeq ($(MODE), tinylinuxbsd)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
@@ -224,6 +220,10 @@ CONFIG_CPPFLAGS +=		\
 	-DSUPPORT_VECTOR=113
 DEFAULT_COPTS +=		\
 	-mred-zone
+CONFIG_OFLAGS +=		\
+	-g0
+CONFIG_LDFLAGS +=		\
+	-S
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -246,6 +246,7 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
+#
 ifeq ($(MODE), tinysysv)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
@@ -260,6 +261,10 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
+CONFIG_OFLAGS +=		\
+	-g0
+CONFIG_LDFLAGS +=		\
+	-S
 TARGET_ARCH ?=			\
 	-msse3
 endif
@@ -276,6 +281,7 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
+#
 ifeq ($(MODE), tinynowin)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
@@ -288,10 +294,36 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
+CONFIG_OFLAGS +=		\
+	-g0
+CONFIG_LDFLAGS +=		\
+	-S
 TARGET_ARCH ?=			\
 	-msse3
 endif

+# GCC11 Mode
+# https://justine.lol/compilers/x86_64-linux-musl__x86_64-linux-musl__g++-11.2.0.tar.xz
+ifeq ($(MODE), gcc11)
+.UNVEIL += rx:/opt/gcc11
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -DSYSDEBUG -O2
+AS = /opt/gcc11/bin/x86_64-linux-musl-as
+CC = /opt/gcc11/bin/x86_64-linux-musl-gcc
+CXX = /opt/gcc11/bin/x86_64-linux-musl-g++
+CXXFILT = /opt/gcc11/bin/x86_64-linux-musl-c++filt
+LD = /opt/gcc11/bin/x86_64-linux-musl-ld.bfd
+NM = /opt/gcc11/bin/x86_64-linux-musl-nm
+GCC = /opt/gcc11/bin/x86_64-linux-musl-gcc
+STRIP = /opt/gcc11/bin/x86_64-linux-musl-strip
+OBJCOPY = /opt/gcc11/bin/x86_64-linux-musl-objcopy
+OBJDUMP = /opt/gcc11/bin/x86_64-linux-musl-objdump
+ADDR2LINE = /opt/gcc11/bin/x86_64-linux-musl-addr2line
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2 -Wno-stringop-overread
+CONFIG_CFLAGS += -Wno-old-style-definition
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
+TARGET_ARCH ?= -msse3
+endif
+
 # LLVM Mode
 ifeq ($(MODE), llvm)
 TARGET_ARCH ?= -msse3
@@ -62,8 +62,9 @@ TOUCH = build/bootstrap/touch.com
 PKG = build/bootstrap/package.com
 MKDEPS = build/bootstrap/mkdeps.com
 ZIPOBJ = build/bootstrap/zipobj.com
+FIXUPOBJ = build/bootstrap/fixupobj.com
 MKDIR = build/bootstrap/mkdir.com -p
-COMPILE = build/bootstrap/compile.com -V9 $(QUOTA)
+COMPILE = build/bootstrap/compile.com -V9 -P4096 $(QUOTA)

 COMMA := ,
 PWD := $(shell build/bootstrap/pwd.com)
@@ -72,33 +73,25 @@ IMAGE_BASE_VIRTUAL ?= 0x400000
 IGNORE := $(shell $(ECHO) -2 ♥cosmo)
 IGNORE := $(shell $(MKDIR) o/tmp)

-ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-pc-linux-gnu-as.exe)","")
-AS = o/third_party/gcc/bin/x86_64-pc-linux-gnu-as.exe
-CC = o/third_party/gcc/bin/x86_64-pc-linux-gnu-gcc.exe
-CXX = o/third_party/gcc/bin/x86_64-pc-linux-gnu-g++.exe
-CXXFILT = o/third_party/gcc/bin/x86_64-pc-linux-gnu-c++filt.exe
-LD = o/third_party/gcc/bin/x86_64-pc-linux-gnu-ld.bfd.exe
-NM = o/third_party/gcc/bin/x86_64-pc-linux-gnu-nm.exe
-GCC = o/third_party/gcc/bin/x86_64-pc-linux-gnu-gcc.exe
-STRIP = o/third_party/gcc/bin/x86_64-pc-linux-gnu-strip.exe
-OBJCOPY = o/third_party/gcc/bin/x86_64-pc-linux-gnu-objcopy.exe
-OBJDUMP = o/third_party/gcc/bin/x86_64-pc-linux-gnu-objdump.exe
-ADDR2LINE = $(shell build/bootstrap/pwd.com)/o/third_party/gcc/bin/x86_64-pc-linux-gnu-addr2line.exe
+ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-pc-linux-gnu-*)","")
+PREFIX = o/third_party/gcc/bin/x86_64-pc-linux-gnu-
 else
 IGNORE := $(shell build/bootstrap/unbundle.com)
-AS = o/third_party/gcc/bin/x86_64-linux-musl-as
-CC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
-CXX = o/third_party/gcc/bin/x86_64-linux-musl-g++
-CXXFILT = o/third_party/gcc/bin/x86_64-linux-musl-c++filt
-LD = o/third_party/gcc/bin/x86_64-linux-musl-ld.bfd
-NM = o/third_party/gcc/bin/x86_64-linux-musl-nm
-GCC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
-STRIP = o/third_party/gcc/bin/x86_64-linux-musl-strip
-OBJCOPY = o/third_party/gcc/bin/x86_64-linux-musl-objcopy
-OBJDUMP = o/third_party/gcc/bin/x86_64-linux-musl-objdump
-ADDR2LINE = $(shell build/bootstrap/pwd.com)/o/third_party/gcc/bin/x86_64-linux-musl-addr2line
+PREFIX = o/third_party/gcc/bin/x86_64-linux-musl-
 endif

+AS = $(PREFIX)as
+CC = $(PREFIX)gcc
+CXX = $(PREFIX)g++
+CXXFILT = $(PREFIX)c++filt
+LD = $(PREFIX)ld.bfd
+NM = $(PREFIX)nm
+GCC = $(PREFIX)gcc
+STRIP = $(PREFIX)strip
+OBJCOPY = $(PREFIX)objcopy
+OBJDUMP = $(PREFIX)objdump
+ADDR2LINE = $(PWD)/$(PREFIX)addr2line
+
 export ADDR2LINE
 export LC_ALL
 export MKDIR
@@ -106,6 +99,12 @@ export MODE
 export SOURCE_DATE_EPOCH
 export TMPDIR

+ifeq ($(LANDLOCKMAKE_VERSION),)
+TMPSAFE = $(TMPDIR)/$(subst /,_,$@).tmp
+else
+TMPSAFE = $(TMPDIR)/
+endif
+
 FTRACE =								\
 	-pg

@@ -141,6 +140,7 @@ DEFAULT_CCFLAGS =							\

 DEFAULT_OFLAGS =							\
 	-g								\
+	-gdwarf-4							\
 	-gdescribe-dies

 DEFAULT_COPTS =								\
@@ -153,7 +153,8 @@ DEFAULT_COPTS =								\
 	-fno-gnu-unique							\
 	-fstrict-aliasing						\
 	-fstrict-overflow						\
-	-fno-semantic-interposition
+	-fno-semantic-interposition					\
+	-mno-tls-direct-seg-refs

 MATHEMATICAL =								\
 	-O3								\
@@ -164,7 +165,7 @@ DEFAULT_CPPFLAGS =							\
 	-DMODE='"$(MODE)"'						\
 	-DIMAGE_BASE_VIRTUAL=$(IMAGE_BASE_VIRTUAL)			\
 	-nostdinc							\
-	-iquote.
+	-iquote .

 DEFAULT_CFLAGS =							\
 	-std=gnu2x
@@ -175,7 +176,8 @@ DEFAULT_CXXFLAGS =							\
 	-fuse-cxa-atexit						\
 	-fno-threadsafe-statics						\
 	-Wno-int-in-bool-context					\
-	-Wno-narrowing
+	-Wno-narrowing							\
+	-Wno-literal-suffix

 DEFAULT_ASFLAGS =							\
 	-W								\
@@ -230,7 +232,7 @@ cpp.flags =								\
 	$(CONFIG_CPPFLAGS)						\
 	$(CPPFLAGS)							\
 	$(OVERRIDE_CPPFLAGS)						\
-	-includelibc/integral/normalize.inc
+	-include libc/integral/normalize.inc

 copt.flags =								\
 	$(TARGET_ARCH)							\
@@ -12,5 +12,9 @@

 tail = $(wordlist 2,$(words $1),$1)
 reverse = $(if $1,$(call reverse,$(call tail,$1)) $(firstword $1))
-uniq = $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1)))
 uniqr = $(if $1,$(call uniqr,$(filter-out $(firstword $1),$1)) $(firstword $1))
+
+# polyfill uniq native (landlock make 1.4)
+ifneq ($(call uniq,c b c a),c b a)
+uniq = $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1)))
+endif
@@ -23,8 +23,9 @@
 #   - tool/build/runitd.c

 .PRECIOUS: o/$(MODE)/%.com.ok
+o/$(MODE)/%.com.ok: .PLEDGE = stdio rpath wpath cpath proc fattr inet
 o/$(MODE)/%.com.ok:				\
 		o/$(MODE)/tool/build/runit.com	\
 		o/$(MODE)/tool/build/runitd.com	\
 		o/$(MODE)/%.com
-	@$(COMPILE) -ATEST -tT$@ $^ $(HOSTS)
+	@$(COMPILE) -wATEST -tT$@ $^ $(HOSTS)
@@ -20,84 +20,206 @@ o/%.o: %.s                         ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(
 o/%.o: o/%.s                       ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
 o/%.s: %.S                         ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
 o/%.s: o/%.S                       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/%.i: %.S                         ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
 o/%.o: %.S                         ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
 o/%.o: o/%.S                       ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
-o/%.s: %.i                         ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
-o/%.s: o/%.i                       ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
-o/%.o: %.cc                        ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-o/%.o: o/%.cc                      ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
 o/%.lds: %.lds                     ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
 o/%.inc: %.h                       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) -D__ASSEMBLER__ -P $<
-o/%.h.ok: %.h                      ; @$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
-o/%.okk: %                         ; @$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 o/%.greg.o: %.greg.c               ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
-o/%.zip.o: o/%                     ; @$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<

 o/$(MODE)/%: o/$(MODE)/%.dbg       ; @$(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -S -O binary $< $@
 o/$(MODE)/%.o: %.s                 ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: o/$(MODE)/%.s       ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.s: %.S                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.s: o/$(MODE)/%.S       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: %.c                 ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: %.f                 ; @$(COMPILE) -AOBJECTIFY.f $(OBJECTIFY.f) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: %.F                 ; @$(COMPILE) -AOBJECTIFY.F $(OBJECTIFY.F) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: o/$(MODE)/%.c       ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.ss: %.c                ; @$(COMPILE) -ACOMPILE.c $(COMPILE.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.ss: o/$(MODE)/%.c      ; @$(COMPILE) -AOBJECTIFY.s $(COMPILE.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.i: %.S                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.i: %.c                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.i: %.cc                ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.i: o/$(MODE)/%.c       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.h: %.c                 ; @$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
 o/$(MODE)/%.h: o/$(MODE)/%.c       ; @$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
 o/$(MODE)/%.o: %.S                 ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: o/$(MODE)/%.S       ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.s: %.i                 ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.s: o/$(MODE)/%.i       ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: %.cc                ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: o/$(MODE)/%.cc      ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.lds: %.lds             ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.h.ok: %.h              ; @$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
-o/$(MODE)/%.hh.ok: %.hh            ; @$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
-o/$(MODE)/%.okk: %                 ; @$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
-o/$(MODE)/%.cxx.o: %.c             ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) -xc++ $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: %.greg.c            ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.greg.o: %.greg.c       ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.ansi.o: %.ansi.c       ; @$(COMPILE) -AOBJECTIFY.ansi $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.ansi.o: %.c            ; @$(COMPILE) -AOBJECTIFY.ansi $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.c99.o: %.c99.c         ; @$(COMPILE) -AOBJECTIFY.c99 $(OBJECTIFY.c99.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.c11.o: %.c11.c         ; @$(COMPILE) -AOBJECTIFY.c11 $(OBJECTIFY.c11.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.c2x.o: %.c2x.c         ; @$(COMPILE) -AOBJECTIFY.c2x $(OBJECTIFY.c2x.c) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.initabi.o: %.initabi.c ; @$(COMPILE) -AOBJECTIFY.init $(OBJECTIFY.initabi.c) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.ncabi.o: %.ncabi.c     ; @$(COMPILE) -AOBJECTIFY.nc $(OBJECTIFY.ncabi.c) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.real.o: %.c            ; @$(COMPILE) -AOBJECTIFY.real $(OBJECTIFY.real.c) $(OUTPUT_OPTION) $<

-o/$(MODE)/%.runs: o/$(MODE)/%      ; @$(COMPILE) -ACHECK -tT$@ $< $(TESTARGS)
-o/$(MODE)/%.zip.o: %               ; @$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%-gcc.asm: %.c           ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
-o/$(MODE)/%-gcc.asm: %.cc          ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
-o/$(MODE)/%-clang.asm: %.c         ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
-o/$(MODE)/%-clang.asm: %.cc        ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
-o/$(MODE)/%-clang.asm: CC = $(CLANG)
+o/%.o: %.cc
+	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
+
+o/%.o: o/%.cc
+	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
+
+o/$(MODE)/%.o: %.c
+	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
+	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
+
+o/$(MODE)/%.o: o/$(MODE)/%.c
+	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
+	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
+
+o/$(MODE)/%.o: o/$(MODE)/%.cc
+	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@

 o/%.a:
-	$(file >$@.args,$^)
-	@$(COMPILE) -AARCHIVE -T$@ $(AR) $(ARFLAGS) $@ @$@.args
+	$(file >$(TMPDIR)/$(subst /,_,$@),$^)
+	@$(COMPILE) -AARCHIVE -wT$@ $(AR) $(ARFLAGS) $@ @$(TMPDIR)/$(subst /,_,$@)

 o/%.pkg:
-	$(file >$@.args,$(filter %.o,$^))
-	@$(COMPILE) -APACKAGE -T$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) @$@.args
+	$(file >$(TMPSAFE).args,$(filter %.o,$^))
+	@$(COMPILE) -APACKAGE -wT$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) @$(TMPSAFE).args

 o/$(MODE)/%.pkg:
-	$(file >$@.args,$(filter %.o,$^))
-	@$(COMPILE) -APACKAGE -T$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) @$@.args
+	$(file >$(TMPSAFE).args,$(filter %.o,$^))
+	@$(COMPILE) -APACKAGE -wT$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) @$(TMPSAFE).args

 o/$(MODE)/%.o: %.py o/$(MODE)/third_party/python/pyobj.com
-	@$(COMPILE) -APYOBJ o/$(MODE)/third_party/python/pyobj.com $(PYFLAGS) -o $@ $<
+	@$(COMPILE) -wAPYOBJ o/$(MODE)/third_party/python/pyobj.com $(PYFLAGS) -o $@ $<

 o/$(MODE)/%.pyc: %.py o/$(MODE)/third_party/python/pycomp.com
-	@$(COMPILE) -APYCOMP o/$(MODE)/third_party/python/pycomp.com $(PYCFLAGS) -o $@ $<
+	@$(COMPILE) -wAPYCOMP o/$(MODE)/third_party/python/pycomp.com $(PYCFLAGS) -o $@ $<

 o/$(MODE)/%.lua: %.lua o/$(MODE)/third_party/lua/luac.com
-	@$(COMPILE) -ALUAC o/$(MODE)/third_party/lua/luac.com -s -o $@ $<
+	@$(COMPILE) -wALUAC o/$(MODE)/third_party/lua/luac.com -s -o $@ $<
+
+o/$(MODE)/%.lua.runs: %.lua o/$(MODE)/tool/net/redbean.com
+	@$(COMPILE) -wALUA -tT$@ o/$(MODE)/tool/net/redbean.com $(LUAFLAGS) -i $<
+
+o/$(MODE)/%: o/$(MODE)/%.com o/$(MODE)/tool/build/cp.com o/$(MODE)/tool/build/assimilate.com
+	@$(COMPILE) -wACP -T$@ o/$(MODE)/tool/build/cp.com $< $@
+	@$(COMPILE) -wAASSIMILATE -T$@ o/$(MODE)/tool/build/assimilate.com $@
+
+################################################################################
+# LOCAL UNIT TESTS
+#
+# We always run unit tests as part of the normal `make` invocation. you
+# may override the $(TESTARGS) variable to do things such as enable the
+# benchmarking feature. For example:
+#
+#     TESTARGS = -b
+#
+# May be specified in your ~/.cosmo.mk file. You can also use this to
+# enable things like function tracing. For example:
+#
+#     TESTARGS = ----ftrace
+#     .PLEDGE += prot_exec
+#
+# You could then run a command like:
+#
+#     make -j8 o//test/libc/calls/openbsd_test.com.runs
+#
+# You need PROT_EXEC permission since ftrace morphs the binary. It's
+# also worth mentioning that the pledge.com command can simulate what
+# Landlock Make does:
+#
+#     o//tool/build/pledge.com \
+#       -v. -p 'stdio rpath wpath cpath tty prot_exec' \
+#       o//test/libc/calls/openbsd_test.com \
+#       ----ftrace
+#
+# This is useful in the event a test binary should run by itself, but
+# fails to run beneath Landlock Make. It's also useful sometimes to
+# override the verbosity when running tests:
+#
+#     make V=5 TESTARGS=-b o//test/libc/calls/openbsd_test.com.runs
+#
+# This way, if for some reason a test should fail but calls exit(0),
+# then the stdout/stderr output, which would normally be suppressed,
+# will actually be displayed.
+
+o/$(MODE)/%.runs: o/$(MODE)/%
+	@$(COMPILE) -ACHECK -wtT$@ $< $(TESTARGS)
+
+################################################################################
+# ELF ZIP FILES
+#
+# zipobj.com lets us do fast incremental linking of compressed data.
+# it's nice because if we link a hundred binaries that use the time zone
+# database, then that database only needs to be DEFLATE'd once.
+
+o/%.zip.o: o/%
+	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+
+o/$(MODE)/%.zip.o: %
+	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+
+o/$(MODE)/%.zip.o: %
+	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+
+# an issue with sandboxing arises when creating directory entries in the
+# zip file. we need the trailing slash (e.g. o//foo/.zip.o) but Landlock
+# Make avoids sandboxing directory names that have a trailing slash (so
+# they can be used to watch for deleted files, without creating overly
+# broad unveiling). such rules need to be written more explicitly.
+o/$(MODE)%/.zip.o: %
+	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+
+################################################################################
+# STRICT HEADER CHECKING
+#
+# these rules are unsandboxed since they're already a sandboxing test,
+# and it would be too costly in terms of make latency to have every
+# header file depend on $(HDRS) and $(INCS).
+
+o/%.h.ok: private .UNSANDBOXED = 1
+o/%.h.ok: %.h
+	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
+
+o/$(MODE)/%.h.ok: private .UNSANDBOXED = 1
+o/$(MODE)/%.h.ok: %.h
+	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
+
+o/$(MODE)/%.hh.ok: private .UNSANDBOXED = 1
+o/$(MODE)/%.hh.ok: %.hh
+	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
+
+o/%.okk: .UNSANDBOXED = 1
+o/%.okk: %
+	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
+
+o/$(MODE)/%.okk: private .UNSANDBOXED = 1
+o/$(MODE)/%.okk: %
+	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
+
+################################################################################
+# EXECUTABLE HELPERS
+
+MAKE_OBJCOPY =					\
+	$(COMPILE) -AOBJCOPY -T$@		\
+	$(OBJCOPY) -S -O binary $< $@
+
+MAKE_SYMTAB_CREATE =				\
+	$(COMPILE) -wASYMTAB			\
+	o/$(MODE)/tool/build/symtab.com		\
+	-o $(TMPSAFE)/.symtab			\
+	$<
+
+MAKE_SYMTAB_ZIP =				\
+	$(COMPILE) -AZIP -T$@			\
+	o/$(MODE)/third_party/zip/zip.com	\
+	-b$(TMPDIR)				\
+	-9qj					\
+	$@					\
+	$(TMPSAFE)/.symtab
+
+################################################################################
+# EMACS ASSEMBLY GENERATION
+
+o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-gcc.asm: %.c
+	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
+
+o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-gcc.asm: %.cc
+	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
+
+o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-clang.asm: %.c
+	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
+
+o/$(MODE)/%-clang.asm: CC = $(CLANG)
+o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-clang.asm: %.cc
+	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
@@ -31,8 +31,7 @@ if [ ! -f /proc/sys/fs/binfmt_misc/status ]; then
  exit 0
 fi

-STATUS="$(build/bootstrap/apetest.com)"
-if [ x"$STATUS" != xsuccess ]; then
+if ! build/bootstrap/echo.com -n; then
  cat <<'EOF' >&2

 ERROR
@@ -40,11 +40,11 @@ $(DSP_BMP_A).pkg:				\
 		$(foreach x,$(DSP_BMP_A_DIRECTDEPS),$($(x)_A).pkg)

 o/$(MODE)/dsp/bmp/float2short.o			\
-o/$(MODE)/dsp/bmp/scalevolume.o:		\
+o/$(MODE)/dsp/bmp/scalevolume.o: private	\
 		OVERRIDE_CFLAGS +=		\
 			$(MATHEMATICAL)

-o/tiny/dsp/bmp/scalevolume.o:			\
+o/tiny/dsp/bmp/scalevolume.o: private		\
 		OVERRIDE_CFLAGS +=		\
 			-Os

@@ -47,15 +47,15 @@ o/$(MODE)/dsp/core/c1331.o			\
 o/$(MODE)/dsp/core/magikarp.o			\
 o/$(MODE)/dsp/core/c93654369.o			\
 o/$(MODE)/dsp/core/float2short.o		\
-o/$(MODE)/dsp/core/scalevolume.o:		\
+o/$(MODE)/dsp/core/scalevolume.o: private	\
 		OVERRIDE_CFLAGS +=		\
 			$(MATHEMATICAL)

-o/tiny/dsp/core/scalevolume.o:			\
+o/tiny/dsp/core/scalevolume.o: private		\
 		OVERRIDE_CFLAGS +=		\
 			-Os

-o/$(MODE)/dsp/core/det3.o:			\
+o/$(MODE)/dsp/core/det3.o: private		\
 		OVERRIDE_CFLAGS +=		\
 			-ffast-math

@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/core.h"
-#include "libc/bits/bits.h"
-#include "libc/bits/safemacros.internal.h"
+#include "libc/intrin/bits.h"
+#include "libc/intrin/safemacros.internal.h"
 #include "libc/limits.h"

 /**
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/core.h"
-#include "libc/bits/likely.h"
+#include "libc/intrin/likely.h"

 /**
 * Expands μ-Law coded to audio sample.
@@ -37,10 +37,10 @@ This library provides several interfaces to load, demux and decode MPEG video
 and audio data. A high-level API combines the demuxer, video & audio decoders
 in an easy to use wrapper.

-Lower-level APIs for accessing the demuxer, video decoder and audio decoder, 
+Lower-level APIs for accessing the demuxer, video decoder and audio decoder,
 as well as providing different data sources are also available.

-Interfaces are written in an object orientet style, meaning you create object 
+Interfaces are written in an object orientet style, meaning you create object
 instances via various different constructor functions (plm_*create()),
 do some work on them and later dispose them via plm_*destroy().

@@ -51,11 +51,11 @@ plm_video_*  -- the MPEG1 Video ("mpeg1") decoder
 plm_audio_*  -- the MPEG1 Audio Layer II ("mp2") decoder


-This library uses malloc(), realloc() and free() to manage memory. Typically 
+This library uses malloc(), realloc() and free() to manage memory. Typically
 all allocation happens up-front when creating the interface. However, the
 default buffer size may be too small for certain inputs. In these cases plmpeg
 will realloc() the buffer with a larger size whenever needed. You can configure
-the default buffer size by defining PLM_BUFFER_DEFAULT_SIZE *before* 
+the default buffer size by defining PLM_BUFFER_DEFAULT_SIZE *before*
 including this library.

 With the high-level interface you have two options to decode video & audio:
@@ -85,7 +85,7 @@ mat4 rec601 = mat4(
 gl_FragColor = vec4(y, cb, cr, 1.0) * rec601;

 Audio data is decoded into a struct with either one single float array with the
-samples for the left and right channel interleaved, or if the 
+samples for the left and right channel interleaved, or if the
 PLM_AUDIO_SEPARATE_CHANNELS is defined *before* including this library, into
 two separate float arrays - one for each channel.

@@ -67,7 +67,7 @@ plm_buffer_t *plm_buffer_create_with_file(FILE *fh, int close_when_done) {

 plm_buffer_t *plm_buffer_create_with_memory(unsigned char *bytes, size_t length, int free_when_done) {
 	plm_buffer_t *b;
-	b = memalign(alignof(plm_buffer_t), sizeof(plm_buffer_t));
+	b = memalign(_Alignof(plm_buffer_t), sizeof(plm_buffer_t));
 	memset(b, 0, sizeof(plm_buffer_t));
 	b->capacity = length;
 	b->length = length;
@@ -79,7 +79,7 @@ plm_buffer_t *plm_buffer_create_with_memory(unsigned char *bytes, size_t length,

 plm_buffer_t * plm_buffer_create_with_capacity(size_t capacity) {
 	plm_buffer_t *b;
-	b = memalign(alignof(plm_buffer_t), sizeof(plm_buffer_t));
+	b = memalign(_Alignof(plm_buffer_t), sizeof(plm_buffer_t));
 	memset(b, 0, sizeof(plm_buffer_t));
 	b->capacity = capacity;
 	b->free_when_done = true;
@@ -115,8 +115,8 @@ plm_packet_t *plm_demux_decode(plm_demux_t *self) {
 	do {
 		code = plm_buffer_next_start_code(self->buffer);
 		if (
-			code == PLM_DEMUX_PACKET_VIDEO_1 || 
-			code == PLM_DEMUX_PACKET_PRIVATE || 
+			code == PLM_DEMUX_PACKET_VIDEO_1 ||
+			code == PLM_DEMUX_PACKET_PRIVATE ||
 			(code >= PLM_DEMUX_PACKET_AUDIO_1 && code <= PLM_DEMUX_PACKET_AUDIO_4)
 		) {
 			return plm_demux_decode_packet(self, code);
@@ -273,11 +273,11 @@ typedef plm_audio_t plm_audio_t;
 int plm_audio_decode_header(plm_audio_t *self);
 void plm_audio_decode_frame(plm_audio_t *self);
 const plm_quantizer_spec_t *plm_audio_read_allocation(plm_audio_t *self, int sb, int tab3);
-void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part); 
+void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part);
 void plm_audio_matrix_transform(int s[32][3], int ss, float *d, int dp);

 plm_audio_t *plm_audio_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {
-	plm_audio_t *self = (plm_audio_t *)memalign(alignof(plm_audio_t), sizeof(plm_audio_t));
+	plm_audio_t *self = (plm_audio_t *)memalign(_Alignof(plm_audio_t), sizeof(plm_audio_t));
 	memset(self, 0, sizeof(plm_audio_t));

 	self->samples.count = PLM_AUDIO_SAMPLES_PER_FRAME;
@@ -345,7 +345,7 @@ plm_samples_t *plm_audio_decode(plm_audio_t *self) {
 	self->samples.time = self->time;

 	self->samples_decoded += PLM_AUDIO_SAMPLES_PER_FRAME;
-	self->time = (double)self->samples_decoded / 
+	self->time = (double)self->samples_decoded /
 		(double)PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];

 	return &self->samples;
@@ -402,7 +402,7 @@ int plm_audio_decode_header(plm_audio_t *self) {
 		plm_buffer_skip(self->buffer, 16);
 	}

-	// Compute frame size, check if we have enough data to decode the whole 
+	// Compute frame size, check if we have enough data to decode the whole
 	// frame.
 	int bitrate = PLM_AUDIO_BIT_RATE[self->bitrate_index];
 	int samplerate = PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
@@ -561,7 +561,7 @@ void plm_audio_decode_frame(plm_audio_t *self) {
 						}
 					#else
 						for (int j = 0; j < 32; j++) {
-							self->samples.interleaved[((out_pos + j) << 1) + ch] = 
+							self->samples.interleaved[((out_pos + j) << 1) + ch] =
 								self->U[j] / 2147418112.0f;
 						}
 					#endif
@@ -37,8 +37,7 @@ DSP_MPEG_A_DIRECTDEPS =				\
 	LIBC_STUBS				\
 	LIBC_SYSV				\
 	LIBC_TIME				\
-	LIBC_TINYMATH				\
-	LIBC_UNICODE
+	LIBC_TINYMATH

 DSP_MPEG_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x))))
@@ -51,13 +50,10 @@ $(DSP_MPEG_A).pkg:				\
 		$(DSP_MPEG_A_OBJS)		\
 		$(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x)_A).pkg)

-o/$(MODE)/dsp/mpeg/clamp4int256-k8.o:		\
+o/$(MODE)/dsp/mpeg/clamp4int256-k8.o: private	\
 		OVERRIDE_CFLAGS +=		\
 			-Os

-#o/$(MODE)/dsp/mpeg/macroblock.o:		\
-		CC = $(CLANG)
-
 DSP_MPEG_LIBS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)))
 DSP_MPEG_SRCS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_SRCS))
 DSP_MPEG_HDRS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_HDRS))
@@ -32,7 +32,7 @@
 #include "dsp/mpeg/idct.h"
 #include "dsp/mpeg/mpeg.h"
 #include "dsp/mpeg/video.h"
-#include "libc/bits/initializer.internal.h"
+#include "libc/intrin/initializer.internal.h"
 #include "libc/fmt/conv.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
@@ -94,9 +94,9 @@ plm_t *plm_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {

 	self->demux = plm_demux_create(buffer, destroy_when_done);

-	// In theory we should check plm_demux_get_num_video_streams() and 
+	// In theory we should check plm_demux_get_num_video_streams() and
 	// plm_demux_get_num_audio_streams() here, but older files typically
-	// do not specify these correcly. So we just assume we have a video and
+	// do not specify these correctly. So we just assume we have a video and
 	// audio stream and create the decoders.

 	self->video_packet_type = PLM_DEMUX_PACKET_VIDEO_1;
@@ -159,7 +159,7 @@ double plm_get_framerate(plm_t *self) {

 int plm_get_num_audio_streams(plm_t *self) {
 	// Some files do not specify the number of audio streams in the system header.
-	// If the reported number of streams is 0, we check if we have a samplerate, 
+	// If the reported number of streams is 0, we check if we have a samplerate,
 	// indicating at least one audio stream.
 	int num_streams = plm_demux_get_num_audio_streams(self->demux);
 	return num_streams == 0 && plm_get_samplerate(self) ? 1 : num_streams;
@@ -40,7 +40,7 @@ asm(".include \"libc/disclaimer.inc\"");
 * @see YCbCr2RGB() in tool/viz/lib/ycbcr2rgb.c
 */
 void plm_frame_to_rgb(plm_frame_t *frame, uint8_t *rgb) {
-  // Chroma values are the same for each block of 4 pixels, so we proccess
+  // Chroma values are the same for each block of 4 pixels, so we process
  // 2 lines at a time, 2 neighboring pixels each.
  int w = frame->y.width, w2 = w >> 1;
  int y_index1 = 0, y_index2 = w, y_next_2_lines = w + (w - frame->width);
@@ -21,14 +21,14 @@
 #include "dsp/core/ituround.h"
 #include "dsp/core/q.h"
 #include "dsp/core/twixt8.h"
+#include "libc/intrin/bsr.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
 #include "libc/math.h"
+#include "libc/mem/gc.internal.h"
 #include "libc/mem/mem.h"
-#include "libc/nexgen32e/bsr.h"
-#include "libc/runtime/gc.internal.h"
 #include "libc/str/str.h"
 #include "libc/testlib/testlib.h"
 #include "libc/x/x.h"
@@ -203,8 +203,8 @@ void *Gyarados(long dyw, long dxw, int dst[dyw][dxw], long syw, long sxw,
      CHECK_LE(sxn, sxw);
      CHECK_LE(dyn, dyw);
      CHECK_LE(dxn, dxw);
-      CHECK_LT(bsrl(syn) + bsrl(sxn), 32);
-      CHECK_LT(bsrl(dyn) + bsrl(dxn), 32);
+      CHECK_LT(_bsrl(syn) + _bsrl(sxn), 32);
+      CHECK_LT(_bsrl(dyn) + _bsrl(dxn), 32);
      CHECK_LE(dyw, 0x7fff);
      CHECK_LE(dxw, 0x7fff);
      CHECK_LE(syw, 0x7fff);
@@ -51,7 +51,7 @@ $(DSP_SCALE_A).pkg:				\
 o/$(MODE)/dsp/scale/cdecimate2xuint8x8.o	\
 o/$(MODE)/dsp/scale/gyarados.o			\
 o/$(MODE)/dsp/scale/magikarp.o			\
-o/$(MODE)/dsp/scale/scale.o:			\
+o/$(MODE)/dsp/scale/scale.o: private		\
 		OVERRIDE_CFLAGS +=		\
 			$(MATHEMATICAL)

@@ -30,7 +30,7 @@
 * @see ttyconfig(), ttyrestore()
 */
 int ttyconfig(int ttyfd, ttyconf_f fn, int64_t arg,
-              const struct termios *opt_out_oldconf) {
+              struct termios *opt_out_oldconf) {
  struct termios conf[2];
  if (tcgetattr(ttyfd, &conf[0]) != -1 &&
      fn(memcpy(&conf[1], &conf[0], sizeof(conf[0])), arg) != -1 &&
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/tty.h"
-#include "libc/bits/pushpop.h"
+#include "libc/intrin/pushpop.h"
 #include "libc/dce.h"
 #include "libc/log/internal.h"
 #include "libc/log/log.h"
@@ -17,14 +17,17 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/tty.h"
-#include "libc/bits/safemacros.internal.h"
-#include "libc/bits/weaken.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/termios.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
 #include "libc/fmt/fmt.h"
+#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/weaken.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sock/sock.h"
+#include "libc/sock/struct/pollfd.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/poll.h"
 #include "libc/sysv/errfuns.h"
@@ -80,10 +83,11 @@ int ttyident(struct TtyIdent *ti, int ttyinfd, int ttyoutfd) {
      if (ttyident_probe(ti, ttyinfd, ttyoutfd, "\e[>c") != -1) {
        rc = 0;
        memset(&outer, 0, sizeof(outer));
-        if (ti->id == 83 /* GNU Screen */ && (ti->next || weaken(malloc)) &&
+        if (ti->id == 83 /* GNU Screen */ && (ti->next || _weaken(malloc)) &&
            ttyident_probe(&outer, ttyinfd, ttyoutfd, "\eP\e[>c\e\\") != -1 &&
-            (ti->next = (ti->next ? ti->next
-                                  : weaken(malloc)(sizeof(struct TtyIdent))))) {
+            (ti->next =
+                 (ti->next ? ti->next
+                           : _weaken(malloc)(sizeof(struct TtyIdent))))) {
          memcpy(ti->next, &outer, sizeof(outer));
        } else {
          free_s(&ti->next);
@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_DSP_TTY_INTERNAL_H_
 #define COSMOPOLITAN_DSP_TTY_INTERNAL_H_
 #include "dsp/tty/ttyrgb.h"
-#include "libc/bits/xmmintrin.internal.h"
+#include "libc/intrin/xmmintrin.internal.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_

@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/itoa8.h"
-#include "libc/bits/bits.h"
-#include "libc/bits/initializer.internal.h"
+#include "libc/intrin/bits.h"
+#include "libc/intrin/initializer.internal.h"
 #include "libc/str/str.h"

 struct Itoa8 kItoa8;
@@ -2,8 +2,8 @@
 #define DSP_TTY_QUANT_H_
 #include "dsp/tty/ttyrgb.h"
 #include "libc/assert.h"
-#include "libc/bits/bits.h"
-#include "libc/bits/xmmintrin.internal.h"
+#include "libc/intrin/bits.h"
+#include "libc/intrin/xmmintrin.internal.h"
 #include "libc/limits.h"
 #include "libc/str/str.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
@@ -19,7 +19,7 @@
 #include "dsp/core/core.h"
 #include "dsp/tty/quant.h"
 #include "libc/assert.h"
-#include "libc/bits/initializer.internal.h"
+#include "libc/intrin/initializer.internal.h"
 #include "libc/limits.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/quant.h"
-#include "libc/bits/xmmintrin.internal.h"
+#include "libc/intrin/xmmintrin.internal.h"

 struct TtyRgb rgb2ttyf2i_(__m128 rgb) {
  __v4si i4;
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/tty.h"
-#include "libc/alg/arraylist2.internal.h"
-#include "libc/runtime/gc.internal.h"
+#include "libc/mem/arraylist2.internal.h"
+#include "libc/mem/gc.internal.h"
 #include "libc/x/x.h"

 /* TODO(jart): DELETE */
@@ -44,7 +44,7 @@ int ttysendtitle(int, const char *, const struct TtyIdent *);
 int ttyident(struct TtyIdent *, int, int);
 void ttyidentclear(struct TtyIdent *);
 char *ttydescribe(char *, size_t, const struct TtyIdent *);
-int ttyconfig(int, ttyconf_f, int64_t, const struct termios *);
+int ttyconfig(int, ttyconf_f, int64_t, struct termios *);
 int ttyrestore(int, const struct termios *);
 int ttysetrawdeadline(struct termios *, int64_t);
 int ttysetrawmode(struct termios *, int64_t);
@@ -25,7 +25,6 @@ DSP_TTY_A_CHECKS =				\

 DSP_TTY_A_DIRECTDEPS =				\
 	DSP_CORE				\
-	LIBC_ALG				\
 	LIBC_CALLS				\
 	LIBC_FMT				\
 	LIBC_INTRIN				\
@@ -41,8 +40,7 @@ DSP_TTY_A_DIRECTDEPS =				\
 	LIBC_SYSV				\
 	LIBC_TINYMATH				\
 	LIBC_TIME				\
-	LIBC_X					\
-	LIBC_UNICODE
+	LIBC_X

 DSP_TTY_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(DSP_TTY_A_DIRECTDEPS),$($(x))))
@@ -55,8 +53,8 @@ $(DSP_TTY_A).pkg:				\
 		$(DSP_TTY_A_OBJS)		\
 		$(foreach x,$(DSP_TTY_A_DIRECTDEPS),$($(x)_A).pkg)

-o/$(MODE)/dsp/tty/ttyraster.o:			\
-		OVERRIDE_CFLAGS +=		\
+o/$(MODE)/dsp/tty/ttyraster.o: private		\
+		OVERRIDE_CFLAGS +=	\
 			$(MATHEMATICAL)

 DSP_TTY_LIBS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)))
@@ -18,7 +18,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/tty.h"
-#include "libc/alg/alg.h"
+#include "libc/mem/alg.h"
 #include "libc/nexgen32e/nexgen32e.h"
 #include "libc/str/str.h"

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/itoa8.h"
 #include "dsp/tty/tty.h"
-#include "libc/bits/safemacros.internal.h"
+#include "libc/intrin/safemacros.internal.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/internal.h"
 #include "dsp/tty/quant.h"
-#include "libc/bits/initializer.internal.h"
+#include "libc/intrin/initializer.internal.h"
 #include "libc/dce.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
@@ -22,8 +22,8 @@
 #include "dsp/tty/ttyrgb.h"
 #include "dsp/tty/windex.h"
 #include "libc/assert.h"
-#include "libc/bits/bits.h"
-#include "libc/bits/safemacros.internal.h"
+#include "libc/intrin/bits.h"
+#include "libc/intrin/safemacros.internal.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
@@ -775,7 +775,10 @@ char *ttyraster(char *v, const struct TtyRgb *c, size_t yn, size_t xn,
  struct Glyph glyph;
  struct TtyRgb chun[4], lastchunk[4];
  for (y = 0; y < yn; y += 2, c += xn) {
-    if (y) *v++ = '\r', *v++ = '\n';
+    if (y) {
+      v = stpcpy(v, "\e[0m\r\n");
+      v = setbgfg(v, bg, fg);
+    }
    for (x = 0; x < xn; x += 2, c += 2) {
      CopyChunk(chun, c, xn);
      if (ttyquant()->alg == kTtyQuantTrue) {
@@ -795,6 +798,6 @@ char *ttyraster(char *v, const struct TtyRgb *c, size_t yn, size_t xn,
      memcpy(lastchunk, chun, sizeof(chun));
    }
  }
-  *v = '\0';
+  v = stpcpy(v, "\e[0m");
  return v;
 }
@@ -22,11 +22,10 @@
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/siginfo.h"
 #include "libc/calls/termios.h"
-#include "libc/calls/typedef/sigaction_f.h"
 #include "libc/calls/ucontext.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
-#include "libc/runtime/gc.internal.h"
+#include "libc/mem/gc.internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/fileno.h"
@@ -34,6 +33,7 @@
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/x/x.h"
+#include "libc/x/xsigaction.h"

 /* TODO(jart): DELETE */

@@ -98,8 +98,8 @@ static relegated void ttyraw_onsig(int sig, struct siginfo *info,
  }
  for (i = 0; i < ARRAYLEN(g_ttyraw.sigs); ++i) {
    if (g_ttyraw.sigs[i] == sig) {
-      if (g_ttyraw.next[i] != SIG_IGN) {
-        if (g_ttyraw.next[i] != SIG_DFL) {
+      if (g_ttyraw.next[i] != (void *)SIG_IGN) {
+        if (g_ttyraw.next[i] != (void *)SIG_DFL) {
          if (g_ttyraw.next[i]) {
            g_ttyraw.next[i](sig, info, ctx);
          }
@@ -118,7 +118,7 @@ static textstartup void ttyraw_initsig(int sig, unsigned flags, unsigned mask) {
  struct sigaction old;
  g_ttyraw.next[i] = xsigaction(sig, ttyraw_onsig, flags, mask, &old) != -1
                         ? old.sa_sigaction
-                         : SIG_DFL;
+                         : (void *)SIG_DFL;
  g_ttyraw.sigs[i++] = sig;
 }

@@ -21,6 +21,7 @@
 #include "libc/calls/termios.h"
 #include "libc/errno.h"
 #include "libc/sock/sock.h"
+#include "libc/sock/struct/pollfd.h"
 #include "libc/sysv/consts/poll.h"
 #include "libc/sysv/consts/termios.h"

@@ -10,7 +10,7 @@
 #include "libc/log/log.h"

 /**
- * Automatically launchs GDB Debugger TUI during crash.
+ * Automatically launches GDB Debugger TUI during crash.
 *
 * Run the following inside a terminal:
 *
@@ -7,7 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/bits/bits.h"
+#include "libc/intrin/bits.h"
 #include "libc/dce.h"
 #include "libc/log/log.h"
 #include "libc/runtime/runtime.h"
@@ -7,7 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/bits/bits.h"
+#include "libc/intrin/bits.h"
 #include "libc/dce.h"
 #include "libc/log/log.h"
 #include "libc/mem/mem.h"
@@ -7,7 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/bits/bits.h"
+#include "libc/intrin/bits.h"
 #include "libc/dce.h"
 #include "libc/log/log.h"
 #include "libc/mem/mem.h"
@@ -0,0 +1,41 @@
+#if 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/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/calls/struct/timespec.h"
+#include "libc/stdio/stdio.h"
+#include "libc/time/time.h"
+
+/**
+ * @fileoverview clock() function demo
+ */
+
+int main(int argc, char *argv[]) {
+  unsigned long i;
+  volatile unsigned long x;
+  struct timespec now, start, next, interval;
+  printf("hammering the cpu...\n");
+  next = start = _timespec_mono();
+  interval = _timespec_frommillis(500);
+  next = _timespec_add(next, interval);
+  for (;;) {
+    for (i = 0;; ++i) {
+      x *= 7;
+      if (!(i % 256)) {
+        now = _timespec_mono();
+        if (_timespec_gte(now, next)) {
+          break;
+        }
+      }
+    }
+    next = _timespec_add(next, interval);
+    printf("consumed %10g seconds monotonic time and %10g seconds cpu time\n",
+           _timespec_tonanos(_timespec_sub(now, start)) / 1000000000.,
+           (double)clock() / CLOCKS_PER_SEC);
+  }
+}
@@ -0,0 +1,56 @@
+#if 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/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/calls/struct/timespec.h"
+#include "libc/errno.h"
+#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/clock.h"
+
+int n;
+int shown[64];
+
+void show(int clock) {
+  int i;
+  struct timespec ts;
+  if (clock == 127) return;
+  for (i = 0; i < n; ++i) {
+    if (shown[i] == clock) {
+      return;
+    }
+  }
+  shown[n++] = clock;
+  if (clock_getres(clock, &ts) != -1) {
+    kprintf("%s %'ld ns\n", DescribeClockName(clock), _timespec_tonanos(ts));
+  } else {
+    kprintf("%s %s\n", DescribeClockName(clock), _strerrno(errno));
+  }
+}
+
+int main(int argc, char *argv[]) {
+  show(CLOCK_REALTIME);
+  show(CLOCK_REALTIME_FAST);
+  show(CLOCK_REALTIME_PRECISE);
+  show(CLOCK_MONOTONIC);
+  show(CLOCK_MONOTONIC_RAW);
+  show(CLOCK_MONOTONIC_FAST);
+  show(CLOCK_MONOTONIC_PRECISE);
+  show(CLOCK_PROCESS_CPUTIME_ID);
+  show(CLOCK_THREAD_CPUTIME_ID);
+  show(CLOCK_PROF);
+  show(CLOCK_BOOTTIME);
+  show(CLOCK_REALTIME_ALARM);
+  show(CLOCK_BOOTTIME_ALARM);
+  show(CLOCK_TAI);
+  show(CLOCK_UPTIME);
+  show(CLOCK_UPTIME_PRECISE);
+  show(CLOCK_UPTIME_FAST);
+  show(CLOCK_SECOND);
+}
@@ -8,11 +8,12 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/assert.h"
+#include "libc/calls/calls.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/log/check.h"
 #include "libc/mem/mem.h"
-#include "libc/runtime/gc.internal.h"
+#include "libc/mem/gc.internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
@@ -9,18 +9,21 @@
 #endif
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/dirent.h"
+#include "libc/calls/struct/rusage.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/timespec.h"
+#include "libc/errno.h"
 #include "libc/fmt/fmt.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/kprintf.h"
+#include "libc/log/appendresourcereport.internal.h"
 #include "libc/log/internal.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
+#include "libc/mem/mem.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
-#include "libc/stdio/append.internal.h"
+#include "libc/stdio/append.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/clock.h"
@@ -151,7 +154,7 @@ int main(int argc, char *argv[]) {
  while ((line = linenoiseWithHistory(prompt, "cmd"))) {
    n = 0;
    start = line;
-    if (startswith(start, "time ")) {
+    if (_startswith(start, "time ")) {
      timeit = true;
      start += 5;
    } else {
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/bits/safemacros.internal.h"
+#include "libc/intrin/safemacros.internal.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"

@@ -8,6 +8,7 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/calls/calls.h"
+#include "libc/calls/struct/sigset.h"
 #include "libc/log/log.h"
 #include "libc/stdio/stdio.h"

@@ -23,7 +24,7 @@
 *
 * On supported platforms, this will cause GDB to automatically attach.
 * The nice thing about this, is you can start stepping through your
- * code at the precice instruction where the interrupt happened. See
+ * code at the precise instruction where the interrupt happened. See
 * `libc/log/attachdebugger.c` to see how it works.
 *
 * If you wish to suppress the auto-GDB behavior, then:
@@ -7,7 +7,6 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/bits/safemacros.internal.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/dce.h"
@@ -15,15 +14,16 @@
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/fmt.h"
+#include "libc/intrin/safemacros.internal.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
-#include "libc/rand/rand.h"
-#include "libc/runtime/gc.h"
+#include "libc/mem/gc.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sock/goodsocket.internal.h"
 #include "libc/sock/sock.h"
-#include "libc/stdio/append.internal.h"
+#include "libc/stdio/append.h"
+#include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/slice.h"
 #include "libc/str/str.h"
@@ -40,6 +40,7 @@
 #include "libc/sysv/consts/tcp.h"
 #include "libc/time/struct/tm.h"
 #include "libc/x/x.h"
+#include "libc/x/xsigaction.h"
 #include "net/http/http.h"
 #include "net/http/url.h"
 #include "net/https/https.h"
@@ -182,7 +183,7 @@ int main(int argc, char *argv[]) {
  struct Url url;
  char *host, *port;
  bool usessl = false;
-  _gc(ParseUrl(urlarg, -1, &url));
+  _gc(ParseUrl(urlarg, -1, &url, kUrlPlus));
  _gc(url.params.p);
  if (url.scheme.n) {
    if (url.scheme.n == 5 && !memcasecmp(url.scheme.p, "https", 5)) {
@@ -8,7 +8,8 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/log/log.h"
-#include "libc/runtime/gc.internal.h"
+#include "libc/mem/gc.internal.h"
+#include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/x/x.h"
 #include "net/http/escape.h"
@@ -7,9 +7,9 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/runtime/gc.h"
+#include "libc/mem/gc.h"
 #include "libc/stdio/stdio.h"
-#include "libc/x/x.h"
+#include "libc/x/xiso8601.h"

 /**
 * @fileoverview ISO-8601 international high-precision timestamp printer.
@@ -8,10 +8,12 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/assert.h"
+#include "libc/calls/calls.h"
 #include "libc/errno.h"
 #include "libc/mem/mem.h"
-#include "libc/runtime/gc.internal.h"
+#include "libc/mem/gc.internal.h"
 #include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
 #include "third_party/zlib/zlib.h"

 #define CHUNK 32768
@@ -8,7 +8,7 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/mem/mem.h"
-#include "libc/runtime/gc.h"
+#include "libc/mem/gc.h"
 #include "libc/stdio/stdio.h"

 /**
@@ -0,0 +1,42 @@
+#if 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/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/macros.internal.h"
+#include "libc/stdio/stdio.h"
+
+typedef float xmm_t __attribute__((__vector_size__(16), __aligned__(4)));
+
+float dotvector(float *x, float *y, size_t n) {
+  size_t i;
+  float res;
+  if (n > 64) {
+    return dotvector(x, y, n / 2) + dotvector(x + n / 2, y + n / 2, n - n / 2);
+  }
+  for (res = i = 0; i < n; ++i) {
+    if (i + 4 <= n) {
+      xmm_t res4 = (xmm_t){0};
+      do {
+        res4 += *(xmm_t *)(x + i) * *(xmm_t *)(y + i);
+      } while ((i += 4) + 4 <= n);
+      res += res4[0];
+      res += res4[1];
+      res += res4[2];
+      res += res4[3];
+      continue;
+    }
+    res += x[i] * y[i];
+  }
+  return res;
+}
+
+int main(int argc, char *argv[]) {
+  float x[] = {1, 2, 3, 4, 1, 2, 3, 4};
+  float y[] = {4, 3, 2, 1, 1, 2, 3, 4};
+  printf("%g\n", dotvector(x, y, ARRAYLEN(x)));
+}
@@ -36,16 +36,12 @@ EXAMPLES_COMS =									\

 EXAMPLES_BINS =									\
 	$(EXAMPLES_COMS)							\
-	$(EXAMPLES_COMS:%=%.dbg)						\
-	o/$(MODE)/examples/life-nomod.com					\
-	o/$(MODE)/examples/life-classic.com
+	$(EXAMPLES_COMS:%=%.dbg)

 EXAMPLES_DIRECTDEPS =								\
 	DSP_CORE								\
 	DSP_SCALE								\
 	DSP_TTY									\
-	LIBC_ALG								\
-	LIBC_BITS								\
 	LIBC_CALLS								\
 	LIBC_DNS								\
 	LIBC_FMT								\
@@ -59,7 +55,6 @@ EXAMPLES_DIRECTDEPS =								\
 	LIBC_NT_USER32								\
 	LIBC_NT_WS2_32								\
 	LIBC_NT_ADVAPI32							\
-	LIBC_RAND								\
 	LIBC_RUNTIME								\
 	LIBC_SOCK								\
 	LIBC_STDIO								\
@@ -71,13 +66,14 @@ EXAMPLES_DIRECTDEPS =								\
 	LIBC_THREAD								\
 	LIBC_TIME								\
 	LIBC_TINYMATH								\
-	LIBC_UNICODE								\
+	LIBC_VGA								\
 	LIBC_X									\
 	LIBC_ZIPOS								\
 	NET_HTTP								\
 	NET_HTTPS								\
 	THIRD_PARTY_COMPILER_RT							\
 	THIRD_PARTY_DLMALLOC							\
+	THIRD_PARTY_DOUBLECONVERSION						\
 	THIRD_PARTY_GDTOA							\
 	THIRD_PARTY_GETOPT							\
 	THIRD_PARTY_LIBCXX							\
@@ -85,6 +81,8 @@ EXAMPLES_DIRECTDEPS =								\
 	THIRD_PARTY_LUA								\
 	THIRD_PARTY_MBEDTLS							\
 	THIRD_PARTY_MUSL							\
+	THIRD_PARTY_NSYNC							\
+	THIRD_PARTY_NSYNC_MEM							\
 	THIRD_PARTY_QUICKJS							\
 	THIRD_PARTY_STB								\
 	THIRD_PARTY_XED								\
@@ -99,7 +97,7 @@ o/$(MODE)/examples/examples.pkg:						\
 		$(EXAMPLES_OBJS)						\
 		$(foreach x,$(EXAMPLES_DIRECTDEPS),$($(x)_A).pkg)

-o/$(MODE)/examples/unbourne.o:							\
+o/$(MODE)/examples/unbourne.o: private						\
 		OVERRIDE_CPPFLAGS +=						\
 			-DSTACK_FRAME_UNLIMITED					\
 			-fpie
@@ -145,18 +143,20 @@ o/$(MODE)/examples/nesemu1.com.dbg:						\
 		$(EXAMPLES_BOOTLOADER)
 	@$(APELINK)

-o/$(MODE)/examples/nesemu1.com:							\
-		o/$(MODE)/examples/nesemu1.com.dbg				\
-		o/$(MODE)/third_party/zip/zip.com				\
-		o/$(MODE)/tool/build/symtab.com
-	@$(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -S -O binary $< $@
-	@$(COMPILE) -ASYMTAB o/$(MODE)/tool/build/symtab.com			\
-		-o o/$(MODE)/examples/.nesemu1/.symtab $<
-	@$(COMPILE) -AZIP -T$@ o/$(MODE)/third_party/zip/zip.com -9qj $@	\
-		o/$(MODE)/examples/.nesemu1/.symtab
+o/$(MODE)/examples/picol.o: private				\
+		OVERRIDE_CPPFLAGS +=				\
+			-DSTACK_FRAME_UNLIMITED

-o/$(MODE)/examples/nesemu1.o: QUOTA += -M512m
-o/$(MODE)/usr/share/dict/words.zip.o: ZIPOBJ_FLAGS += -C2
+o/$(MODE)/examples/picol.com.dbg:				\
+		$(EXAMPLES_DEPS)				\
+		o/$(MODE)/examples/picol.o			\
+		o/$(MODE)/examples/examples.pkg			\
+		$(CRT)						\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
+o/$(MODE)/examples/nesemu1.o: private QUOTA += -M512m
+o/$(MODE)/usr/share/dict/words.zip.o: private ZIPOBJ_FLAGS += -C2

 $(EXAMPLES_OBJS): examples/examples.mk

@@ -166,34 +166,6 @@ o/$(MODE)/usr/share/dict/words:							\
 	@$(MKDIR) $(@D)
 	@o/$(MODE)/tool/build/gzip.com $(ZFLAGS) -cd <$< >$@

-################################################################################
-# binaries for execve_test.com
-
-o/$(MODE)/examples/life-nomod.com.zip.o: o/$(MODE)/examples/life-nomod.com
-	@$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) -B $(OUTPUT_OPTION) $<
-
-o/$(MODE)/examples/life-classic.com.zip.o: o/$(MODE)/examples/life-classic.com
-	@$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) -B $(OUTPUT_OPTION) $<
-
-o/$(MODE)/examples/pylife/pylife.com.zip.o: o/$(MODE)/examples/pylife/pylife.com
-	@$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) -B $(OUTPUT_OPTION) $<
-
-o/$(MODE)/examples/life-classic.com.dbg:					\
-		$(EXAMPLES_DEPS)						\
-		o/$(MODE)/examples/life.o					\
-		o/$(MODE)/examples/examples.pkg					\
-		$(CRT)								\
-		$(APE)
-	@$(APELINK)
-
-o/$(MODE)/examples/life-nomod.com.dbg:						\
-		$(EXAMPLES_DEPS)						\
-		o/$(MODE)/examples/life.o					\
-		o/$(MODE)/examples/examples.pkg					\
-		$(CRT)								\
-		$(APE_NO_MODIFY_SELF)
-	@$(APELINK)
-
 ################################################################################

 .PHONY: o/$(MODE)/examples
@@ -8,21 +8,13 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/calls/calls.h"
-#include "libc/intrin/kprintf.h"
 #include "libc/log/check.h"
-#include "libc/log/log.h"
-#include "libc/nt/nt/process.h"
-#include "libc/rand/rand.h"
-#include "libc/runtime/gc.h"
-#include "libc/runtime/memtrack.internal.h"
-#include "libc/runtime/runtime.h"
+#include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
-#include "libc/time/time.h"
-#include "libc/x/x.h"

 dontinline void dostuff(const char *s) {
  int i, us;
-  srand(rand64()); /* seeds rand() w/ intel rdrnd, auxv, etc. */
+  srand(_rand64()); /* seeds rand() w/ intel rdrnd, auxv, etc. */
  for (i = 0; i < 5; ++i) {
    us = rand() % 500000;
    usleep(us);
@@ -0,0 +1,17 @@
+#if 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/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/mem/gc.h"
+#include "libc/mem/mem.h"
+#include "libc/str/str.h"
+
+int main(int argc, char *argv[]) {
+  char *p = _gc(malloc(64));
+  strcpy(p, "this memory is free'd when main() returns");
+}
@@ -8,7 +8,7 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/log/gdb.h"
-#include "libc/rand/rand.h"
+#include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"

 /**
@@ -7,19 +7,9 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/fmt/itoa.h"
-#include "libc/runtime/sysconf.h"
-#include "libc/stdio/stdio.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/runtime/runtime.h"

-int main(int argc, char *argv[]) {
-  int c, n;
-  char a[22], *p;
-  if ((c = GetCpuCount())) {
-    p = FormatInt64(a, c);
-    *p++ = '\n';
-    return write(1, a, p - a) == p - a ? 0 : 1;
-  } else {
-    return 1;
-  }
+int main() {
+  kprintf("%d\n", _getcpucount());
 }
@@ -7,20 +7,21 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/bits/bits.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
+#include "libc/intrin/bits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/nt/runtime.h"
-#include "libc/rand/rand.h"
-#include "libc/rand/xorshift.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
+#include "libc/stdio/xorshift.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/ex.h"
 #include "libc/sysv/consts/exit.h"
@@ -101,7 +102,7 @@ uint64_t rngset64(void) {
  static unsigned i;
  static uint64_t s;
  if (!i) {
-    s = rand64();
+    s = _rand64();
    i = (s + 1) & (511);
  }
  return MarsagliaXorshift64(&s);
@@ -214,7 +215,7 @@ const struct Function {
    {"moby", moby},              //
    {"mt19937", _mt19937},       //
    {"python", pythonx2},        //
-    {"rand64", rand64},          //
+    {"rand64", _rand64},         //
    {"rdrand", rdrand},          //
    {"rdrnd", rdrand},           //
    {"rdseed", rdseed},          //
@@ -0,0 +1,29 @@
+#if 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/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/assert.h"
+#include "libc/calls/struct/timeval.h"
+#include "libc/stdio/stdio.h"
+#include "libc/time/struct/tm.h"
+#include "libc/time/time.h"
+#include "net/http/http.h"
+
+int main(int argc, char *argv[]) {
+  int rc;
+  int64_t t;
+  char p[30];
+  struct tm tm;
+  struct timeval tv;
+  rc = gettimeofday(&tv, 0);
+  assert(!rc);
+  t = tv.tv_sec;
+  gmtime_r(&t, &tm);
+  FormatHttpDateTime(p, &tm);
+  printf("%s\n", p);
+}
@@ -8,27 +8,29 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/assert.h"
-#include "libc/bits/atomic.h"
+#include "libc/atomic.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timeval.h"
 #include "libc/dce.h"
+#include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
+#include "libc/intrin/atomic.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/wait0.internal.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
 #include "libc/mem/mem.h"
-#include "libc/nexgen32e/threaded.h"
+#include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
-#include "libc/runtime/sysconf.h"
 #include "libc/sock/sock.h"
+#include "libc/sock/struct/pollfd.h"
+#include "libc/sock/struct/sockaddr.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/af.h"
 #include "libc/sysv/consts/clock.h"
@@ -43,6 +45,10 @@
 #include "libc/sysv/consts/sock.h"
 #include "libc/sysv/consts/sol.h"
 #include "libc/sysv/consts/tcp.h"
+#include "libc/thread/spawn.h"
+#include "libc/thread/thread.h"
+#include "libc/thread/tls.h"
+#include "libc/thread/wait0.internal.h"
 #include "libc/time/struct/tm.h"
 #include "libc/time/time.h"
 #include "net/http/http.h"
@@ -71,8 +77,8 @@
 * Like redbean, greenbean has superior performance too, with an
 * advantage on benchmarks biased towards high connection counts
 *
- *     $ wrk -c 300 -t 32 --latency http://10.10.10.124:8080/
- *     Running 10s test @ http://10.10.10.124:8080/
+ *     $ wrk -c 300 -t 32 --latency http://127.0.0.1:8080/
+ *     Running 10s test @ http://127.0.0.1:8080/
 *       32 threads and 300 connections
 *         Thread Stats   Avg      Stdev     Max   +/- Stdev
 *         Latency   661.06us    5.11ms  96.22ms   98.85%
@@ -99,14 +105,14 @@
  "Cache-Control: private; max-age=0\r\n"

 int threads;
-_Atomic(int) workers;
-_Atomic(int) messages;
-_Atomic(int) listening;
-_Atomic(int) connections;
-_Atomic(int) closingtime;
+atomic_int workers;
+atomic_int messages;
+atomic_int listening;
+atomic_int connections;
+atomic_int closingtime;
 const char *volatile status;

-int Worker(void *id) {
+void *Worker(void *id) {
  int server, yes = 1;

  // load balance incoming connections for port 8080 across all threads
@@ -114,7 +120,7 @@ int Worker(void *id) {
  struct timeval timeo = {KEEPALIVE / 1000, KEEPALIVE % 1000};
  struct sockaddr_in addr = {.sin_family = AF_INET, .sin_port = htons(PORT)};

-  server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  server = socket(AF_INET, SOCK_STREAM, 0);
  if (server == -1) {
    kprintf("socket() failed %m\n"
            "  try running: sudo prlimit --pid=$$ --nofile=%d\n",
@@ -130,7 +136,7 @@ int Worker(void *id) {
  setsockopt(server, SOL_TCP, TCP_QUICKACK, &yes, sizeof(yes));
  errno = 0;

-  if (bind(server, &addr, sizeof(addr)) == -1) {
+  if (bind(server, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
    kprintf("%s() failed %m\n", "socket");
    goto CloseWorker;
  }
@@ -160,7 +166,7 @@ int Worker(void *id) {

    // wait for client connection
    clientaddrsize = sizeof(clientaddr);
-    client = accept(server, &clientaddr, &clientaddrsize);
+    client = accept(server, (struct sockaddr *)&clientaddr, &clientaddrsize);

    // accept() can raise a very diverse number of errors but none of
    // them are really true showstoppers that would necessitate us to
@@ -272,9 +278,8 @@ void PrintStatus(void) {
 }

 int main(int argc, char *argv[]) {
-  int i;
-  char **tls;
-  char **stack;
+  int i, rc;
+  pthread_t *th;
  uint32_t *hostips;
  // ShowCrashReports();

@@ -293,36 +298,29 @@ int main(int argc, char *argv[]) {
            PORT);
  }

+  threads = argc > 1 ? atoi(argv[1]) : _getcpucount();
+  if (!(1 <= threads && threads <= 100000)) {
+    kprintf("error: invalid number of threads: %d\n", threads);
+    exit(1);
+  }
+
+  // secure the server
+  __enable_threads();
+  unveil("/dev/null", "rw");
+  unveil(0, 0);
+  pledge("stdio inet", 0);
+
  // spawn over 9,000 worker threads
-  tls = 0;
-  stack = 0;
-  threads = argc > 1 ? atoi(argv[1]) : GetCpuCount();
-  if ((1 <= threads && threads <= INT_MAX) &&
-      (tls = malloc(threads * sizeof(*tls))) &&
-      (stack = malloc(threads * sizeof(*stack)))) {
-    for (i = 0; i < threads; ++i) {
-      if ((tls[i] = __initialize_tls(malloc(64))) &&
-          (stack[i] = mmap(0, GetStackSize(), PROT_READ | PROT_WRITE,
-                           MAP_STACK | MAP_ANONYMOUS, -1, 0)) != MAP_FAILED) {
-        ++workers;
-        if (clone(Worker, stack[i], GetStackSize(),
-                  CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES |
-                      CLONE_SIGHAND | CLONE_SETTLS | CLONE_CHILD_SETTID |
-                      CLONE_CHILD_CLEARTID,
-                  (void *)(intptr_t)i, 0, tls[i], 64,
-                  (int *)(tls[i] + 0x38)) == -1) {
-          --workers;
-          kprintf("error: clone(%d) failed %m\n", i);
-        }
-      } else {
-        kprintf("error: mmap(%d) failed %m\n", i);
-      }
-      if (!(i % 500)) {
-        PrintStatus();
-      }
+  th = calloc(threads, sizeof(pthread_t));
+  for (i = 0; i < threads; ++i) {
+    ++workers;
+    if ((rc = pthread_create(th + i, 0, Worker, (void *)(intptr_t)i))) {
+      --workers;
+      kprintf("error: pthread_create(%d) failed %s\n", i, strerror(rc));
+    }
+    if (!(i % 500)) {
+      PrintStatus();
    }
-  } else {
-    kprintf("error: invalid number of threads\n");
  }

  // wait for workers to terminate
@@ -335,17 +333,11 @@ int main(int argc, char *argv[]) {
  kprintf("\r\e[K");

  // join the workers
-  // this is how we guarantee stacks are safe to free
-  if (tls && stack) {
-    for (i = 0; i < threads; ++i) {
-      _wait0((int *)(tls[i] + 0x38));
-      munmap(stack[i], GetStackSize());
-      free(tls[i]);
-    }
+  for (i = 0; i < threads; ++i) {
+    pthread_join(th[i], 0);
  }

  // clean up memory
  free(hostips);
-  free(stack);
-  free(tls);
+  free(th);
 }
@@ -38,7 +38,7 @@
 */
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
-#include "libc/rand/rand.h"
+#include "libc/stdio/rand.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"