Release Cosmopolitan 3.2.2

If cosmo_dlopen() is linked on AMD64 then the runtime will switch to
using %gs for thread-local storage. This eliminates the need for the
imported symbol trampoline. It's now safer to pass function pointers
back and forth with imported libraries. Your program gets recompiled
at runtime to make it happen and the overhead is a few milliseconds.

.gitignore

@@ -1,6 +1,7 @@
 # -*- conf -*-
 
 /o
+/cosmocc
 /.prompt.jtlp
 
 # TODO: Find some way to have Python write to o/

Makefile

@@ -1,5 +1,5 @@
 #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘
+#── vi: set et ft=make ts=8 sw=8 fenc=utf-8 :vi ──────────────────────┘
 #
 # SYNOPSIS
 #
@@ -73,21 +73,89 @@ MODE := $(m)
 endif
 endif
 
-UNAME_M = $(shell uname -m)
-UNAME_S = $(shell uname -s)
+COMMA := ,
+PWD := $(shell pwd)
+
+# detect wsl2 running cosmopolitan binaries on the host by checking whether:
+# - user ran build/bootstrap/make.com, in which case make's working directory is in wsl
+# - user ran make, in which case cocmd.com's working directory is in wsl
+ifneq ($(findstring //wsl.localhost/,$(CURDIR) $(PWD)),)
+$(warning wsl2 interop is enabled)
+$(error you need to run sudo sh -c 'echo -1 > /proc/sys/fs/binfmt_misc/WSLInterop')
+endif
+
+UNAME_M := $(shell uname -m)
+UNAME_S := $(shell uname -s)
 
 # apple still distributes a 17 year old version of gnu make
 ifeq ($(MAKE_VERSION), 3.81)
 $(error please use build/bootstrap/make.com)
 endif
 
-# provide instructions to non-linux users on unbundling gcc
-ifeq ($(TOOLCHAIN),)                                                # if TOOLCHAIN isn't defined
-ifeq ("$(wildcard o/third_party/gcc/bin/x86_64-linux-cosmo-*)","")  # if our gcc isn't unbundled
-ifneq ($(UNAME_M)-$(UNAME_S), x86_64-Linux)                         # if this is not amd64 linux
-$(error you need to download https://justine.lol/cosmocc-0.0.18.zip and unzip it inside the cosmo directory)
-endif
+LC_ALL = C
+SOURCE_DATE_EPOCH = 0
+
+ARFLAGS = rcsD
+ZFLAGS ?=
+XARGS ?= xargs -P4 -rs8000
+DOT ?= dot
+CLANG = clang
+TMPDIR = o/tmp
+
+AR = build/bootstrap/ar.com
+CP = build/bootstrap/cp.com
+RM = build/bootstrap/rm.com -f
+GZIP = build/bootstrap/gzip.com
+ECHO = build/bootstrap/echo.com
+CHMOD = build/bootstrap/chmod.com
+TOUCH = build/bootstrap/touch.com
+PKG = build/bootstrap/package.com
+MKDEPS = build/bootstrap/mkdeps.com
+ZIPOBJ = build/bootstrap/zipobj.com
+ZIPCOPY = build/bootstrap/zipcopy.com
+PECHECK = build/bootstrap/pecheck.com
+FIXUPOBJ = build/bootstrap/fixupobj.com
+MKDIR = build/bootstrap/mkdir.com -p
+COMPILE = build/bootstrap/compile.com -V9 -P4096 $(QUOTA)
+
+IGNORE := $(shell $(MKDIR) $(TMPDIR))
+
+ifneq ($(findstring aarch64,$(MODE)),)
+ARCH = aarch64
+HOSTS ?= pi studio freebsdarm
+else
+ARCH = x86_64
+HOSTS ?= freebsd rhel7 xnu win10 openbsd netbsd
 endif
+
+ZIPOBJ_FLAGS += -a$(ARCH)
+IGNORE := $(shell $(MKDIR) $(TMPDIR))
+
+export ADDR2LINE
+export LC_ALL
+export MKDIR
+export MODE
+export SOURCE_DATE_EPOCH
+export TMPDIR
+
+COSMOCC = cosmocc/3.2
+TOOLCHAIN = $(COSMOCC)/bin/$(ARCH)-linux-cosmo-
+DOWNLOAD := $(shell build/download-cosmocc.sh $(COSMOCC) 3.2 28b48682595f0f46b45ab381118cdffdabc8fcfa29aa54e301fe6ffe35269f5e)
+
+AS = $(TOOLCHAIN)as
+CC = $(TOOLCHAIN)gcc
+CXX = $(TOOLCHAIN)g++
+CXXFILT = $(TOOLCHAIN)c++filt
+LD = $(TOOLCHAIN)ld.bfd
+NM = $(TOOLCHAIN)nm
+GCC = $(TOOLCHAIN)gcc
+STRIP = $(TOOLCHAIN)strip
+OBJCOPY = $(TOOLCHAIN)objcopy
+OBJDUMP = $(TOOLCHAIN)objdump
+ifneq ($(wildcard $(PWD)/$(TOOLCHAIN)addr2line),)
+ADDR2LINE = $(PWD)/$(TOOLCHAIN)addr2line
+else
+ADDR2LINE = $(TOOLCHAIN)addr2line
 endif
 
 # the default build modes is empty string
@@ -115,6 +183,11 @@ o/$(MODE):			\
 	o/$(MODE)/examples	\
 	o/$(MODE)/third_party
 
+# TODO(jart): Make Emacs `C-c C-c` shortcut not need this.
+.PHONY: o/$(MODE)/ o/$(MODE)/.
+o/$(MODE)/: o/$(MODE)
+o/$(MODE)/.: o/$(MODE)
+
 # check if we're using o//third_party/make/make.com
 # we added sandboxing to guarantee cosmo's makefile is hermetic
 # it also shaves away 200ms of startup latency with native $(uniq)
@@ -125,7 +198,7 @@ $(warning please run ape/apeinstall.sh if you intend to use landlock make)
 $(shell sleep .5)
 endif
 endif
-ifeq ($(USE_SYSTEM_TOOLCHAIN),)
+ifneq ($(TOOLCHAIN),)
 .STRICT = 1
 endif
 endif
@@ -136,8 +209,8 @@ endif
 	libc/stdbool.h				\
 	libc/disclaimer.inc			\
 	rwc:/dev/shm				\
+	rx:cosmocc				\
 	rx:build/bootstrap			\
-	rx:o/third_party/gcc			\
 	r:build/portcosmo.h			\
 	/proc/stat				\
 	rw:/dev/null				\
@@ -158,152 +231,154 @@ include build/definitions.mk			# ├──META
 include build/config.mk				# │  You can build
 include build/rules.mk				# │  You can topologically order
 include build/online.mk				#─┘
-include libc/nexgen32e/nexgen32e.mk		#─┐
-include libc/sysv/sysv.mk			# ├──SYSTEM SUPPORT
-include libc/nt/nt.mk				# │  You can do math
-include libc/intrin/intrin.mk			# │  You can use the stack
-include third_party/compiler_rt/compiler_rt.mk	# │  You can manipulate arrays
-include libc/tinymath/tinymath.mk		# │  You can issue raw system calls
-include libc/str/str.mk				# │
-include third_party/xed/xed.mk			# │
-include third_party/puff/puff.mk		# │
-include libc/elf/elf.mk				# │
-include ape/ape.mk				# │
-include libc/fmt/fmt.mk				# │
-include libc/vga/vga.mk				# │
-include libc/irq/irq.mk				#─┘
-include libc/calls/calls.mk			#─┐
-include libc/irq/irq.mk				# ├──SYSTEMS RUNTIME
-include third_party/nsync/nsync.mk		# │  You can issue system calls
-include libc/runtime/runtime.mk			# │
-include libc/dlopen/dlopen.mk			# │
-include third_party/double-conversion/dc.mk	# │
-include libc/crt/crt.mk				# │
-include third_party/dlmalloc/dlmalloc.mk	#─┘
-include libc/mem/mem.mk				#─┐
-include third_party/gdtoa/gdtoa.mk		# ├──DYNAMIC RUNTIME
-include third_party/nsync/mem/mem.mk		# │  You can now use stdio
-include libc/proc/proc.mk			# │  You can now use threads
-include libc/thread/thread.mk			# │  You can now use processes
-include tool/hello/hello.mk			# │  You can finally call malloc()
-include third_party/zlib/zlib.mk		# │
-include libc/stdio/stdio.mk			# │
-include libc/time/time.mk			# │
-include net/net.mk				# │
-include third_party/vqsort/vqsort.mk		# │
-include libc/log/log.mk				# │
-include third_party/getopt/getopt.mk		# │
-include third_party/bzip2/bzip2.mk		# │
-include dsp/core/core.mk			# │
-include third_party/musl/musl.mk		# │
-include libc/x/x.mk				# │
-include third_party/stb/stb.mk			# │
-include dsp/scale/scale.mk			# │
-include dsp/mpeg/mpeg.mk			# │
-include dsp/dsp.mk				# │
-include third_party/zlib/gz/gz.mk		# │
-include third_party/intel/intel.mk		# │
-include third_party/aarch64/aarch64.mk		# │
-include libc/libc.mk				#─┘
-include libc/sock/sock.mk			#─┐
-include dsp/tty/tty.mk				# ├──ONLINE RUNTIME
-include libc/dns/dns.mk				# │  You can communicate with the network
-include net/http/http.mk			# │
-include third_party/mbedtls/mbedtls.mk		# │
-include third_party/libcxx/libcxx.mk		# │
-include third_party/ggml/ggml.mk		# │
-include third_party/radpajama/radpajama.mk	# │
-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/tree/tree.mk
-include third_party/zstd/zstd.mk
-include third_party/tr/tr.mk
-include third_party/sed/sed.mk
-include third_party/awk/awk.mk
-include third_party/hiredis/hiredis.mk
-include third_party/make/make.mk
-include third_party/ctags/ctags.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
-include third_party/mbedtls/test/test.mk
-include third_party/quickjs/quickjs.mk
-include third_party/lz4cli/lz4cli.mk
-include third_party/zip/zip.mk
-include third_party/xxhash/xxhash.mk
-include third_party/unzip/unzip.mk
-include tool/build/lib/buildlib.mk
-include third_party/chibicc/chibicc.mk
-include third_party/chibicc/test/test.mk
-include third_party/python/python.mk
-include tool/build/build.mk
-include tool/curl/curl.mk
-include third_party/qemu/qemu.mk
-include examples/examples.mk
-include examples/pyapp/pyapp.mk
-include examples/pylife/pylife.mk
-include tool/decode/lib/decodelib.mk
-include tool/decode/decode.mk
-include tool/lambda/lib/lib.mk
-include tool/lambda/lambda.mk
-include tool/plinko/lib/lib.mk
-include tool/plinko/plinko.mk
-include test/tool/plinko/test.mk
-include tool/net/net.mk
-include tool/viz/viz.mk
-include tool/tool.mk
-include net/turfwar/turfwar.mk
-include test/libc/tinymath/test.mk
-include test/libc/intrin/test.mk
-include test/libc/mem/test.mk
-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/str/test.mk
-include test/libc/log/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/time/test.mk
-include test/libc/proc/test.mk
-include test/libc/stdio/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
-include test/tool/viz/lib/test.mk
-include test/tool/viz/test.mk
-include test/tool/net/test.mk
-include test/tool/test.mk
-include test/dsp/core/test.mk
-include test/dsp/scale/test.mk
-include test/dsp/tty/test.mk
-include test/dsp/test.mk
-include examples/package/lib/build.mk
-include examples/package/build.mk
+include libc/nexgen32e/BUILD.mk			#─┐
+include libc/sysv/BUILD.mk			# ├──SYSTEM SUPPORT
+include libc/nt/BUILD.mk			# │  You can do math
+include libc/intrin/BUILD.mk			# │  You can use the stack
+include third_party/compiler_rt/BUILD.mk	# │  You can manipulate arrays
+include libc/tinymath/BUILD.mk			# │  You can issue raw system calls
+include libc/str/BUILD.mk			# │
+include third_party/xed/BUILD.mk		# │
+include third_party/puff/BUILD.mk		# │
+include libc/elf/BUILD.mk			# │
+include ape/BUILD.mk				# │
+include libc/fmt/BUILD.mk			# │
+include libc/vga/BUILD.mk			# │
+include libc/irq/BUILD.mk			#─┘
+include libc/calls/BUILD.mk			#─┐
+include libc/irq/BUILD.mk			# ├──SYSTEMS RUNTIME
+include third_party/nsync/BUILD.mk		# │  You can issue system calls
+include libc/runtime/BUILD.mk			# │
+include third_party/double-conversion/BUILD.mk	# │
+include libc/crt/BUILD.mk			# │
+include third_party/dlmalloc/BUILD.mk		#─┘
+include libc/mem/BUILD.mk			#─┐
+include third_party/gdtoa/BUILD.mk		# ├──DYNAMIC RUNTIME
+include third_party/nsync/mem/BUILD.mk		# │  You can now use stdio
+include libc/proc/BUILD.mk			# │  You can now use threads
+include libc/dlopen/BUILD.mk			# │  You can now use processes
+include libc/thread/BUILD.mk			# │  You can finally call malloc()
+include third_party/zlib/BUILD.mk		# │
+include libc/stdio/BUILD.mk			# │
+include tool/hello/BUILD.mk			# │
+include libc/time/BUILD.mk			# │
+include net/BUILD.mk				# │
+include third_party/vqsort/BUILD.mk		# │
+include libc/log/BUILD.mk			# │
+include third_party/getopt/BUILD.mk		# │
+include third_party/bzip2/BUILD.mk		# │
+include dsp/core/BUILD.mk			# │
+include third_party/zlib/gz/BUILD.mk		# │
+include third_party/intel/BUILD.mk		# │
+include third_party/aarch64/BUILD.mk		# │
+include libc/BUILD.mk				#─┘
+include libc/sock/BUILD.mk			#─┐
+include net/http/BUILD.mk			# ├──ONLINE RUNTIME
+include third_party/musl/BUILD.mk		# │  You can communicate with the network
+include libc/x/BUILD.mk				# │
+include dsp/scale/BUILD.mk			# │
+include dsp/mpeg/BUILD.mk			# │
+include dsp/tty/BUILD.mk			# │
+include dsp/BUILD.mk				# │
+include third_party/stb/BUILD.mk		# │
+include third_party/mbedtls/BUILD.mk		# │
+include third_party/ncurses/BUILD.mk		# │
+include third_party/readline/BUILD.mk		# │
+include third_party/libcxx/BUILD.mk		# │
+include third_party/pcre/BUILD.mk		# │
+include third_party/less/BUILD.mk		# │
+include net/https/BUILD.mk			# │
+include third_party/regex/BUILD.mk		# │
+include third_party/bash/BUILD.mk		#─┘
+include third_party/tidy/BUILD.mk
+include third_party/BUILD.mk
+include third_party/nsync/testing/BUILD.mk
+include libc/testlib/BUILD.mk
+include tool/viz/lib/BUILD.mk
+include tool/args/BUILD.mk
+include test/posix/BUILD.mk
+include test/tool/args/BUILD.mk
+include third_party/linenoise/BUILD.mk
+include third_party/maxmind/BUILD.mk
+include net/finger/BUILD.mk
+include third_party/double-conversion/test/BUILD.mk
+include third_party/lua/BUILD.mk
+include third_party/tree/BUILD.mk
+include third_party/zstd/BUILD.mk
+include third_party/tr/BUILD.mk
+include third_party/sed/BUILD.mk
+include third_party/awk/BUILD.mk
+include third_party/hiredis/BUILD.mk
+include third_party/make/BUILD.mk
+include third_party/ctags/BUILD.mk
+include third_party/finger/BUILD.mk
+include third_party/argon2/BUILD.mk
+include third_party/smallz4/BUILD.mk
+include third_party/sqlite3/BUILD.mk
+include third_party/mbedtls/test/BUILD.mk
+include third_party/quickjs/BUILD.mk
+include third_party/lz4cli/BUILD.mk
+include third_party/zip/BUILD.mk
+include third_party/xxhash/BUILD.mk
+include third_party/unzip/BUILD.mk
+include tool/build/lib/BUILD.mk
+include third_party/chibicc/BUILD.mk
+include third_party/chibicc/test/BUILD.mk
+include third_party/python/BUILD.mk
+include tool/build/BUILD.mk
+include tool/curl/BUILD.mk
+include third_party/qemu/BUILD.mk
+include examples/BUILD.mk
+include examples/pyapp/BUILD.mk
+include examples/pylife/BUILD.mk
+include tool/decode/lib/BUILD.mk
+include tool/decode/BUILD.mk
+include tool/lambda/lib/BUILD.mk
+include tool/lambda/BUILD.mk
+include tool/plinko/lib/BUILD.mk
+include tool/plinko/BUILD.mk
+include test/tool/plinko/BUILD.mk
+include tool/net/BUILD.mk
+include tool/viz/BUILD.mk
+include tool/BUILD.mk
+include net/turfwar/BUILD.mk
+include test/libc/tinymath/BUILD.mk
+include test/libc/intrin/BUILD.mk
+include test/libc/mem/BUILD.mk
+include test/libc/nexgen32e/BUILD.mk
+include test/libc/runtime/BUILD.mk
+include test/libc/thread/BUILD.mk
+include test/libc/sock/BUILD.mk
+include test/libc/str/BUILD.mk
+include test/libc/log/BUILD.mk
+include test/libc/str/BUILD.mk
+include test/libc/calls/BUILD.mk
+include test/libc/x/BUILD.mk
+include test/libc/xed/BUILD.mk
+include test/libc/fmt/BUILD.mk
+include test/libc/time/BUILD.mk
+include test/libc/proc/BUILD.mk
+include test/libc/stdio/BUILD.mk
+include test/libc/release/BUILD.mk
+include test/libc/BUILD.mk
+include test/net/http/BUILD.mk
+include test/net/https/BUILD.mk
+include test/net/finger/BUILD.mk
+include test/net/BUILD.mk
+include test/tool/build/lib/BUILD.mk
+include test/tool/build/BUILD.mk
+include test/tool/viz/lib/BUILD.mk
+include test/tool/viz/BUILD.mk
+include test/tool/net/BUILD.mk
+include test/tool/BUILD.mk
+include test/dsp/core/BUILD.mk
+include test/dsp/scale/BUILD.mk
+include test/dsp/tty/BUILD.mk
+include test/dsp/BUILD.mk
+include examples/package/lib/BUILD.mk
+include examples/package/BUILD.mk
 #-φ-examples/package/new.sh
-include test/test.mk
+include test/BUILD.mk
 
 OBJS	 = $(foreach x,$(PKGS),$($(x)_OBJS))
 SRCS	:= $(foreach x,$(PKGS),$($(x)_SRCS))
@@ -329,7 +404,7 @@ o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(
 o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x)))) $(INCS) $(INCS)
 	$(file >$@,$(INCS))
 o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt o/$(MODE)/incs.txt $(SRCS) $(HDRS) $(INCS)
-	$(COMPILE) -AMKDEPS -L320 $(MKDEPS) -o $@ -r o/$(MODE)/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt @o/$(MODE)/incs.txt
+	$(COMPILE) -AMKDEPS -L320 $(MKDEPS) -o $@ -s -r o/$(MODE)/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt @o/$(MODE)/incs.txt
 
 o/$(MODE)/srcs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(SRCS),$(file >>$@,$(x)))
@@ -356,7 +431,6 @@ loc: o/$(MODE)/tool/build/summy.com
 COSMOPOLITAN_OBJECTS =			\
 	TOOL_ARGS			\
 	NET_HTTP			\
-	LIBC_DNS			\
 	LIBC_SOCK			\
 	LIBC_NT_WS2_32			\
 	LIBC_NT_IPHLPAPI		\
@@ -403,13 +477,13 @@ COSMOPOLITAN_OBJECTS =			\
 	LIBC_NT_KERNEL32		\
 	LIBC_NEXGEN32E
 
-COSMOPOLITAN_HEADERS =			\
+COSMOPOLITAN_H_PKGS =			\
 	APE				\
 	LIBC				\
 	LIBC_CALLS			\
-	LIBC_DNS			\
 	LIBC_ELF			\
 	LIBC_FMT			\
+	LIBC_DLOPEN			\
 	LIBC_INTRIN			\
 	LIBC_LOG			\
 	LIBC_MEM			\
@@ -434,21 +508,41 @@ COSMOPOLITAN_HEADERS =			\
 	THIRD_PARTY_GDTOA		\
 	THIRD_PARTY_GETOPT		\
 	THIRD_PARTY_MUSL		\
+	THIRD_PARTY_ZLIB		\
 	THIRD_PARTY_REGEX
 
+COSMOCC_PKGS =				\
+	$(COSMOPOLITAN_H_PKGS)		\
+	THIRD_PARTY_AARCH64		\
+	THIRD_PARTY_LIBCXX		\
+	THIRD_PARTY_INTEL
+
 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))	\
-		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_INCS))
-	$(file >$(TMPDIR)/$(subst /,_,$@),libc/integral/normalize.inc $(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS)))
+COSMOCC_HDRS =								\
+	$(wildcard libc/integral/*)					\
+	$(foreach x,$(COSMOCC_PKGS),$($(x)_HDRS))			\
+	$(foreach x,$(COSMOCC_PKGS),$($(x)_INCS))
+
+o/cosmocc.h.txt: Makefile
+	$(file >$@, $(call uniq,$(COSMOCC_HDRS)))
+
+COSMOPOLITAN_H_ROOT_HDRS =						\
+	libc/integral/normalize.inc					\
+	$(foreach x,$(COSMOPOLITAN_H_PKGS),$($(x)_HDRS))
+
+o/cosmopolitan.h.txt: Makefile
+	$(file >$@, $(call uniq,$(COSMOPOLITAN_H_ROOT_HDRS)))
+
+o/cosmopolitan.h: o/cosmopolitan.h.txt					\
+		$(wildcard libc/integral/*)				\
+		$(foreach x,$(COSMOPOLITAN_H_PKGS),$($(x)_HDRS))	\
+		$(foreach x,$(COSMOPOLITAN_H_PKGS),$($(x)_INCS))
 	@$(ECHO) '#ifndef __STRICT_ANSI__' >$@
 	@$(ECHO) '#define _COSMO_SOURCE' >>$@
 	@$(ECHO) '#endif' >>$@
-	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >>$@
+	@$(COMPILE) -AROLLUP -T$@ build/bootstrap/rollup.com @$< >>$@
 
 o/cosmopolitan.html: private .UNSANDBOXED = 1
 o/cosmopolitan.html:							\

README.md

@@ -12,29 +12,25 @@ possible performance and the tiniest footprint imaginable.
 
 ## Background
 
-For an introduction to this project, please read the [αcτµαlly pδrταblε
-εxεcµταblε](https://justine.lol/ape.html) blog post and [cosmopolitan
+For an introduction to this project, please read the [actually portable
+executable](https://justine.lol/ape.html) blog post and [cosmopolitan
 libc](https://justine.lol/cosmopolitan/index.html) website. We also have
-[API documentation](https://justine.lol/cosmopolitan/documentation.html).
+[API
+documentation](https://justine.lol/cosmopolitan/documentation.html).
 
 ## Getting Started
 
-It's recommended that Cosmopolitan be installed to `/opt/cosmo` and
-`/opt/cosmos` on your computer. The first has the monorepo. The second
-contains your non-monorepo artifacts.
+You can start by obtaining a release of our `cosmocc` compiler from
+<https://cosmo.zip/pub/cosmocc/>.
 
 ```sh
-sudo mkdir -p /opt
-sudo chmod 1777 /opt
-git clone https://github.com/jart/cosmopolitan /opt/cosmo
-export PATH="/opt/cosmo/bin:/opt/cosmos/bin:$PATH"
-echo 'PATH="/opt/cosmo/bin:/opt/cosmos/bin:$PATH"' >>~/.profile
-ape-install        # optionally install a faster systemwide ape loader
-cosmocc --update   # pull cosmo and rebuild toolchain
+mkdir -p cosmocc
+cd cosmocc
+wget https://cosmo.zip/pub/cosmocc/cosmocc.zip
+unzip cosmocc.zip
 ```
 
-You've now successfully installed your very own cosmos. Now let's build
-an example program:
+Here's an example program we can write:
 
 ```c
 // hello.c
@@ -45,26 +41,11 @@ int main() {
 }
 ```
 
-To compile the program, you can run the `cosmocc` command. It's
-important to give it an output path that ends with `.com` so the output
-format will be Actually Portable Executable. When this happens, a
-concomitant debug binary is created automatically too.
+It can be compiled as follows:
 
 ```sh
-cosmocc -o hello.com hello.c
-./hello.com
-./hello.com.dbg
-```
-
-You can use the `cosmocc` toolchain to build conventional open source
-projects which use autotools. This strategy normally works:
-
-```sh
-export CC=cosmocc
-export CXX=cosmoc++
-./configure --prefix=/opt/cosmos
-make -j
-make install
+cosmocc -o hello hello.c
+./hello
 ```
 
 The Cosmopolitan Libc runtime links some heavyweight troubleshooting
@@ -72,324 +53,66 @@ features by default, which are very useful for developers and admins.
 Here's how you can log system calls:
 
 ```sh
-./hello.com --strace
+./hello --strace
 ```
 
 Here's how you can get a much more verbose log of function calls:
 
 ```sh
-./hello.com --ftrace
+./hello --ftrace
 ```
 
-If you don't want rich runtime features like the above included, and you
-just want libc, and you want smaller simpler programs. In that case, you
-can consider using `MODE=tiny`, which is preconfigured by the repo in
-[build/config.mk](build/config.mk). Using this mode is much more
-effective at reducing binary footprint than the `-Os` flag alone. You
-can change your build mode by doing the following:
+You can use the Cosmopolitan's toolchain to build conventional open
+source projects which use autotools. This strategy normally works:
 
 ```sh
-export MODE=tiny
-cosmocc --update
-```
-
-We can also make our program slightly smaller by using the system call
-interface directly, which is fine, since Cosmopolitan polyfills these
-interfaces across platforms, including Windows. For example:
-
-```c
-// hello2.c
-#include <unistd.h>
-int main() {
-  write(1, "hello world\n", 12);
-}
-```
-
-Once compiled, your APE binary should be ~36kb in size.
-
-```sh
-export MODE=tiny
-cosmocc -Os -o hello2.com hello2.c
-./hello2.com
-```
-
-But let's say you only care about your binaries running on Linux and you
-don't want to use up all this additional space for platforms like WIN32.
-In that case, you can try `MODE=tinylinux` for example which will create
-executables more on the order of 8kb (similar to Musl Libc).
-
-```sh
-export MODE=tinylinux
-cosmocc --update
-cosmocc -Os -o hello2.com hello2.c
-./hello2.com  # <-- actually an ELF executable
-```
-
-## ARM
-
-Cosmo supports cross-compiling binaries for machines with ARM
-microprocessors. For example:
-
-```sh
-make -j8 m=aarch64 o/aarch64/third_party/ggml/llama.com
-make -j8 m=aarch64-tiny o/aarch64-tiny/third_party/ggml/llama.com
-```
-
-That'll produce ELF executables that run natively on two operating
-systems: Linux Arm64 (e.g. Raspberry Pi) and MacOS Arm64 (i.e. Apple
-Silicon), thus giving you full performance. The catch is you have to
-compile these executables on an x86_64-linux machine. The second catch
-is that MacOS needs a little bit of help understanding the ELF format.
-To solve that, we provide a tiny APE loader you can use on M1 machines.
-
-```sh
-scp ape/ape-m1.c macintosh:
-scp o/aarch64/third_party/ggml/llama.com macintosh:
-ssh macintosh
-xcode-install
-cc -o ape ape-m1.c
-sudo cp ape /usr/local/bin/ape
-```
-
-You can run your ELF AARCH64 executable on Apple Silicon as follows:
-
-```sh
-ape ./llama.com
-```
-
-If you want to run the `MODE=aarch64` unit tests, you need to have
-qemu-aarch64 installed as a binfmt_misc interpreter. It needs to be a
-static binary if you want it to work with Landlock Make's security. You
-can use the build included in our `third_party/qemu/` folder.
-
-```
-doas cp o/third_party/qemu/qemu-aarch64 /usr/bin/qemu-aarch64
-doas sh -c "echo ':qemu-aarch64:M::\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\xb7\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-aarch64:CF' > /proc/sys/fs/binfmt_misc/register"
-make -j8 m=aarch64
-```
-
-Please note that the qemu-aarch64 binfmt_misc interpreter installation
-process is *essential* for being able to use the `aarch64-unknown-cosmo`
-toolchain to build fat APE binaries on your x86-64 machine.
-
-## AMD64 + ARM64 fat APE binaries
-
-If you've setup the qemu binfmt_misc interpreter, then you can can use
-cosmo's toolchains to build fat ape binaries. It works by compiling your
-program twice, so you can have a native build for both architectures in
-the same file. The two programs are merged together by apelink.com which
-also embeds multiple copies of APE loader and multiple symbols tables.
-
-The easiest way to build fat APE is using `fatcosmocc`. This compiler
-works by creating a concomitant `.aarch64/foo.o` for every `foo.o` you
-compile. The only exception is the C preprocessor mode, which actually
-runs x86-64 GCC except with macros like `__x86_64__` undefined.
-
-This toolchain works great for C projects that are written in a portable
-way and don't produce architecture-specific artifacts. One example of a
-large project that can be easily built is GNU coreutils.
-
-```sh
-cd coreutils
-fatcosmocc --update ||exit
-./configure CC=fatcosmocc \
-            AR=fatcosmoar \
-            INSTALL=$(command -v fatcosmoinstall) \
-            --prefix=/opt/cosmos \
-            --disable-nls \
-            --disable-dependency-tracking \
-            --disable-silent-rules
-make -j8
-```
-
-You'll then have a bunch of files like `src/ls` which are fat ape
-binaries. If you want to run them on Windows, then you simply need to
-rename the file so that it has the `.com` suffix. Better yet, consider
-making that a symlink (a.k.a. reparse point). The biggest gotcha with
-`fatcosmocc` though is ensuring builds don't strip binaries. For
-example, Linux's `install -s` command actually understands Windows'
-Portable Executable format well enough to remove the MS-DOS stub, which
-is where the APE shell script is stored. You need to ensure that
-`fatcosmoinstall` is used instead. Especially if your project needs to
-install the libraries built by `fatacosmoar` into `/opt/cosmos`.
-
-## Advanced Fat APE Builds
-
-Once you get seriously involved in creating fat APE builds of software
-you're going to eventually outgrow `fatcosmocc`. One example is Emacs
-which is trickier to build, because it produces architecture-specific
-files, and it also depends on shared files, e.g. zoneinfo. Since we like
-having everything in a neat little single-file executable container that
-doesn't need an "installation wizard", this tutorial will explain how we
-manage to accomplish that.
-
-What you're going to do is, instead of using `fatcosmocc`, you're going
-to use both the `x86_64-unknown-cosmo-cc` and `aarch64-unknown-cosmo-cc`
-toolchains independently, and then run `apelink` and `zip` to manually
-build the final files. But there's a few tricks to learn first.
-
-The first trick is to create a symlink on your system called `/zip`.
-Cosmopolitan Libc normally uses that as a synthetic folder that lets you
-access the assets in your zip executable. But since that's a read-only
-file system, your build system should use the normal one.
-
-```sh
-doas ln -sf /opt/cosmos /zip
-```
-
-Now create a file named `rebuild-fat.sh` which runs the build twice:
-
-```sh
-#!/bin/sh
-set -ex
-export MODE=aarch64
-export COSMOS=/opt/cosmos/aarch64
-rebuild-cosmos.sh aarch64
-export MODE=
-export COSMOS=/opt/cosmos/x86_64
-rebuild-cosmos.sh x86_64
-wall.com 'finished building'
-```
-
-Then create a second file `rebuild-cosmos.sh` which runs your build:
-
-```sh
-#!/bin/bash
-set -ex
-
-ARCH=${1:-x86_64}
-export COSMO=${COSMO:-/opt/cosmo}
-export COSMOS=${COSMOS:-/opt/cosmos/$ARCH}
-export AS=$(command -v $ARCH-unknown-cosmo-as) || exit
-export CC=$(command -v $ARCH-unknown-cosmo-cc) || exit
-export CXX=$(command -v $ARCH-unknown-cosmo-c++) || exit
-export AR=$(command -v $ARCH-unknown-cosmo-ar) || exit
-export STRIP=$(command -v $ARCH-unknown-cosmo-strip) || exit
-export INSTALL=$(command -v $ARCH-unknown-cosmo-install) || exit
-export OBJCOPY=$(command -v $ARCH-unknown-cosmo-objcopy) || exit
-export OBJDUMP=$(command -v $ARCH-unknown-cosmo-objdump) || exit
-export ADDR2LINE=$(command -v $ARCH-unknown-cosmo-addr2line) || exit
-
-$CC --update
-
-export COSMOPOLITAN_DISABLE_ZIPOS=1
-
-cd ~/vendor/zlib
-./configure --prefix=$COSMOS --static
-make clean
-make -j
-make install
-
-cd ~/vendor/ncurses-6.4
-./configure --prefix=$COSMOS --sysconfdir=/zip --datarootdir=/zip/share --exec-prefix=/zip/$ARCH --disable-shared
-make clean
-make -j
-make install
-
-cd ~/vendor/readline-8.2
-./configure --prefix=$COSMOS --sysconfdir=/zip --datarootdir=/zip/share --exec-prefix=/zip/$ARCH --disable-shared
-make uninstall || true
-make clean
-make -j
-make install
-
-# NOTES:
-# 1. You'll need to patch enum { FOO = x } that fails to build into a #define FOO
-# 2. You'll need to patch configure.ac so it DOES NOT define USABLE_FIONREAD to 1
-# 2. You'll need to patch configure.ac so it DOES NOT define INTERRUPT_INPUT to 1
-cd ~/vendor/emacs-28.2
-./configure --prefix=$COSMOS --sysconfdir=/zip --datarootdir=/zip/share --exec-prefix=/zip/$ARCH \
-            --without-x --with-threads --without-gnutls --disable-silent-rules --with-file-notification=no
-make uninstall || true
-make clean
+export CC=x86_64-unknown-cosmo-cc
+export CXX=x86_64-unknown-cosmo-c++
+./configure --prefix=/opt/cosmos/x86_64
 make -j
 make install
 ```
 
-Once you've completed this build process, you'll have the ELF files
-`/opt/cosmos/x86_64/bin/emacs` and `/opt/cosmos/aarch64/bin/emacs`. Your
-next move is to combine them into a single pristine `emacs.com` file.
+## Cosmopolitan Source Builds
+
+Cosmopolitan can be compiled from source on any of our supported
+platforms. The Makefile will download cosmocc automatically.
+
+It's recommended that you install a systemwide APE Loader. This command
+requires `sudo` access to copy the `ape` command to a system folder and
+register with binfmt_misc on Linux, for even more performance.
 
 ```sh
-cd /zip
-COSMO=${COSMO:-/opt/cosmo}
-mkdir -p /opt/cosmos/bin
-apelink \
-  -o /opt/cosmos/bin/emacs.com \
-  -l "$COSMO/o//ape/ape.elf" \
-  -l "$COSMO/o/aarch64/ape/ape.elf" \
-  -M "$COSMO/ape/ape-m1.c" \
-  /opt/cosmos/x86_64/bin/emacs \
-  /opt/cosmos/aarch64/bin/emacs
-cd /zip
-zip -r /opt/cosmos/bin/emacs.com \
-    aarch64/libexec \
-    x86_64/libexec \
-    share/terminfo \
-    $(find share/emacs -type f |
-        grep -v '\.el.gz$' |
-        grep -v refcards |
-        grep -v images)
+ape/apeinstall.sh
 ```
 
-You can now scp your `emacs.com` build to seven operating systems for
-two distinct kinds of microprocessors without any dependencies. All the
-LISP, zoneinfo, and termcap files it needs are stored inside the ZIP
-structure of the binary, which has performance that's equivalent to the
-Linux filesystem (even though it decompresses artifacts on the fly!) For
-this reason, you might actually find that fat APE Emacs goes faster if
-you're using an operating system like Windows where files are go slow.
-
-If you like to use Vim instead of Emacs, then you can build that too.
-However Vim's build system makes it a bit harder, since it's configured
-to always strip binaries. The `apelink` program needs the symbol tables
-to still be there when it creates the fat version. Otherwise tools like
-`--ftrace` won't work.
-
-## Monolithic Source Builds
-
-Cosmopolitan can be compiled from source on any Linux distro. First, you
-need to download or clone the repository.
+You can now build the mono repo with any modern version of GNU Make. To
+make life easier, we've included one in the cosmocc toolchain, which is
+guaranteed to be compatible and furthermore includes our extensions for
+doing build system sandboxing.
 
 ```sh
-wget https://justine.lol/cosmopolitan/cosmopolitan.tar.gz
-tar xf cosmopolitan.tar.gz  # see releases page
-cd cosmopolitan
-```
-
-This will build the entire repository and run all the tests:
-
-```sh
-build/bootstrap/make.com
+build/bootstrap/make.com -j8
 o//examples/hello.com
-find o -name \*.com | xargs ls -rShal | less
-```
-
-If you get an error running make.com then it's probably because you have
-WINE installed to `binfmt_misc`. You can fix that by installing the the
-APE loader as an interpreter. It'll improve build performance too!
-
-```sh
-bin/ape-install
 ```
 
 Since the Cosmopolitan repository is very large, you might only want to
-build a particular thing. Cosmopolitan's build config does a good job at
-having minimal deterministic builds. For example, if you wanted to build
-only hello.com then you could do that as follows:
+build one particular thing. Here's an example of a target that can be
+compiled relatively quickly, which is a simple POSIX test that only
+depends on core LIBC packages.
 
 ```sh
-build/bootstrap/make.com o//examples/hello.com
+rm -rf o//libc o//test
+build/bootstrap/make.com o//test/posix/signal_test.com
+o//test/posix/signal_test.com
 ```
 
 Sometimes it's desirable to build a subset of targets, without having to
-list out each individual one. You can do that by asking make to build a
-directory name. For example, if you wanted to build only the targets and
-subtargets of the chibicc package including its tests, you would say:
+list out each individual one. For example if you wanted to build and run
+all the unit tests in the `TEST_POSIX` package, you could say:
 
 ```sh
-build/bootstrap/make.com o//third_party/chibicc
-o//third_party/chibicc/chibicc.com --help
+build/bootstrap/make.com o//test/posix
 ```
 
 Cosmopolitan provides a variety of build modes. For example, if you want
@@ -399,118 +122,39 @@ really tiny binaries (as small as 12kb in size) then you'd say:
 build/bootstrap/make.com m=tiny
 ```
 
-Here's some other build modes you can try:
+You can furthermore cut out the bloat of other operating systems, and
+have Cosmopolitan become much more similar to Musl Libc.
 
 ```sh
-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
+build/bootstrap/make.com m=tinylinux
 ```
 
 For further details, see [//build/config.mk](build/config.mk).
 
-## Cosmopolitan Amalgamation
+## Debugging
 
-Another way to use Cosmopolitan is via our amalgamated release, where
-we've combined everything into a single static archive and a single
-header file. 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:
+To print a log of system calls to stderr:
 
 ```sh
-wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-3.0.2.zip
-unzip cosmopolitan-amalgamation-3.0.2.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 -mno-tls-direct-seg-refs -gdwarf-4 \
-  -o hello.com.dbg hello.c -fuse-ld=bfd -Wl,-T,ape.lds -Wl,--gc-sections \
-  -Wl,-z,common-page-size=0x1000 -Wl,-z,max-page-size=0x1000 \
-  -include cosmopolitan.h crt.o ape-no-modify-self.o cosmopolitan.a
-objcopy -S -O binary hello.com.dbg hello.com
+cosmocc -o hello hello.c
+./hello --strace
 ```
 
-You now have a portable program.
+To print a log of function calls to stderr:
 
 ```sh
-./hello.com
-bash -c './hello.com'  # older zsh/fish workaround (patched in zsh 5.9 and fish 3.3.0)
+cosmocc -o hello hello.c
+./hello --ftrace
 ```
 
-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):
+Both strace and ftrace use the unbreakable kprintf() facility, which is
+able to be sent to a file by setting an environment variable.
 
 ```sh
-sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
+export KPRINTF_LOG=log
+./hello --strace
 ```
 
-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 (the [APE loader](https://justine.lol/apeloader/))
-to `${TMPDIR:-${HOME:-.}}` that maps your program into memory without
-needing to copy it. The APE loader must be in an executable location
-(e.g. not stored on a `noexec` mount) for it to run. See below for
-alternatives:
-
-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
-bin/ape-install
-
-# System-Wide APE Uninstall
-# for Linux, Darwin, and BSDs
-bin/ape-uninstall
-```
-
-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
-hello.com: DOS/MBR boot sector
-./hello.com --assimilate
-$ file hello.com
-hello.com: ELF 64-bit LSB executable
-```
-
-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
-```
-
-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>.
-
 ## GDB
 
 Here's the recommended `~/.gdbinit` config:
@@ -542,39 +186,53 @@ You normally run the `.com.dbg` file under gdb. If you need to debug the
 gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
 ```
 
-## Alternative Development Environments
+## Platform Notes
 
-### MacOS
+### Shells
 
-If you're developing on MacOS you can install the GNU compiler
-collection for x86_64-elf via homebrew:
+If you use zsh and have trouble running APE programs try `sh -c ./prog`
+or simply upgrade to zsh 5.9+ (since we patched it two years ago). The
+same is the case for Python `subprocess`, old versions of fish, etc.
+
+### Linux
+
+Some Linux systems are configured to launch MZ executables under WINE.
+Other distros configure their stock installs so that APE programs will
+print "run-detectors: unable to find an interpreter". For example:
 
 ```sh
-brew install x86_64-elf-gcc
+jart@ubuntu:~$ wget https://cosmo.zip/pub/cosmos/bin/dash
+jart@ubuntu:~$ chmod +x dash
+jart@ubuntu:~$ ./dash
+run-detectors: unable to find an interpreter for ./dash
 ```
 
-Then in the above scripts just replace `gcc` and `objcopy` with
-`x86_64-elf-gcc` and `x86_64-elf-objcopy` to compile your APE binary.
-
-### Windows
-
-If you're developing on Windows then you need to download an
-x86_64-pc-linux-gnu toolchain beforehand. See the [Compiling on
-Windows](https://justine.lol/cosmopolitan/windows-compiling.html)
-tutorial. It's needed because the ELF object format is what makes
-universal binaries possible.
-
-Cosmopolitan officially only builds on Linux. However, one highly
-experimental (and currently broken) thing you could try, is building the
-entire cosmo repository from source using the cross9 toolchain.
+You can fix that by registering APE with `binfmt_misc`:
 
 ```sh
-mkdir -p o/third_party
-rm -rf o/third_party/gcc
-wget https://justine.lol/linux-compiler-on-windows/cross9.zip
-unzip cross9.zip
-mv cross9 o/third_party/gcc
-build/bootstrap/make.com
+sudo wget -O /usr/bin/ape https://cosmo.zip/pub/cosmos/bin/ape-$(uname -m).elf
+sudo chmod +x /usr/bin/ape
+sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
+sudo sh -c "echo ':APE-jart:M::jartsr::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
+```
+
+You should be good now. APE will not only work, it'll launch executables
+400µs faster now too. However if things still didn't work out, it's also
+possible to disable `binfmt_misc` as follows:
+
+```sh
+sudo sh -c 'echo -1 > /proc/sys/fs/binfmt_misc/cli'     # remove Ubuntu's MZ interpreter
+sudo sh -c 'echo -1 > /proc/sys/fs/binfmt_misc/status'  # remove ALL binfmt_misc entries
+```
+
+### WSL
+
+It's normally unsafe to use APE in a WSL environment, because it tries
+to run MZ executables as WIN32 binaries within the WSL environment. In
+order to make it safe to use Cosmopolitan software on WSL, run this:
+
+```sh
+sudo sh -c "echo -1 > /proc/sys/fs/binfmt_misc/WSLInterop"
 ```
 
 ## Discord Chatroom

ape/BUILD.mk

@@ -0,0 +1,284 @@
+#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
+#── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
+#
+# OVERVIEW
+#
+#   αcτµαlly pδrταblε εxεcµταblε
+#
+# DESCRIPTION
+#
+#   This file defines the libraries, runtimes, and build rules needed to
+#   create executables from your Linux workstation that'll run anywhere.
+#   Loading this package will make certain systemic modifications to the
+#   build like turning off the System V "Red Zone" optimization, because
+#   αcτµαlly pδrταblε εxεcµταblεs need to be able to run in kernelspace.
+
+PKGS += APE
+
+APE_FILES := $(wildcard ape/*.*)
+APE_HDRS = $(filter %.h,$(APE_FILES))
+APE_INCS = $(filter %.inc,$(APE_FILES))
+
+ifeq ($(ARCH), aarch64)
+
+APE = o/$(MODE)/ape/aarch64.lds
+
+APELINK =					\
+	$(COMPILE)				\
+	-ALINK.ape				\
+	$(LINK)					\
+	$(LINKARGS)				\
+	$(OUTPUT_OPTION) &&			\
+	$(COMPILE)				\
+	-AFIXUP.ape				\
+	-wT$@					\
+	$(FIXUPOBJ)				\
+	$@
+
+APE_SRCS = ape/ape.S ape/start.S ape/launch.S ape/systemcall.S
+APE_OBJS = o/$(MODE)/ape/ape.o
+APE_NO_MODIFY_SELF = $(APE)
+APE_COPY_SELF = $(APE)
+
+.PHONY: o/$(MODE)/ape
+o/$(MODE)/ape: $(APE)
+
+o/$(MODE)/ape/aarch64.lds:			\
+	ape/aarch64.lds				\
+	libc/zip.internal.h			\
+	libc/thread/tls.h			\
+	libc/calls/struct/timespec.h		\
+	libc/macros.internal.h			\
+	libc/str/str.h
+
+APE_LOADER_LDFLAGS =				\
+	-pie					\
+	-static					\
+	-nostdlib				\
+	--no-dynamic-linker			\
+	-z norelro				\
+	-z common-page-size=0x4000		\
+	-z max-page-size=0x4000
+
+APE_LOADER_FLAGS =				\
+	-DNDEBUG				\
+	-iquote.				\
+	-Wall					\
+	-Wextra					\
+	-fpie					\
+	-Os					\
+	-ffreestanding				\
+	-mgeneral-regs-only			\
+	-fno-asynchronous-unwind-tables		\
+	-fno-stack-protector			\
+	-fno-ident				\
+	-fno-gnu-unique				\
+	-c					\
+	 $(OUTPUT_OPTION)			\
+	$<
+
+o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
+	@$(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -g $< $@
+	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
+
+o/$(MODE)/ape/ape.elf.dbg:			\
+		o/$(MODE)/ape/start.o		\
+		o/$(MODE)/ape/loader.o		\
+		o/$(MODE)/ape/launch.o		\
+		o/$(MODE)/ape/systemcall.o
+	@$(COMPILE) -ALINK.elf $(LD) $(APE_LOADER_LDFLAGS) -o $@ $(patsubst %.lds,-T %.lds,$^)
+
+o/$(MODE)/ape/loader.o: ape/loader.c ape/ape.h
+	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=33 -g $(APE_LOADER_FLAGS)
+o/$(MODE)/ape/start.o: ape/start.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+o/$(MODE)/ape/launch.o: ape/launch.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+o/$(MODE)/ape/systemcall.o: ape/systemcall.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+
+.PHONY: o/$(MODE)/ape
+o/$(MODE)/ape: o/$(MODE)/ape/ape.elf
+
+else
+
+APE =	o/$(MODE)/ape/ape.o			\
+	o/$(MODE)/ape/ape.lds
+
+APELINK =					\
+	$(COMPILE)				\
+	-ALINK.ape				\
+	$(LINK)					\
+	$(LINKARGS)				\
+	$(OUTPUT_OPTION) &&			\
+	$(COMPILE)				\
+	-AFIXUP.ape				\
+	-wT$@					\
+	$(FIXUPOBJ)				\
+	$@
+
+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			\
+	o/$(MODE)/ape/ape-copy-self.o
+
+APE_LOADER_FLAGS =				\
+	-DNDEBUG				\
+	-iquote.				\
+	-Wall					\
+	-Wextra					\
+	-Werror					\
+	-pedantic-errors			\
+	-fpie					\
+	-Os					\
+	-ffreestanding				\
+	-mgeneral-regs-only			\
+	-fno-stack-protector			\
+	-fno-ident				\
+	-fno-gnu-unique				\
+	-c					\
+	 $(OUTPUT_OPTION)			\
+	$<
+
+APE_SRCS_C = ape/loader.c
+APE_SRCS_S = $(filter %.S,$(APE_FILES))
+APE_SRCS = $(APE_SRCS_C) $(APE_SRCS_S)
+APE_OBJS = $(APE_SRCS_S:%.S=o/$(MODE)/%.o)
+APE_CHECKS = $(APE_HDRS:%=o/%.ok)
+
+o/ape/idata.inc:				\
+		ape/idata.internal.h		\
+		ape/relocations.h
+
+o/$(MODE)/ape/ape-no-modify-self.o:		\
+		ape/ape.S			\
+		ape/ape.h			\
+		ape/macros.internal.h		\
+		ape/notice.inc			\
+		ape/relocations.h		\
+		ape/ape.internal.h		\
+		libc/dce.h			\
+		libc/elf/def.h			\
+		libc/thread/tls.h		\
+		libc/intrin/asancodes.h		\
+		libc/macho.internal.h		\
+		libc/macros.internal.h		\
+		libc/nexgen32e/uart.internal.h	\
+		libc/calls/metalfile.internal.h	\
+		libc/nt/pedef.internal.h	\
+		libc/runtime/e820.internal.h	\
+		libc/runtime/mman.internal.h	\
+		libc/runtime/pc.internal.h	\
+		libc/sysv/consts/prot.h		\
+		ape/blink-linux-aarch64.gz	\
+		ape/blink-xnu-aarch64.gz	\
+		o/$(MODE)/ape/ape.elf
+	@$(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			\
+		ape/ape.h			\
+		ape/macros.internal.h		\
+		ape/notice.inc			\
+		ape/relocations.h		\
+		ape/ape.internal.h		\
+		libc/dce.h			\
+		libc/elf/def.h			\
+		libc/thread/tls.h		\
+		libc/intrin/asancodes.h		\
+		libc/macho.internal.h		\
+		libc/macros.internal.h		\
+		libc/nexgen32e/uart.internal.h	\
+		libc/calls/metalfile.internal.h	\
+		libc/nt/pedef.internal.h	\
+		libc/runtime/e820.internal.h	\
+		libc/runtime/mman.internal.h	\
+		libc/runtime/pc.internal.h	\
+		libc/sysv/consts/prot.h		\
+		ape/blink-linux-aarch64.gz	\
+		ape/blink-xnu-aarch64.gz
+	@$(COMPILE)				\
+		-AOBJECTIFY.S			\
+		$(OBJECTIFY.S)			\
+		$(OUTPUT_OPTION)		\
+		-DAPE_NO_MODIFY_SELF $<
+
+o/$(MODE)/ape/loader.o: ape/loader.c
+	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=121 -g $(APE_LOADER_FLAGS)
+o/$(MODE)/ape/loader-gcc.asm: ape/loader.c
+	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=121 -S -g0 $(APE_LOADER_FLAGS)
+o/$(MODE)/ape/loader-clang.asm: ape/loader.c
+	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=121 -S -g0 $(APE_LOADER_FLAGS)
+
+o/$(MODE)/ape/loader-xnu.o: ape/loader.c
+	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=8 -g $(APE_LOADER_FLAGS)
+o/$(MODE)/ape/loader-xnu-gcc.asm: ape/loader.c
+	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
+o/$(MODE)/ape/loader-xnu-clang.asm: ape/loader.c
+	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
+
+o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
+	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy.com -f -o $@ $<
+
+o/$(MODE)/ape/ape.macho: o/$(MODE)/ape/ape.elf.dbg
+	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy.com -fm -o $@ $<
+
+APE_LOADER_LDFLAGS =				\
+	-static					\
+	-nostdlib				\
+	--no-dynamic-linker			\
+	-z separate-code			\
+	-z common-page-size=0x1000		\
+	-z max-page-size=0x10000
+
+o/$(MODE)/ape/ape.elf.dbg:			\
+		o/$(MODE)/ape/loader-macho.o	\
+		o/$(MODE)/ape/start.o		\
+		o/$(MODE)/ape/loader.o		\
+		o/$(MODE)/ape/launch.o		\
+		o/$(MODE)/ape/systemcall.o	\
+		ape/loader.lds
+	@$(COMPILE) -ALINK.elf $(LD) $(APE_LOADER_LDFLAGS) -o $@ $(patsubst %.lds,-T %.lds,$^)
+
+.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-no-modify-self.o
+
+endif
+
+# these assembly files are safe to build on aarch64
+o/$(MODE)/ape/ape.o: ape/ape.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+
+o/$(MODE)/ape/ape.o:				\
+		ape/blink-linux-aarch64.gz	\
+		ape/blink-xnu-aarch64.gz
+
+o/$(MODE)/ape/ape.lds:				\
+		ape/ape.lds			\
+		ape/macros.internal.h		\
+		ape/relocations.h		\
+		ape/ape.internal.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.internal.h

ape/aarch64.lds

@@ -1,5 +1,5 @@
 /*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
-│vi: set et sts=2 tw=2 fenc=utf-8                                           :vi│
+│ vi: set et sts=2 sw=2 fenc=utf-8                                         :vi │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/thread/tls.h"
 

ape/ape-m1.c

@@ -1,5 +1,5 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2021 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include <assert.h>
 #include <dispatch/dispatch.h>
 #include <dlfcn.h>
 #include <errno.h>
@@ -34,9 +35,11 @@
 #include <time.h>
 #include <unistd.h>
 
-#define pagesz         16384
+#define pagesz 16384
+/* maximum path size that cosmo can take */
+#define PATHSIZE       (PATH_MAX < 1024 ? PATH_MAX : 1024)
 #define SYSLIB_MAGIC   ('s' | 'l' << 8 | 'i' << 16 | 'b' << 24)
-#define SYSLIB_VERSION 7
+#define SYSLIB_VERSION 8
 
 struct Syslib {
   int magic;
@@ -62,7 +65,7 @@ struct Syslib {
   /* v2 (2023-09-10) */
   pthread_t (*pthread_self)(void);
   void (*dispatch_release)(dispatch_semaphore_t);
-  int (*raise)(int);
+  long (*raise)(int);
   int (*pthread_join)(pthread_t, void **);
   void (*pthread_yield_np)(void);
   int pthread_stack_min;
@@ -194,10 +197,11 @@ union ElfPhdrBuf {
 
 struct PathSearcher {
   int literally;
+  int indirect;
   unsigned long namelen;
   const char *name;
   const char *syspath;
-  char path[1024];
+  char path[PATHSIZE];
 };
 
 struct ApeLoader {
@@ -220,16 +224,8 @@ static int StrCmp(const char *l, const char *r) {
 }
 
 static const char *BaseName(const char *s) {
-  int c;
-  const char *b = "";
-  if (s) {
-    while ((c = *s++)) {
-      if (c == '/') {
-        b = s;
-      }
-    }
-  }
-  return b;
+  const char *b = strrchr(s, '/');
+  return b ? b + 1 : s;
 }
 
 static char *GetEnv(char **p, const char *s) {
@@ -297,6 +293,14 @@ static long Print(int fd, const char *s, ...) {
   return write(fd, b, n);
 }
 
+static int GetIndirectOffset(const char *arg0) {
+  char *tail = strrchr(arg0, '.');
+  if (tail && !StrCmp(tail + 1, "ape")) {
+    return tail - arg0;
+  }
+  return 0;
+}
+
 static void Perror(const char *thing, long rc, const char *reason) {
   char ibuf[21];
   ibuf[0] = 0;
@@ -312,11 +316,23 @@ __attribute__((__noreturn__)) static void Pexit(const char *c, int failed,
 }
 
 static char AccessCommand(struct PathSearcher *ps, unsigned long pathlen) {
-  if (pathlen + 1 + ps->namelen + 1 > sizeof(ps->path)) return 0;
+  if (pathlen + 1 + ps->namelen + 1 > sizeof(ps->path)) {
+    return 0;
+  }
   if (pathlen && ps->path[pathlen - 1] != '/') ps->path[pathlen++] = '/';
   memmove(ps->path + pathlen, ps->name, ps->namelen);
   ps->path[pathlen + ps->namelen] = 0;
-  return !access(ps->path, X_OK);
+  if (!access(ps->path, X_OK)) {
+    if (ps->indirect) {
+      ps->namelen -= 4;
+      ps->path[pathlen + ps->namelen] = 0;
+      if (access(ps->path, X_OK) < 0) {
+        Pexit(ps->path, -errno, "access(X_OK)");
+      }
+    }
+    return 1;
+  }
+  return 0;
 }
 
 static char SearchPath(struct PathSearcher *ps) {
@@ -441,6 +457,10 @@ static long sys_close(int fd) {
   return sysret(close(fd));
 }
 
+static long sys_raise(int sig) {
+  return sysret(raise(sig));
+}
+
 static long sys_pipe(int pfds[2]) {
   return sysret(pipe(pfds));
 }
@@ -533,7 +553,8 @@ static long sys_pselect(int nfds, fd_set *readfds, fd_set *writefds,
 __attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
                                                 long *sp, struct ElfEhdr *e,
                                                 struct ElfPhdr *p,
-                                                struct Syslib *lib) {
+                                                struct Syslib *lib,
+                                                char *path) {
   long rc;
   int prot;
   int flags;
@@ -625,7 +646,6 @@ __attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
 
     /* load from file */
     if (p[i].p_filesz) {
-      long map1, map2;
       int prot1, prot2;
       unsigned long wipe;
       prot1 = prot;
@@ -649,22 +669,33 @@ __attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
       addr = (void *)(dynbase + (p[i].p_vaddr & -pagesz));
       size = (p[i].p_vaddr & (pagesz - 1)) + p[i].p_filesz;
       if (prot1 & PROT_EXEC) {
+#ifdef SIP_DISABLED
         // if sip is disabled then we can load the executable segments
-        // of the binary into memory without needing to copy anything!
+        // off the binary into memory without needing to copy anything
+        // which provides considerably better performance for building
         rc = sys_mmap(addr, size, prot1, flags, fd, p[i].p_offset & -pagesz);
         if (rc < 0) {
-          if (rc != -EPERM) Pexit(exe, rc, "mmap(exec)");
-          // apple arm64 won't allow PROT_EXEC mapping any unsigned file
-          // however we are allowed to copy it into an anonymous mapping
-          map1 = sys_mmap(0, size, PROT_READ, MAP_PRIVATE, fd,
-                          p[i].p_offset & -pagesz);
-          if (map1 < 0) Pexit(exe, map1, "mmap(exec) workaround input");
-          map2 = sys_mmap(addr, size, (prot1 = PROT_READ | PROT_WRITE),
-                          MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
-          if (map2 < 0) Pexit(exe, map2, "mmap(exec) workaround output");
-          memcpy((void *)map2, (void *)map1, size);
-          munmap((void *)map1, size);
+          if (rc == -EPERM) {
+            Pexit(exe, rc,
+                  "map(exec) failed because SIP (System Integrity Protection) "
+                  "is enabled, but APE Loader was compiled with SIP_DISABLED");
+          } else {
+            Pexit(exe, rc, "map(exec) failed");
+          }
         }
+#else
+        // the issue is that if sip is enabled then, attempting to map
+        // it with exec permission will cause xnu to phone home a hash
+        // of the entire file to apple intelligence as a one time cost
+        // which is literally minutes for executables holding big data
+        // since there's no public apple api for detecting sip we read
+        // as the default strategy which is slow but it works for both
+        rc = sys_mmap(addr, size, (prot1 = PROT_READ | PROT_WRITE),
+                      MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
+        if (rc < 0) Pexit(exe, rc, "prog mmap anon");
+        rc = pread(fd, addr, p[i].p_filesz, p[i].p_offset & -pagesz);
+        if (rc != p[i].p_filesz) Pexit(exe, -errno, "prog pread");
+#endif
       } else {
         rc = sys_mmap(addr, size, prot1, flags, fd, p[i].p_offset & -pagesz);
         if (rc < 0) Pexit(exe, rc, "prog mmap");
@@ -694,11 +725,11 @@ __attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
   close(fd);
 
   register long *x0 __asm__("x0") = sp;
+  register char *x2 __asm__("x2") = path;
+  register int x3 __asm__("x3") = 8; /* _HOSTXNU */
   register struct Syslib *x15 __asm__("x15") = lib;
   register long x16 __asm__("x16") = e->e_entry;
   __asm__ volatile("mov\tx1,#0\n\t"
-                   "mov\tx2,#0\n\t"
-                   "mov\tx3,#0\n\t"
                    "mov\tx4,#0\n\t"
                    "mov\tx5,#0\n\t"
                    "mov\tx6,#0\n\t"
@@ -727,7 +758,7 @@ __attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
                    "mov\tx0,#0\n\t"
                    "br\tx16"
                    : /* no outputs */
-                   : "r"(x0), "r"(x15), "r"(x16)
+                   : "r"(x0), "r"(x2), "r"(x3), "r"(x15), "r"(x16)
                    : "memory");
   __builtin_unreachable();
 }
@@ -851,7 +882,7 @@ static const char *TryElf(struct ApeLoader *M, union ElfEhdrBuf *ebuf,
   auxv[28] = 0;
 
   /* we're now ready to load */
-  Spawn(exe, fd, sp, e, p, &M->lib);
+  Spawn(exe, fd, sp, e, p, &M->lib, M->ps.path);
 }
 
 int main(int argc, char **argv, char **envp) {
@@ -860,7 +891,7 @@ int main(int argc, char **argv, char **envp) {
   struct ApeLoader *M;
   long *sp, *sp2, *auxv;
   union ElfEhdrBuf *ebuf;
-  char *p, *pe, *exe, *prog, *execfn;
+  char *p, *pe, *exe, *prog, *execfn, *shell;
 
   /* allocate loader memory in program's arg block */
   n = sizeof(struct ApeLoader);
@@ -877,6 +908,7 @@ int main(int argc, char **argv, char **envp) {
   M->lib.pthread_jit_write_protect_supported_np =
       pthread_jit_write_protect_supported_np;
   M->lib.pthread_jit_write_protect_np = pthread_jit_write_protect_np_workaround;
+  M->lib.sys_icache_invalidate = sys_icache_invalidate;
   M->lib.pthread_create = pthread_create;
   M->lib.pthread_exit = pthread_exit;
   M->lib.pthread_kill = pthread_kill;
@@ -888,7 +920,7 @@ int main(int argc, char **argv, char **envp) {
   M->lib.dispatch_walltime = dispatch_walltime;
   M->lib.pthread_self = pthread_self;
   M->lib.dispatch_release = dispatch_release;
-  M->lib.raise = raise;
+  M->lib.raise = sys_raise;
   M->lib.pthread_join = pthread_join;
   M->lib.pthread_yield_np = pthread_yield_np;
   M->lib.pthread_stack_min = PTHREAD_STACK_MIN;
@@ -933,28 +965,6 @@ int main(int argc, char **argv, char **envp) {
   sp = (long *)(argv - 1);
   auxv = (long *)(envp + i + 1);
 
-  /* interpret command line arguments */
-  if ((M->ps.literally = argc >= 3 && !StrCmp(argv[1], "-"))) {
-    /* if the first argument is a hyphen then we give the user the
-       power to change argv[0] or omit it entirely. most operating
-       systems don't permit the omission of argv[0] but we do, b/c
-       it's specified by ANSI X3.159-1988. */
-    prog = (char *)sp[3];
-    argc = sp[3] = sp[0] - 3;
-    argv = (char **)((sp += 3) + 1);
-  } else if (argc < 2) {
-    Emit("usage: ape   PROG [ARGV1,ARGV2,...]\n"
-         "       ape - PROG [ARGV0,ARGV1,...]\n"
-         "actually portable executable loader silicon 1.9\n"
-         "copyright 2023 justine alexandra roberts tunney\n"
-         "https://justine.lol/ape.html\n");
-    _exit(1);
-  } else {
-    prog = (char *)sp[2];
-    argc = sp[1] = sp[0] - 1;
-    argv = (char **)((sp += 1) + 1);
-  }
-
   /* create new bottom of stack for spawned program
      system v abi aligns this on a 16-byte boundary
      grows down the alloc by poking the guard pages */
@@ -967,9 +977,51 @@ int main(int argc, char **argv, char **envp) {
   memmove(sp2, sp, (auxv - sp) * sizeof(long));
   argv = (char **)(sp2 + 1);
   envp = (char **)(sp2 + 1 + argc + 1);
-  auxv = sp2 + (auxv - sp);
+  auxv = (long *)(envp + i + 1);
   sp = sp2;
 
+  /* interpret command line arguments */
+  if ((M->ps.indirect = argc > 0 ? GetIndirectOffset(argv[0]) : 0)) {
+    /* if argv[0] is $prog.ape, then we strip off the .ape and run
+       $prog. This allows you to use symlinks to trick the OS when
+       a native executable is required. For example, let's say you
+       want to use the APE binary /opt/cosmos/bin/bash as a system
+       shell in /etc/shells, or perhaps in shebang lines like e.g.
+       `#!/opt/cosmos/bin/bash`. That won't work with APE normally,
+       but it will if you say:
+           ln -sf /usr/local/bin/ape /opt/cosmos/bin/bash.ape
+       and then use #!/opt/cosmos/bin/bash.ape instead. */
+    M->ps.literally = 0;
+    if (*argv[0] == '-' && (shell = GetEnv(envp, "SHELL")) &&
+        !StrCmp(argv[0] + 1, BaseName(shell))) {
+      execfn = prog = shell;
+    } else {
+      prog = (char *)sp[1];
+    }
+    argc = sp[0];
+    argv = (char **)(sp + 1);
+  } else if ((M->ps.literally = argc >= 3 && !StrCmp(argv[1], "-"))) {
+    /* if the first argument is a hyphen then we give the user the
+       power to change argv[0] or omit it entirely. most operating
+       systems don't permit the omission of argv[0] but we do, b/c
+       it's specified by ANSI X3.159-1988. */
+    prog = (char *)sp[3];
+    argc = sp[3] = sp[0] - 3;
+    argv = (char **)((sp += 3) + 1);
+  } else if (argc < 2) {
+    Emit("usage: ape   PROG [ARGV1,ARGV2,...]\n"
+         "       ape - PROG [ARGV0,ARGV1,...]\n"
+         "  ($0 = PROG.ape) [ARGV1,ARGV2,...]\n"
+         "actually portable executable loader silicon 1.10\n"
+         "copyrights 2023 justine alexandra roberts tunney\n"
+         "https://justine.lol/ape.html\n");
+    _exit(1);
+  } else {
+    prog = (char *)sp[2];
+    argc = sp[1] = sp[0] - 1;
+    argv = (char **)((sp += 1) + 1);
+  }
+
   /* allocate ephemeral memory for reading file */
   n = sizeof(union ElfEhdrBuf);
   ebuf = (union ElfEhdrBuf *)__builtin_alloca(n);
@@ -989,12 +1041,6 @@ int main(int argc, char **argv, char **envp) {
   }
   pe = ebuf->buf + rc;
 
-  /* resolve argv[0] to reflect path search */
-  if (argc > 0 && ((*prog != '/' && *exe == '/' && !StrCmp(prog, argv[0])) ||
-                   !StrCmp(BaseName(prog), argv[0]))) {
-    argv[0] = exe;
-  }
-
   /* generate some hard random data */
   if ((rc = sys_getentropy(M->rando, sizeof(M->rando))) < 0) {
     Pexit(argv[0], rc, "getentropy");

ape/ape.S

@@ -1,5 +1,5 @@
 /*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2020 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
@@ -592,7 +592,7 @@ ape_disk:
 
 #ifdef APE_IS_SHELL_SCRIPT
 apesh:	.ascii	"\n@\n#'\"\n"			// sixth edition shebang
-	.ascii	"m=\"$(uname -m)\"\n"
+	.ascii	"m=$(uname -m 2>/dev/null) || m=x86_64\n"
 
 	.ascii	"if [ \"$m\" = x86_64 ] || [ \"$m\" = amd64 ]; then\n"
 //	Until all operating systems can be updated to support APE,
@@ -710,7 +710,7 @@ apesh:	.ascii	"\n@\n#'\"\n"			// sixth edition shebang
 //	because they need to be in the first 4096 bytes
         .section .emushprologue,"a",@progbits
 emush:	.ascii	"\n@\n#'\"\n"
-	.ascii	"s=\"$(uname -s)\"\n"
+	.ascii	"s=$(uname -s 2>/dev/null) || s=Darwin\n"
 //	our script is running on a non-x86_64 architecture
 //	1. `dd` out the appropriate blink vm blob
 //	2. gunzip the blink virtual machine executable
@@ -748,6 +748,8 @@ ape_loader_end:
 #if SupportsSystemv() || SupportsMetal()
 	.section .elf.phdrs,"a",@progbits
 
+	.globl	ape_phdrs
+ape_phdrs:
 	.long	PT_LOAD
 	.long	PF_R|PF_X
 	.stub	ape_cod_offset,quad

ape/ape.h

@@ -2,7 +2,7 @@
 #define COSMOPOLITAN_APE_APE_H_
 
 #define APE_VERSION_MAJOR 1
-#define APE_VERSION_MINOR 9
+#define APE_VERSION_MINOR 10
 #define APE_VERSION_STR   APE_VERSION_STR_(APE_VERSION_MAJOR, APE_VERSION_MINOR)
 #define APE_VERSION_NOTE  APE_VERSION_NOTE_(APE_VERSION_MAJOR, APE_VERSION_MINOR)
 

ape/ape.lds

@@ -1,5 +1,5 @@
 /*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
-│vi: set et sts=2 tw=2 fenc=utf-8                                           :vi│
+│ vi: set et sts=2 sw=2 fenc=utf-8                                         :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2020 Justine Alexandra Roberts Tunney                              │
 │                                                                              │

ape/ape.mk

@@ -1,287 +0,0 @@
-#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘
-#
-# OVERVIEW
-#
-#   αcτµαlly pδrταblε εxεcµταblε
-#
-# DESCRIPTION
-#
-#   This file defines the libraries, runtimes, and build rules needed to
-#   create executables from your Linux workstation that'll run anywhere.
-#   Loading this package will make certain systemic modifications to the
-#   build like turning off the System V "Red Zone" optimization, because
-#   αcτµαlly pδrταblε εxεcµταblεs need to be able to run in kernelspace.
-
-PKGS += APE
-
-APE_FILES := $(wildcard ape/*.*)
-APE_HDRS = $(filter %.h,$(APE_FILES))
-APE_INCS = $(filter %.inc,$(APE_FILES))
-
-ifeq ($(ARCH), aarch64)
-
-APE = o/$(MODE)/ape/aarch64.lds
-
-APELINK =					\
-	$(COMPILE)				\
-	-ALINK.ape				\
-	$(LINK)					\
-	$(LINKARGS)				\
-	$(OUTPUT_OPTION) &&			\
-	$(COMPILE)				\
-	-AFIXUP.ape				\
-	-wT$@					\
-	$(FIXUPOBJ)				\
-	$@
-
-APE_SRCS = ape/ape.S ape/start.S ape/launch.S ape/systemcall.S
-APE_OBJS = o/$(MODE)/ape/ape.o
-APE_NO_MODIFY_SELF = $(APE)
-APE_COPY_SELF = $(APE)
-
-.PHONY: o/$(MODE)/ape
-o/$(MODE)/ape: $(APE)
-
-o/$(MODE)/ape/aarch64.lds:			\
-	ape/aarch64.lds				\
-	libc/zip.internal.h			\
-	libc/intrin/bits.h			\
-	libc/thread/tls.h			\
-	libc/calls/struct/timespec.h		\
-	libc/macros.internal.h			\
-	libc/str/str.h
-
-APE_LOADER_LDFLAGS =				\
-	-pie					\
-	-static					\
-	-nostdlib				\
-	--no-dynamic-linker			\
-	-z norelro				\
-	-z common-page-size=0x4000		\
-	-z max-page-size=0x4000
-
-APE_LOADER_FLAGS =				\
-	-DNDEBUG				\
-	-iquote.				\
-	-Wall					\
-	-Wextra					\
-	-fpie					\
-	-Os					\
-	-ffreestanding				\
-	-mgeneral-regs-only			\
-	-fno-asynchronous-unwind-tables		\
-	-fno-stack-protector			\
-	-fno-ident				\
-	-fno-gnu-unique				\
-	-c					\
-	 $(OUTPUT_OPTION)			\
-	$<
-
-o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
-	$(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -g $< $@
-
-o/$(MODE)/ape/ape.elf.dbg:			\
-		o/$(MODE)/ape/start.o		\
-		o/$(MODE)/ape/loader.o		\
-		o/$(MODE)/ape/launch.o		\
-		o/$(MODE)/ape/systemcall.o
-	@$(COMPILE) -ALINK.elf $(LD) $(APE_LOADER_LDFLAGS) -o $@ $(patsubst %.lds,-T %.lds,$^)
-
-o/$(MODE)/ape/loader.o: ape/loader.c ape/ape.h
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=1 -g $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/start.o: ape/start.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/ape/launch.o: ape/launch.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/ape/systemcall.o: ape/systemcall.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-
-.PHONY: o/$(MODE)/ape
-o/$(MODE)/ape: o/$(MODE)/ape/ape.elf
-
-else
-
-APE =	o/$(MODE)/ape/ape.o			\
-	o/$(MODE)/ape/ape.lds
-
-APELINK =					\
-	$(COMPILE)				\
-	-ALINK.ape				\
-	$(LINK)					\
-	$(LINKARGS)				\
-	$(OUTPUT_OPTION) &&			\
-	$(COMPILE)				\
-	-AFIXUP.ape				\
-	-wT$@					\
-	$(FIXUPOBJ)				\
-	$@
-
-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			\
-	o/$(MODE)/ape/ape-copy-self.o
-
-APE_LOADER_FLAGS =				\
-	-DNDEBUG				\
-	-iquote.				\
-	-Wall					\
-	-Wextra					\
-	-Werror					\
-	-pedantic-errors			\
-	-fpie					\
-	-Os					\
-	-ffreestanding				\
-	-mgeneral-regs-only			\
-	-fno-stack-protector			\
-	-fno-ident				\
-	-fno-gnu-unique				\
-	-c					\
-	 $(OUTPUT_OPTION)			\
-	$<
-
-APE_SRCS_C = ape/loader.c
-APE_SRCS_S = $(filter %.S,$(APE_FILES))
-APE_SRCS = $(APE_SRCS_C) $(APE_SRCS_S)
-APE_OBJS = $(APE_SRCS_S:%.S=o/$(MODE)/%.o)
-APE_CHECKS = $(APE_HDRS:%=o/%.ok)
-
-o/ape/idata.inc:				\
-		ape/idata.internal.h		\
-		ape/relocations.h
-
-o/$(MODE)/ape/ape-no-modify-self.o:		\
-		ape/ape.S			\
-		ape/ape.h			\
-		ape/macros.internal.h		\
-		ape/notice.inc			\
-		ape/relocations.h		\
-		ape/ape.internal.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/thread/tls.h		\
-		libc/intrin/asancodes.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
-		libc/nexgen32e/uart.internal.h	\
-		libc/calls/metalfile.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/sysv/consts/prot.h		\
-		ape/blink-linux-aarch64.gz	\
-		ape/blink-xnu-aarch64.gz	\
-		o/$(MODE)/ape/ape.elf
-	@$(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			\
-		ape/ape.h			\
-		ape/macros.internal.h		\
-		ape/notice.inc			\
-		ape/relocations.h		\
-		ape/ape.internal.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/thread/tls.h		\
-		libc/intrin/asancodes.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
-		libc/nexgen32e/uart.internal.h	\
-		libc/calls/metalfile.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/sysv/consts/prot.h		\
-		ape/blink-linux-aarch64.gz	\
-		ape/blink-xnu-aarch64.gz
-	@$(COMPILE)				\
-		-AOBJECTIFY.S			\
-		$(OBJECTIFY.S)			\
-		$(OUTPUT_OPTION)		\
-		-DAPE_NO_MODIFY_SELF $<
-
-o/$(MODE)/ape/loader.o: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=121 -g $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-gcc.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=121 -S -g0 $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-clang.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=121 -S -g0 $(APE_LOADER_FLAGS)
-
-o/$(MODE)/ape/loader-xnu.o: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=8 -g $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-xnu-gcc.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-xnu-clang.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
-
-o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
-	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy.com -f -o $@ $<
-
-o/$(MODE)/ape/ape.macho: o/$(MODE)/ape/ape.elf.dbg
-	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy.com -fm -o $@ $<
-
-APE_LOADER_LDFLAGS =				\
-	-static					\
-	-nostdlib				\
-	--no-dynamic-linker			\
-	-z separate-code			\
-	-z common-page-size=0x1000		\
-	-z max-page-size=0x10000
-
-o/$(MODE)/ape/ape.elf.dbg:			\
-		o/$(MODE)/ape/loader-macho.o	\
-		o/$(MODE)/ape/start.o		\
-		o/$(MODE)/ape/loader.o		\
-		o/$(MODE)/ape/launch.o		\
-		o/$(MODE)/ape/systemcall.o	\
-		ape/loader.lds
-	@$(COMPILE) -ALINK.elf $(LD) $(APE_LOADER_LDFLAGS) -o $@ $(patsubst %.lds,-T %.lds,$^)
-
-.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-no-modify-self.o
-
-endif
-
-# these assembly files are safe to build on aarch64
-o/$(MODE)/ape/ape.o: ape/ape.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-
-o/$(MODE)/ape/ape.o:				\
-		ape/blink-linux-aarch64.gz	\
-		ape/blink-xnu-aarch64.gz
-
-o/$(MODE)/ape/ape.lds:				\
-		ape/ape.lds			\
-		ape/macros.internal.h		\
-		ape/relocations.h		\
-		ape/ape.internal.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.internal.h

ape/apeinstall.sh

@@ -1 +0,0 @@
-../bin/ape-install

ape/apeinstall.sh

@@ -0,0 +1,175 @@
+#!/bin/sh
+
+PROG=${0##*/}
+MODE=${MODE:-$m}
+TMPDIR=${TMPDIR:-/tmp}
+COSMO=${COSMO:-/opt/cosmo}
+COSMOS=${COSMOS:-/opt/cosmos}
+
+if [ ! -f ape/loader.c ]; then
+  cd "$COSMO" || exit
+fi
+
+if [ -x build/bootstrap/make.com ]; then
+  MAKE=build/bootstrap/make.com
+else
+  MAKE=make
+fi
+
+if [ "$(id -u)" -eq 0 ]; then
+  SUDO=
+else
+  SUDO=sudo
+fi
+
+if command -v install >/dev/null 2>&1; then
+  if [ x"$(uname -s)" = xLinux ]; then
+    INSTALL="install -o root -g root -m 755"
+  else
+    INSTALL="install -o root -g wheel -m 755"
+  fi
+else
+  INSTALL="cp -f"
+fi
+
+echo "Actually Portable Executable (APE) Installer" >&2
+echo "Author:  Justine Tunney <[email protected]>"  >&2
+
+# special installation process for apple silicon
+if [ x"$(uname -s)" = xDarwin ] && [ x"$(uname -m)" = xarm64 ]; then
+  echo "cc -O -o $TMPDIR/ape.$$ ape/ape-m1.c" >&2
+  cc -O -o "$TMPDIR/ape.$$" ape/ape-m1.c || exit
+  trap 'rm "$TMPDIR/ape.$$"' EXIT
+  if [ ! -d /usr/local/bin ]; then
+    echo "$SUDO mkdir -p /usr/local/bin" >&2
+    $SUDO mkdir -p /usr/local/bin || exit
+  fi
+  echo "$SUDO $INSTALL $TMPDIR/ape.$$ /usr/local/bin/ape" >&2
+  $SUDO $INSTALL "$TMPDIR/ape.$$" /usr/local/bin/ape || exit
+  exit
+fi
+
+if [ x"$(uname -m)" = xarm64 ] || [ x"$(uname -m)" = xaarch64 ]; then
+  MODE=aarch64
+  EXT=elf
+  BEXT=aarch64
+elif [ x"$(uname -m)" = xx86_64 ]; then
+  MODE=
+  if [ x"$(uname -s)" = xDarwin ]; then
+    EXT=macho
+  else
+    EXT=elf
+  fi
+  BEXT=$EXT
+else
+  echo "unsupported architecture $(uname -m)" >&2
+  exit
+fi
+
+################################################################################
+# INSTALL APE LOADER SYSTEMWIDE
+
+if [ -f o/$MODE/depend ] && $MAKE -j8 o/$MODE/ape; then
+  echo "successfully recompiled ape loader" >&2
+elif [ -x o/$MODE/ape/ape.$EXT ]; then
+  echo "using ape loader you compiled earlier" >&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/$MODE/ape || exit
+  cp -af build/bootstrap/ape.$BEXT o/$MODE/ape/ape.$EXT || exit
+else
+  echo "no cosmopolitan libc repository here" >&2
+  echo "fetching ape loader from justine.lol" >&2
+  mkdir -p o/$MODE/ape || exit
+  if command -v wget >/dev/null 2>&1; then
+    wget -qO o/$MODE/ape/ape.$EXT https://justine.lol/ape.$BEXT || exit
+  else
+    curl -Rso o/$MODE/ape/ape.$EXT https://justine.lol/ape.$BEXT || exit
+  fi
+  chmod +x o/$MODE/ape/ape.$EXT || exit
+fi
+
+if ! [ /usr/bin/ape -nt o/$MODE/ape/ape.$EXT ]; then
+  echo >&2
+  echo "installing o/$MODE/ape/ape.$EXT to /usr/bin/ape" >&2
+  echo "$SUDO $INSTALL o/$MODE/ape/ape.$EXT /usr/bin/ape" >&2
+  $SUDO $INSTALL o/$MODE/ape/ape.$EXT /usr/bin/ape || exit
+  echo "done" >&2
+fi
+
+################################################################################
+# 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
+
+  uname_r="$(uname -r)"
+  if printf '%s\n%s\n' 5.12 "$uname_r" | sort -CV; then
+    FLAGS=FP
+  else
+    FLAGS=F
+  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:'"$FLAGS'"' >/proc/sys/fs/binfmt_misc/register"' >&2
+  $SUDO sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:$FLAGS' >/proc/sys/fs/binfmt_misc/register" || exit
+  echo '$SUDO sh -c "echo '"'"':APE-jart:M::jartsr::/usr/bin/ape:'"$FLAGS'"' >/proc/sys/fs/binfmt_misc/register"' >&2
+  $SUDO sh -c "echo ':APE-jart:M::jartsr::/usr/bin/ape:$FLAGS' >/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
+
+################################################################################
+
+{
+  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

ape/apeuninstall.sh

@@ -1 +0,0 @@
-../bin/ape-uninstall

ape/apeuninstall.sh

@@ -0,0 +1,65 @@
+#!/bin/sh
+
+PROG=${0##*/}
+MODE=${MODE:-$m}
+COSMO=${COSMO:-/opt/cosmo}
+COSMOS=${COSMOS:-/opt/cosmos}
+
+if [ ! -f ape/loader.c ]; then
+  cd "$COSMO" || exit
+fi
+
+if [ "$UID" = "0" ]; then
+  SUDO=
+else
+  SUDO=sudo
+fi
+
+{
+  echo
+  echo "APE Uninstaller intends to run (in pseudo-shell)"
+  echo
+  echo "    sudo echo -1 into /proc/sys/fs/binfmt_misc/APE*"
+  echo "    sudo rm -f /usr/bin/ape ~/.ape /tmp/.ape # etc."
+  echo
+  echo "You may then use ape/apeinstall.sh to reinstall it"
+  echo
+} >&2
+
+set -ex
+for f in /proc/sys/fs/binfmt_misc/APE*; do
+  if [ -f $f ]; then
+    $SUDO sh -c "echo -1 >$f" || exit
+  fi
+done
+
+# system installation
+if [ -f /usr/bin/ape ]; then
+  $SUDO rm -f /usr/bin/ape
+fi
+if [ -f /usr/local/bin/ape ]; then
+  $SUDO rm -f /usr/local/bin/ape
+fi
+
+# legacy installations
+rm -f o/tmp/ape /tmp/ape "${TMPDIR:-/tmp}/ape"
+
+# ad-hoc installations
+for x in .ape \
+         .ape-1.1 \
+         .ape-1.3 \
+         .ape-1.4 \
+         .ape-1.5 \
+         .ape-1.6 \
+         .ape-1.7 \
+         .ape-1.8 \
+         .ape-1.9 \
+         .ape-1.10 \
+         .ape-blink-0.9.2 \
+         .ape-blink-1.0.0; do
+  rm -f \
+     ~/$x \
+     /tmp/$x \
+     o/tmp/$x \
+     "${TMPDIR:-/tmp}/$x"
+done

ape/idata.internal.h

@@ -1,5 +1,5 @@
 /*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│vi: set et ft=asm ts=8 sw=8 fenc=utf-8                                     :vi│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2020 Justine Alexandra Roberts Tunney                              │
 │                                                                              │

ape/launch.S

@@ -1,5 +1,5 @@
 /*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2023 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
@@ -31,17 +31,16 @@
 //
 //	@param	rdi is passed through as-is
 //	@param	rsi is address of entrypoint (becomes zero)
-//	@param	rdx is stack pointer (becomes zero)
+//	@param	rdx is passed through as-is
 //	@param	rcx is passed through as-is
+//	@param	r8  is stack pointer (becomes zero)
 //	@noreturn
 Launch:
 #ifdef __aarch64__
 
 	mov	x16,x1
-	mov	sp,x2
+	mov	sp,x4
 	mov	x1,0
-	mov	x2,0
-	mov	x3,0
 	mov	x4,0
 	mov	x5,0
 	mov	x6,0
@@ -71,6 +70,7 @@ Launch:
 
 #else
 
+	mov	%r8,%rsp
 	xor	%r8d,%r8d
 	xor	%r9d,%r9d
 	xor	%r10d,%r10d
@@ -79,8 +79,6 @@ Launch:
 	xor	%r13d,%r13d
 	xor	%r14d,%r14d
 	xor	%r15d,%r15d
-	mov	%rdx,%rsp
-	xor	%edx,%edx
 	push	%rsi
 	xor	%esi,%esi
 	xor	%ebp,%ebp

ape/loader-macho.S

@@ -1,5 +1,5 @@
 /*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2021 Justine Alexandra Roberts Tunney                              │
 │                                                                              │

ape/loader.c

@@ -1,5 +1,5 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2021 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
@@ -87,6 +87,8 @@
 #define MIN(X, Y) ((Y) > (X) ? (X) : (Y))
 #define MAX(X, Y) ((Y) < (X) ? (X) : (Y))
 
+#define PATH_MAX 1024 /* XXX verify */
+
 #define SupportsLinux()   (SUPPORT_VECTOR & LINUX)
 #define SupportsXnu()     (SUPPORT_VECTOR & XNU)
 #define SupportsFreebsd() (SUPPORT_VECTOR & FREEBSD)
@@ -111,41 +113,44 @@
 #define EXTERN_C
 #endif
 
-#define O_RDONLY           0
-#define PROT_NONE          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 MAP_NORESERVE      (IsLinux() ? 16384 : 0)
-#define ELFCLASS32         1
-#define ELFDATA2LSB        1
-#define EM_NEXGEN32E       62
-#define EM_AARCH64         183
-#define ET_EXEC            2
-#define ET_DYN             3
-#define PT_LOAD            1
-#define PT_DYNAMIC         2
-#define PT_INTERP          3
-#define EI_CLASS           4
-#define EI_DATA            5
-#define PF_X               1
-#define PF_W               2
-#define PF_R               4
-#define AT_PHDR            3
-#define AT_PHENT           4
-#define AT_PHNUM           5
-#define AT_PAGESZ          6
-#define AT_EXECFN_LINUX    31
-#define AT_EXECFN_NETBSD   2014
-#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 O_RDONLY                    0
+#define PROT_NONE                   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 MAP_NORESERVE               (IsLinux() ? 16384 : 0)
+#define ELFCLASS32                  1
+#define ELFDATA2LSB                 1
+#define EM_NEXGEN32E                62
+#define EM_AARCH64                  183
+#define ET_EXEC                     2
+#define ET_DYN                      3
+#define PT_LOAD                     1
+#define PT_DYNAMIC                  2
+#define PT_INTERP                   3
+#define EI_CLASS                    4
+#define EI_DATA                     5
+#define PF_X                        1
+#define PF_W                        2
+#define PF_R                        4
+#define AT_PHDR                     3
+#define AT_PHENT                    4
+#define AT_PHNUM                    5
+#define AT_PAGESZ                   6
+#define AT_FLAGS                    8
+#define AT_FLAGS_PRESERVE_ARGV0_BIT 0
+#define AT_FLAGS_PRESERVE_ARGV0     (1 << AT_FLAGS_PRESERVE_ARGV0_BIT)
+#define AT_EXECFN_LINUX             31
+#define AT_EXECFN_NETBSD            2014
+#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 | \
@@ -212,17 +217,18 @@ struct PathSearcher {
   const char *name;
   const char *syspath;
   unsigned long namelen;
-  char path[1024];
+  char path[PATH_MAX];
 };
 
 struct ApeLoader {
   union ElfPhdrBuf phdr;
   struct PathSearcher ps;
-  char path[1024];
+  char path[PATH_MAX];
 };
 
 EXTERN_C long SystemCall(long, long, long, long, long, long, long, int);
-EXTERN_C void Launch(void *, long, void *, int) __attribute__((__noreturn__));
+EXTERN_C void Launch(void *, long, void *, int, void *)
+    __attribute__((__noreturn__));
 
 extern char __executable_start[];
 extern char _end[];
@@ -239,12 +245,13 @@ static int StrCmp(const char *l, const char *r) {
   return (l[i] & 255) - (r[i] & 255);
 }
 
-static const char *BaseName(const char *s) {
-  int c;
-  const char *b = "";
+#if 0
+
+static const char *StrRChr(const char *s, int c) {
+  const char *b = 0;
   if (s) {
-    while ((c = *s++)) {
-      if (c == '/') {
+    for (; *s; ++s) {
+      if (*s == c) {
         b = s;
       }
     }
@@ -252,6 +259,13 @@ static const char *BaseName(const char *s) {
   return b;
 }
 
+static const char *BaseName(const char *s) {
+  const char *b = StrRChr(s, '/');
+  return b ? b + 1 : s;
+}
+
+#endif
+
 static void Bzero(void *a, unsigned long n) {
   long z;
   char *p, *e;
@@ -343,7 +357,7 @@ static char *Utox(char p[19], unsigned long x) {
   return p;
 }
 
-static char *Utoa(char p[21], unsigned long x) {
+static char *Utoa(char p[20], unsigned long x) {
   char t;
   unsigned long i, a, b;
   i = 0;
@@ -561,45 +575,22 @@ static char SearchPath(struct PathSearcher *ps) {
   }
 }
 
-static char FindCommand(struct PathSearcher *ps) {
-  ps->path[0] = 0;
-
-  /* paths are always 100% taken literally when a slash exists
-       $ ape foo/bar.com arg1 arg2 */
-  if (MemChr(ps->name, '/', ps->namelen)) {
-    return AccessCommand(ps, 0);
-  }
-
-  /* we don't run files in the current directory
-       $ ape foo.com arg1 arg2
-     unless $PATH has an empty string entry, e.g.
-       $ expert PATH=":/bin"
-       $ ape foo.com arg1 arg2
-     however we will execute this
-       $ ape - foo.com foo.com arg1 arg2
-     because cosmo's execve needs it */
-  if (ps->literally && AccessCommand(ps, 0)) {
-    return 1;
-  }
-
-  /* otherwise search for name on $PATH */
-  return SearchPath(ps);
-}
-
-static char *Commandv(struct PathSearcher *ps, int os, const char *name,
+static char *Commandv(struct PathSearcher *ps, int os, char *name,
                       const char *syspath) {
+  if (!(ps->namelen = StrLen((ps->name = name)))) return 0;
+  if (ps->literally || MemChr(ps->name, '/', ps->namelen)) return name;
   ps->os = os;
   ps->syspath = syspath ? syspath : "/bin:/usr/local/bin:/usr/bin";
-  if (!(ps->namelen = StrLen((ps->name = name)))) return 0;
   if (ps->namelen + 1 > sizeof(ps->path)) return 0;
-  if (FindCommand(ps)) {
+  ps->path[0] = 0;
+  if (SearchPath(ps)) {
     return ps->path;
   } else {
     return 0;
   }
 }
 
-__attribute__((__noreturn__)) static void Spawn(int os, const char *exe, int fd,
+__attribute__((__noreturn__)) static void Spawn(int os, char *exe, int fd,
                                                 long *sp, unsigned long pagesz,
                                                 struct ElfEhdr *e,
                                                 struct ElfPhdr *p) {
@@ -757,11 +748,11 @@ __attribute__((__noreturn__)) static void Spawn(int os, const char *exe, int fd,
   Msyscall(dynbase + code, codesize, os);
 
   /* call program entrypoint */
-  Launch(IsFreebsd() ? sp : 0, dynbase + e->e_entry, sp, os);
+  Launch(IsFreebsd() ? sp : 0, dynbase + e->e_entry, exe, os, sp);
 }
 
 static const char *TryElf(struct ApeLoader *M, union ElfEhdrBuf *ebuf,
-                          const char *exe, int fd, long *sp, long *auxv,
+                          char *exe, int fd, long *sp, long *auxv,
                           unsigned long pagesz, int os) {
   long i, rc;
   unsigned size;
@@ -890,13 +881,8 @@ __attribute__((__noreturn__)) static void ShowUsage(int os, int fd, int rc) {
         "\n"
         "USAGE\n"
         "\n"
-        "  ape [FLAGS]   PROG [ARGV1,ARGV2,...]\n"
-        "  ape [FLAGS] - PROG [ARGV0,ARGV1,...]\n"
-        "\n"
-        "FLAGS\n"
-        "\n"
-        "  -h     show this help\n"
-        "  -f     force loading of program (do not use execve)\n"
+        "  ape   PROG [ARGV1,ARGV2,...]\n"
+        "  ape - PROG [ARGV0,ARGV1,...]\n"
         "\n",
         0l);
   Exit(rc, os);
@@ -906,10 +892,10 @@ EXTERN_C __attribute__((__noreturn__)) void ApeLoader(long di, long *sp,
                                                       char dl) {
   int rc, n;
   unsigned i;
-  char literally;
   const char *ape;
   int c, fd, os, argc;
   struct ApeLoader *M;
+  char arg0, literally;
   unsigned long pagesz;
   union ElfEhdrBuf *ebuf;
   long *auxv, *ap, *endp, *sp2;
@@ -954,11 +940,14 @@ EXTERN_C __attribute__((__noreturn__)) void ApeLoader(long di, long *sp,
 
   /* detect netbsd and find end of words */
   pagesz = 0;
+  arg0 = 0;
   for (ap = auxv; ap[0]; ap += 2) {
     if (ap[0] == AT_PAGESZ) {
       pagesz = ap[1];
     } else if (SupportsNetbsd() && !os && ap[0] == AT_EXECFN_NETBSD) {
       os = NETBSD;
+    } else if (SupportsLinux() && ap[0] == AT_FLAGS) {
+      arg0 = !!(ap[1] & AT_FLAGS_PRESERVE_ARGV0);
     }
   }
   if (!pagesz) {
@@ -971,22 +960,13 @@ EXTERN_C __attribute__((__noreturn__)) void ApeLoader(long di, long *sp,
     os = LINUX;
   }
 
-  /* parse flags */
-  while (argc > 1) {
-    if (argv[1][0] != '-') break; /* normal argument */
-    if (!argv[1][1]) break;       /* hyphen argument */
-    if (!StrCmp(argv[1], "-h") || !StrCmp(argv[1], "--help")) {
-      ShowUsage(os, 1, 0);
-    } else {
-      Print(os, 2, ape, ": invalid flag (pass -h for help)\n", 0l);
-      Exit(1, os);
-    }
-    *++sp = --argc;
-    ++argv;
-  }
-
   /* we can load via shell, shebang, or binfmt_misc */
-  if ((literally = argc >= 3 && !StrCmp(argv[1], "-"))) {
+  if (arg0) {
+    literally = 1;
+    prog = (char *)sp[2];
+    argc = sp[2] = sp[0] - 2;
+    argv = (char **)((sp += 2) + 1);
+  } else if ((literally = argc >= 3 && !StrCmp(argv[1], "-"))) {
     /* if the first argument is a hyphen then we give the user the
        power to change argv[0] or omit it entirely. most operating
        systems don't permit the omission of argv[0] but we do, b/c
@@ -995,9 +975,12 @@ EXTERN_C __attribute__((__noreturn__)) void ApeLoader(long di, long *sp,
     argc = sp[3] = sp[0] - 3;
     argv = (char **)((sp += 3) + 1);
   } else if (argc < 2) {
-    Print(os, 2, ape, ": missing command name (pass -h for help)\n", 0l);
-    Exit(1, os);
+    ShowUsage(os, 2, 1);
   } else {
+    if (argv[1][0] == '-') {
+      rc = !(argv[1][1] == 'h' && !argv[1][2]) || !StrCmp(argv[1] + 1, "-help");
+      ShowUsage(os, 1 + rc, rc);
+    }
     prog = (char *)sp[2];
     argc = sp[1] = sp[0] - 1;
     argv = (char **)((sp += 1) + 1);
@@ -1042,12 +1025,6 @@ EXTERN_C __attribute__((__noreturn__)) void ApeLoader(long di, long *sp,
   }
   pe = ebuf->buf + rc;
 
-  /* change argv[0] to resolved path if it's ambiguous */
-  if (argc > 0 && ((*prog != '/' && *exe == '/' && !StrCmp(prog, argv[0])) ||
-                   !StrCmp(BaseName(prog), argv[0]))) {
-    argv[0] = exe;
-  }
-
   /* ape intended behavior
      1. if ape, will scan shell script for elf printf statements
      2. shell script may have multiple lines producing elf headers

ape/loader.lds

@@ -1,5 +1,5 @@
 /*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
-│vi: set et sts=2 tw=2 fenc=utf-8                                           :vi│
+│ vi: set et sts=2 sw=2 fenc=utf-8                                         :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2023 Justine Alexandra Roberts Tunney                              │
 │                                                                              │

ape/macros.internal.h

@@ -1,5 +1,5 @@
 /*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│vi: set et ft=asm ts=8 sw=8 fenc=utf-8                                     :vi│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2020 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
@@ -22,119 +22,6 @@
 #ifdef __ASSEMBLER__
 /* clang-format off */
 
-/**
- * @fileoverview Macros relevant to αcτµαlly pδrταblε εxεcµταblε.
- */
-
-//	Calls near (i.e. pc+pcrel<64kB) FUNCTION.
-//	@mode	long,legacy,real
-//	@cost	9 bytes overhead
-.macro	rlcall	function:req
-	.byte	0x50                   	# push %[er]ax
-	.byte	0xb8,0,0		# mov $?,%[e]ax
-	jmp	911f
-	.byte	0x58                   	# pop %[er]ax
-	.byte	0xe8			# call Jvds
-	.long	\function\()-.-4
-	jmp	912f
-911:	.byte	0x58                   	# pop %[er]ax
-	.byte	0xe8			# call Jvds
-	.short	\function\()-.-2
-912:
-.endm
-
-//	Loads far (i.e. <1mb) abs constexpr ADDRESS into ES:DI+EDX+RDX.
-//	@mode	long,legacy,real
-.macro	movesdi	address:req
-	.byte	0xbf			# mov $0x????xxxx,%[e]di
-	.short	\address>>4
-	.byte	0x8e,0xc7		# mov %di,%es
-	.byte	0xbf			# mov $0x????xxxx,%[e]di
-	.short	\address&0xf
-	jmp	297f
-	.byte	0xbf			# mov $0x????xxxx,%edi
-	.long	\address
-297:
-.endm
-
-//	Loads 16-bit CONSTEXPR into Qw-register w/ optional zero-extend.
-//	@mode	long,legacy,real
-.macro	bbmov	constexpr:req abcd abcd.hi:req abcd.lo:req
- .ifnb	\abcd
-  .if	(\constexpr)<128 && (\constexpr)>=0
-	pushpop	\constexpr,\abcd
-   .exitm
-  .endif
- .endif
-	movb	$(\constexpr)>>8&0xff,\abcd.hi
-	movb	$(\constexpr)&0xff,\abcd.lo
-.endm
-
-//	Compares 16-bit CONSTEXPR with Qw-register.
-//	@mode	long,legacy,real
-.macro	bbcmp	constexpr:req abcd.hi:req abcd.lo:req
-	cmpb	$(\constexpr)>>8&0xff,\abcd.hi
-	jnz	387f
-	cmpb	$(\constexpr)&0xff,\abcd.lo
-387:
-.endm
-
-//	Adds 16-bit CONSTEXPR to Qw-register.
-//	@mode	long,legacy,real
-.macro	bbadd	constexpr:req abcd.hi:req abcd.lo:req
-	addb	$(\constexpr)&0xff,\abcd.lo
- .if	(\constexpr) != 0
-	adcb	$(\constexpr)>>8&0xff,\abcd.hi
- .endif
-.endm
-
-//	Subtracts 16-bit CONSTEXPR from Qw-register.
-//	@mode	long,legacy,real
-.macro	bbsub	constexpr:req abcd.hi:req abcd.lo:req
-	subb	$(\constexpr)&0xff,\abcd.lo
- .if	(\constexpr) != 0
-	sbbb	$(\constexpr)>>8&0xff,\abcd.hi
- .endif
-.endm
-
-//	Ands Qw-register with 16-bit CONSTEXPR.
-//	@mode	long,legacy,real
-.macro	bband	constexpr:req abcd.hi:req abcd.lo:req
- .if	((\constexpr)&0xff) != 0xff || ((\constexpr)>>8&0xff) == 0xff
-	andb	$(\constexpr)&0xff,\abcd.lo
- .endif
- .if	((\constexpr)>>8&0xff) != 0xff
-	andb	$(\constexpr)>>8&0xff,\abcd.hi
- .endif
-.endm
-
-//	Ors Qw-register with 16-bit CONSTEXPR.
-//	@mode	long,legacy,real
-.macro	bbor	constexpr:req abcd.hi:req abcd.lo:req
- .if	((\constexpr)&0xff) != 0 || ((\constexpr)>>8&0xff) != 0
-	orb	$(\constexpr)&0xff,\abcd.lo
- .endif
- .if	((\constexpr)>>8&0xff) != 0
-	orb	$(\constexpr)>>8&0xff,\abcd.hi
- .endif
-.endm
-
-//	Performs ACTION only if in real mode.
-//	@mode	long,legacy,real
-.macro	rlo	clobber:req action:vararg
-990:	mov	$0,\clobber
-	.if	.-990b!=3
-	.error	"bad clobber or assembler mode"
-	.endif
-991:	\action
-	.rept	2-(.-991b)
-	nop
-	.endr
-	.if	.-991b!=2
-	.error	"ACTION must be 1-2 bytes"
-	.endif
-.endm
-
 //	Initializes real mode stack.
 //	The most holiest of holy code.
 //	@mode	real

ape/sections.internal.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
 #define COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 extern const char __comment_start[] __attribute__((__weak__));
@@ -23,7 +22,7 @@ extern uint8_t __data_start[] __attribute__((__weak__));
 extern uint8_t __data_end[] __attribute__((__weak__));
 extern uint8_t __bss_start[] __attribute__((__weak__));
 extern uint8_t __bss_end[] __attribute__((__weak__));
+extern unsigned char ape_phdrs[] __attribute__((__weak__));
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_ */

ape/start.S

@@ -1,5 +1,5 @@
 /*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2023 Justine Alexandra Roberts Tunney                              │
 │                                                                              │

ape/systemcall.S

@@ -1,5 +1,5 @@
 /*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2023 Justine Alexandra Roberts Tunney                              │
 │                                                                              │

bin/aarch64-unknown-cosmo-addr2line

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-${m:-aarch64}}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos/aarch64}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/aarch64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-addr2line"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: aarch64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/aarch64-unknown-cosmo-apecopy

@@ -1 +0,0 @@
-apecopy

bin/aarch64-unknown-cosmo-ar

@@ -1,21 +0,0 @@
-#!/bin/sh
-PROG=${0##*/}
-MODE=${MODE:-${m:-aarch64}}
-COSMO=${COSMO:-/opt/cosmo}
-
-fatal_error() {
-  echo "$PROG: $1" >&2
-  exit 1
-}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/aarch64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-if [ ! -x "$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-ar" ]; then
-  fatal_error "you need to run: aarch64-unknown-cosmo-cc --update"
-fi
-
-exec "$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-ar" "$@"

bin/aarch64-unknown-cosmo-as

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-${m:-aarch64}}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos/aarch64}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/aarch64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-as"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: aarch64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/aarch64-unknown-cosmo-nm

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-${m:-aarch64}}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos/aarch64}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/aarch64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-nm"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: aarch64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/aarch64-unknown-cosmo-objcopy

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-${m:-aarch64}}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos/aarch64}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/aarch64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-objcopy"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: aarch64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/aarch64-unknown-cosmo-objdump

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-${m:-aarch64}}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos/aarch64}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/aarch64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-objdump"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: aarch64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/aarch64-unknown-cosmo-strip

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-${m:-aarch64}}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos/aarch64}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/aarch64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-strip"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: aarch64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/ape-install

@@ -1,148 +0,0 @@
-#!/bin/sh
-
-PROG=${0##*/}
-MODE=${MODE:-$m}
-TMPDIR=${TMPDIR:-/tmp}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos}
-
-if [ ! -f ape/loader.c ]; then
-  cd "$COSMO" || exit
-fi
-
-if [ "$(id -u)" -eq 0 ]; then
-  SUDO=
-else
-  SUDO=sudo
-fi
-
-echo "Actually Portable Executable (APE) Installer" >&2
-echo "Author:  Justine Tunney <[email protected]>"  >&2
-
-# special installation process for apple silicon
-if [ "$(uname -s)" = "Darwin" ] && [ "$(uname -m)" = "arm64" ]; then
-  echo "cc -O -o $TMPDIR/ape.$$ ape/ape-m1.c" >&2
-  cc -O -o "$TMPDIR/ape.$$" ape/ape-m1.c || exit
-  if [ ! -d /usr/local/bin ]; then
-    echo "$SUDO mkdir -p /usr/local/bin" >&2
-    $SUDO mkdir -p /usr/local/bin || exit
-  fi
-  echo "$SUDO mv -f $TMPDIR/ape.$$ /usr/local/bin/ape" >&2
-  $SUDO mv -f "$TMPDIR/ape.$$" /usr/local/bin/ape || exit
-  exit
-fi
-
-################################################################################
-# INSTALL APE LOADER SYSTEMWIDE
-
-if [ -f o/depend ] && make -j8 o//ape; then
-  echo "successfully recompiled ape loader" >&2
-elif [ -x o//ape/ape.elf ] && [ -x o//ape/ape.macho ]; then
-  echo "using ape loader you compiled earlier" >&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 || 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
-
-if [ "$(uname -s)" = "Darwin" ]; then
-  if ! [ /usr/bin/ape -nt o//ape/ape.macho ]; then
-    echo >&2
-    echo "installing o//ape/ape.macho to /usr/bin/ape" >&2
-    echo "$SUDO cp -f o//ape/ape.macho /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
-
-################################################################################
-# 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 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 '$SUDO sh -c "echo '"'"':APE-jart:M::jartsr::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
-  $SUDO sh -c "echo ':APE-jart:M::jartsr::/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
-
-################################################################################
-
-{
-  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

bin/ape-uninstall

@@ -1,64 +0,0 @@
-#!/bin/sh
-
-PROG=${0##*/}
-MODE=${MODE:-$m}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos}
-
-if [ ! -f ape/loader.c ]; then
-  cd "$COSMO" || exit
-fi
-
-if [ "$UID" = "0" ]; then
-  SUDO=
-else
-  SUDO=sudo
-fi
-
-{
-  echo
-  echo "APE Uninstaller intends to run (in pseudo-shell)"
-  echo
-  echo "    sudo echo -1 into /proc/sys/fs/binfmt_misc/APE*"
-  echo "    sudo rm -f /usr/bin/ape ~/.ape /tmp/.ape # etc."
-  echo
-  echo "You may then use ape/apeinstall.sh to reinstall it"
-  echo
-} >&2
-
-set -ex
-for f in /proc/sys/fs/binfmt_misc/APE*; do
-  if [ -f $f ]; then
-    $SUDO sh -c "echo -1 >$f" || exit
-  fi
-done
-
-# system installation
-if [ -f /usr/bin/ape ]; then
-  $SUDO rm -f /usr/bin/ape
-fi
-if [ -f /usr/local/bin/ape ]; then
-  $SUDO rm -f /usr/local/bin/ape
-fi
-
-# legacy installations
-rm -f o/tmp/ape /tmp/ape "${TMPDIR:-/tmp}/ape"
-
-# ad-hoc installations
-for x in .ape \
-         .ape-1.1 \
-         .ape-1.3 \
-         .ape-1.4 \
-         .ape-1.5 \
-         .ape-1.6 \
-         .ape-1.7 \
-         .ape-1.8 \
-         .ape-1.9 \
-         .ape-blink-0.9.2 \
-         .ape-blink-1.0.0; do
-  rm -f \
-     ~/$x \
-     /tmp/$x \
-     o/tmp/$x \
-     "${TMPDIR:-/tmp}/$x"
-done

bin/apecopy

@@ -1,102 +0,0 @@
-#!/bin/sh
-PROG=${0##*/}
-COSMO=${COSMO:-/opt/cosmo}
-
-if [ x"$1" = x"--version" ]; then
-cat <<EOF
-$PROG 0.1
-Copyright (c) 2023 Justine Alexandra Roberts Tunney
-Cosmopolitan Libc and LLVM libcxx/compiler-rt are subject to non-GPL
-notice licenses, e.g. ISC, MIT, etc. Your compiled programs must embed
-our copyright notices. This toolchain is configured to do so default.
-Cosmopolitan comes with absolutely NO WARRANTY of any kind.
-For more information, see the Cosmopolitan LICENSE files.
-Copyright (C) 2019 Free Software Foundation, Inc.
-This launches GNU GCC/Binutils subprocesses, which is free software; see
-Cosmopolitan's third_party/gcc/ for source code and copying conditions.
-There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.
-EOF
-exit
-fi
-
-if [ x"$1" = x"--help" ]; then
-cat <<EOF
-Usage: $PROG INPUT OUTPUT
-Converts an executable linked by cosmocc to the Actually Portable
-Executable file format. See $PROG --version for other details.
-EOF
-exit
-fi
-
-fatal_error() {
-  echo "$PROG: fatal error: $1" >&2
-  echo "operation terminated." >&2
-  exit 1
-}
-
-CROSS=1
-ARCH=${PROG%%-*}  # split(prog, '-')[0]
-if [ x"$ARCH" = x"$PROG" ]; then
-  ARCH=x86_64
-  CROSS=0
-fi
-
-if [ x"$ARCH" = x"x86_64" ]; then
-  MODE=${MODE:-$m}
-else
-  MODE=${MODE:-${m:-$ARCH}}
-fi
-
-if [ $CROSS -eq 0 ]; then
-  COSMOS=${COSMOS:-/opt/cosmos}
-else
-  COSMOS=${COSMOS:-/opt/cosmos/$ARCH}
-fi
-
-if [ x"$ARCH" = x"x86_64" ]; then
-  OBJCOPYFLAGS="-S -O binary"
-elif [ x"$ARCH" = x"aarch64" ]; then
-  OBJCOPYFLAGS="-S"
-else
-  fatal_error "$ARCH: unsupported architecture"
-fi
-
-if [ ! -d "$COSMO" ]; then
-  fatal_error "you need to clone cosmopolitan to your $COSMO directory"
-fi
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-if [ ! -f "$COSMO/o//tool/build/zipcopy.com" ] ||
-   [ ! -f "$COSMO/o/third_party/gcc/bin/$ARCH-linux-$BRAND-objcopy" ]; then
-  if [ $CROSS -eq 0 ]; then
-    fatal_error "you need to run: cosmocc --update"
-  else
-    fatal_error "you need to run: $ARCH-unknown-cosmo-cosmocc --update"
-  fi
-fi
-
-INPUT=$1
-OUTPUT=$2
-if [ ! -f "$INPUT" ]; then
-  fatal_error "$INPUT: missing input and output arguments"
-elif [ ! -f "$INPUT" ]; then
-  fatal_error "$INPUT: no such file"
-elif [ ! -f "$INPUT" ]; then
-  fatal_error "$INPUT: missing output argument"
-elif [ x"$INPUT" = x"$OUTPUT" ]; then
-  fatal_error "$INPUT: input and output file can't be the same"
-fi
-
-"$COSMO/o/third_party/gcc/bin/$ARCH-linux-$BRAND-objcopy" \
-  $OBJCOPYFLAGS \
-  "$INPUT" \
-  "$OUTPUT" || exit
-"$COSMO/o//tool/build/zipcopy.com" \
-  "$INPUT" \
-  "$OUTPUT" || exit

bin/apelink

@@ -1,3 +0,0 @@
-#!/bin/sh
-COSMO=${COSMO:-/opt/cosmo}
-exec "$COSMO/o//tool/build/apelink.com" "$@"

bin/cosmoaddr2line

@@ -1,31 +0,0 @@
-#!/bin/sh
-COSMO=${COSMO:-/opt/cosmo}
-
-set -- -apifCe "$@"
-
-if [ -n "$ADDR2LINE" ]; then
-  exec "$ADDR2LINE" "$@"
-fi
-
-find_addr2line() {
-  if [ -x o/third_party/gcc/bin/$1-linux-cosmo-addr2line ]; then
-    ADDR2LINE=o/third_party/gcc/bin/$1-linux-cosmo-addr2line
-  elif [ -x o/third_party/gcc/bin/$1-linux-musl-addr2line ]; then
-    ADDR2LINE=o/third_party/gcc/bin/$1-linux-musl-addr2line
-  elif [ -x "$COSMO/o/third_party/gcc/bin/$1-linux-cosmo-addr2line" ]; then
-    ADDR2LINE="$COSMO/o/third_party/gcc/bin/$1-linux-cosmo-addr2line"
-  elif [ -x "$COSMO/o/third_party/gcc/bin/$1-linux-musl-addr2line" ]; then
-    ADDR2LINE="$COSMO/o/third_party/gcc/bin/$1-linux-musl-addr2line"
-  else
-    echo "error: toolchain not found (try running 'cosmocc --update' or 'make' in the cosmo monorepo)" >&2
-    exit 1
-  fi
-}
-
-for ARCH in x86_64 aarch64; do
-  find_addr2line $ARCH
-  "$ADDR2LINE" "$@" 2>/dev/null && exit
-done
-
-echo "error: addr2line failed" >&2
-exit 1

bin/cosmocc

@@ -1,385 +0,0 @@
-#!/bin/sh
-#
-# cosmopolitan c/c++ compiler
-#
-# getting started
-#
-#     sudo chmod 1777 /opt  # sticky bit isn't required
-#     git clone https://github.com/jart/cosmopolitan /opt/cosmo
-#     export PATH="/opt/cosmo/bin:/opt/cosmos/bin:$PATH"
-#     echo 'export PATH="/opt/cosmo/bin:/opt/cosmos/bin:$PATH"' >>~/.profile
-#     ape-install  # optionally install a faster systemwide ape loader
-#     cosmocc --update  # pull and rebuild toolchain artifacts
-#
-# getting started synopsis
-#
-#     cosmocc -o hello.com hello.c
-#     ./foo.com
-#     ./foo.com --strace
-#     ./foo.com --ftrace
-#
-# how to build a project like lua 5.4.6
-#
-#     make all test CC=cosmocc
-#     src/lua -e 'print("hi")'
-#     make install INSTALL_TOP=/opt/cosmos
-#     apecopy src/lua src/lua.com  # convert to portable ape binary
-#
-# how to cross compile a project like lua 5.4.6
-#
-#     aarch64-unknown-cosmo-cc --update
-#     make clean all test CC=aarch64-unknown-cosmo-cc AR='aarch64-unknown-cosmo-ar rc' -j8
-#     qemu-aarch64 src/lua -e 'print("hi")'
-#     make install INSTALL_TOP=/opt/cosmos/aarch64
-#
-# building in tiny mode
-#
-#     export MODE=tiny
-#     cosmocc --update
-#     cosmocc -Os -o foo.com foo.c
-#
-# building in tiniest mode (linux only)
-#
-#     export MODE=tinylinux
-#     cosmocc --update
-#     cosmocc -Os -o foo.com foo.c
-#
-# hardening programs with memory safety
-#
-#     export MODE=asan
-#     cosmocc --update
-#     cosmocc -o foo.com foo.c
-#
-# detecting this environment
-#
-#   - `__COSMOCC__` is defined when this compiler is in play
-#   - `__COSMOPOLITAN__` is always defined by Cosmopolitan Libc
-#
-# some notes on this compiler
-#
-#   - the underlying compiler itself is gcc
-#   - we use cosmopoiltan libc rather than glibc
-#   - we use llvm's compiler-rt and libcxx runtimes
-#   - we patched gcc so switch case can have symbols
-#   - our scanf() implementation is somewhat troubled
-#
-# compiler flags that aren't supported
-#
-#   - `-r` partial linking not implemented yet (todo)
-#   - `-S` you need to put your assembly behind #ifdefs instead
-#   - `-fexceptions` cosmopolitan doesn't support c++ exceptions yet
-#   - `-frtti` cosmopolitan doesn't support c++ runtime reflection yet
-#   - `-mred-zone` the system v red zone doesn't exist on windows and metal
-#   - `-fpic`, '-fPIC', `-shared`, `-pie`, etc. no shared object support yet
-#   - `-fsanitize=thread` cosmopolitan doesn't have thread sanitizer runtime yet
-#   - `-fomit-frame-pointer` is partially supported (apple forbids full removal)
-#
-# for further details, run `man gcc`
-
-PROG=${0##*/}
-COSMO=${COSMO:-/opt/cosmo}
-GCC_VERSION=11.2.0
-
-if [ "$1" = "--version" ]; then
-cat <<EOF
-$PROG (GCC) $GCC_VERSION
-Copyright (c) 2023 Justine Alexandra Roberts Tunney
-Cosmopolitan Libc and LLVM libcxx/compiler-rt are subject to non-GPL
-notice licenses, e.g. ISC, MIT, etc. Your compiled programs must embed
-our copyright notices. This toolchain is configured to do so default.
-Cosmopolitan comes with absolutely NO WARRANTY of any kind.
-For more information, see the Cosmopolitan LICENSE files.
-Copyright (C) 2019 Free Software Foundation, Inc.
-This launches GNU GCC/Binutils subprocesses, which is free software; see
-Cosmopolitan's third_party/gcc/ for source code and copying conditions.
-There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.
-EOF
-exit
-fi
-
-fatal_error() {
-  echo "$PROG: fatal error: $1" >&2
-  echo "compilation terminated." >&2
-  exit 1
-}
-
-log_command() {
-  if [ -n "$BUILDLOG" ]; then
-    printf '# %s\n(cd %s; %s)\n' "$ORIGINAL" "$PWD" "$*" >>"$BUILDLOG"
-  fi
-}
-
-ORIGINAL="$0 $*"
-PLATFORM="-D__COSMOPOLITAN__ -D__COSMOCC__"
-PREDEF="-include libc/integral/normalize.inc"
-CFLAGS="-fportcosmo -fno-dwarf2-cfi-asm -fno-unwind-tables -fno-asynchronous-unwind-tables -fno-semantic-interposition"
-CPPFLAGS="-fno-pie -nostdinc -fno-math-errno -iquote $COSMO"
-LDFLAGS="-static -no-pie -nostdlib -fuse-ld=bfd"
-APEFLAGS="-Wl,--gc-sections"
-PRECIOUS="-fno-omit-frame-pointer"
-
-CROSS=1
-ARCH=${PROG%%-*}  # split(prog, '-')[0]
-if [ x"$ARCH" = x"$PROG" ]; then
-  ARCH=x86_64
-  CROSS=0
-fi
-
-if [ x"$ARCH" = x"x86_64" ]; then
-  MODE=${MODE:-$m}
-else
-  MODE=${MODE:-${m:-$ARCH}}
-fi
-
-if [ $CROSS -eq 0 ]; then
-  COSMOS=${COSMOS:-/opt/cosmos}
-else
-  COSMOS=${COSMOS:-/opt/cosmos/$ARCH}
-fi
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-CC="$COSMO/o/third_party/gcc/bin/$ARCH-linux-$BRAND-gcc"
-CRT="$COSMO/o/$MODE/libc/crt/crt.o"
-LDLIBS="$COSMO/o/$MODE/cosmopolitan.a"
-CPPFLAGS="$CPPFLAGS -isystem $COSMOS/include -isystem $COSMO/libc/isystem"
-LDFLAGS="$LDFLAGS -L$COSMOS/lib"
-if [ x"$PROG" != x"${PROG%++}" ]; then
-  CC="$COSMO/o/third_party/gcc/bin/$ARCH-linux-$BRAND-g++"
-  CFLAGS="$CFLAGS -fno-rtti -fno-exceptions -fuse-cxa-atexit"
-  LDLIBS="$COSMO/o/$MODE/third_party/libcxx/libcxx.a $LDLIBS"
-fi
-
-PAGESZ=4096
-if [ x"$ARCH" = x"x86_64" ]; then
-  OBJCOPYFLAGS="-S -O binary"
-  CRT="$COSMO/o/$MODE/ape/ape-no-modify-self.o $CRT"
-  CPPFLAGS="$CPPFLAGS -mno-red-zone"
-  CFLAGS="$CFLAGS -mno-tls-direct-seg-refs"
-  LDFLAGS="$LDFLAGS -Wl,-T,$COSMO/o/$MODE/ape/ape.lds"
-  if [ x"$MODE" = x"aarch64" ]; then
-    fatal_error '$MODE must not be aarch64 when using x86_64 cross compiler'
-  elif [ x"$MODE" != x"${MODE#* }" ]; then
-    fatal_error '$MODE must not contain hyphens when targeting x86_64'
-  fi
-elif [ x"$ARCH" = x"aarch64" ]; then
-  OBJCOPYFLAGS="-S"
-  PAGESZ=16384
-  CFLAGS="$CFLAGS -ffixed-x18 -ffixed-x28 -mno-outline-atomics"
-  LDFLAGS="$LDFLAGS -Wl,-T,$COSMO/o/$MODE/ape/aarch64.lds"
-  if [ x"$MODE" != x"aarch64" ] && [ x"$MODE" = x"${MODE#aarch64-*}" ]; then
-    fatal_error '$MODE must be either "aarch64" or "aarch64-FOO" when using aarch64 cross compiler'
-  fi
-else
-  fatal_error "$ARCH: unsupported architecture"
-fi
-
-LDFLAGS="$LDFLAGS -Wl,-z,common-page-size=$PAGESZ -Wl,-z,max-page-size=16384"
-
-if [ ! -d "$COSMO" ]; then
-  fatal_error "you need to clone cosmopolitan to your $COSMO directory"
-fi
-
-if [ "$1" = "--update" ]; then
-  cd $COSMO || exit
-  echo "building cosmo host toolchain..." >&2
-  make --silent -j toolchain MODE= ARCH=x86_64 || exit
-  echo "building cosmo target (MODE=$MODE) toolchain..." >&2
-  make --silent -j toolchain MODE="$MODE" || exit
-  echo "setting up your cosmos..." >&2
-  mkdir -p "$COSMOS/lib" || exit
-  for lib in c dl gcc_s m pthread resolv rt dl z stdc++; do
-    if [ ! -f "$COSMOS/lib/lib${lib}.a" ]; then
-      printf '\041\074\141\162\143\150\076\012' >"$COSMOS/lib/lib${lib}.a" || exit
-    fi
-  done
-  echo "successfully updated your cosmo toolchain" >&2
-  exit
-fi
-
-if [ ! -f "$COSMOS/lib/libc.a" ] ||
-   [ ! -f "$COSMO/o/$MODE/cosmopolitan.a" ]; then
-  fatal_error "you need to run: $PROG --update"
-fi
-
-OPT=
-FIRST=1
-OUTPUT=
-SFLAG=0
-INTENT=ld
-GOT_SOME=0
-NEED_OUTPUT=
-RELOCATABLE=0
-for x; do
-  if [ $FIRST -eq 1 ]; then
-    set --
-    FIRST=0
-  fi
-  if [ -n "$NEED_OUTPUT" ]; then
-    NEED_OUTPUT=
-    OUTPUT=$x
-    set -- "$@" "$x"
-    continue
-  fi
-  if [ x"$x" = x"-" ] ||           # is an argument
-     [ x"$x" = x"${x#-*}" ]; then  # !startswith(x, "-")
-    GOT_SOME=1
-  elif [ x"$x" = x"-static-libstdc++" ]; then
-    continue
-  elif [ x"$x" = x"-static-libgcc" ]; then
-    continue
-  elif [ x"$x" != x"${x#-O}" ]; then
-    OPT=$x
-  elif [ x"$x" = x"-c" ]; then
-    INTENT=cc
-  elif [ x"$x" = x"-s" ]; then
-    SFLAG=1
-    continue
-  elif [ x"$x" = x"-r" ]; then
-    RELOCATABLE=1
-  elif [ x"$x" = x"-E" ]; then
-    INTENT=cpp
-  elif [ x"$x" = x"-o" ]; then
-    NEED_OUTPUT=1
-  elif [ x"$x" = x"-mcosmo" ]; then
-    CPPFLAGS="$CPPFLAGS -D_COSMO_SOURCE"
-    continue
-  elif [ x"$x" != x"${x#-o}" ]; then
-    OUTPUT=${x#-o}
-  elif [ x"$x" = x"-fpic" ]; then
-    continue
-  elif [ x"$x" = x"-fPIC" ]; then
-    continue
-  elif [ x"$x" = x"-r" ] ||
-       [ x"$x" = x"-pie" ] ||
-       [ x"$x" = x"-frtti" ] ||
-       [ x"$x" = x"-shared" ] ||
-       [ x"$x" = x"-nostdlib" ] ||
-       [ x"$x" = x"-mred-zone" ] ||
-       [ x"$x" = x"-fexceptions" ] ||
-       [ x"$x" = x"-fsanitize=thread" ]; then
-    echo "$PROG: $x not supported" >&2
-    exit 1
-  elif [ x"$x" = x"-fsanitize=all" ] ||
-       [ x"$x" = x"-fsanitize=address" ] ||
-       [ x"$x" = x"-fsanitize=undefined" ]; then
-    echo "$PROG: use cosmo MODE=dbg or MODE=asan rather than passing $x" >&2
-    exit 1
-  elif [ x"$x" = x"-fomit-frame-pointer" ]; then
-    # Quoth Apple "The frame pointer register must always address a
-    # valid frame record. Some functions — such as leaf functions or
-    # tail calls — may opt not to create an entry in this list. As a
-    # result, stack traces are always meaningful, even without debug
-    # information."
-    set -- "$@" -momit-leaf-frame-pointer -foptimize-sibling-calls
-    continue
-  elif [ x"$x" != x"${x#-Werror}" ] || \
-       [ x"$x" = x"-pedantic-errors" ]; then
-    # this toolchain is intended for building other people's code
-    # elevating warnings into errors, should only be done by devs
-    continue
-  elif [ x"$x" = x"-march=native" ]; then
-    if [ $CROSS -eq 0 ]; then
-      set -- "$@" $("$COSMO/o//tool/build/march-native.com")
-    else
-      fatal_error "-march=native can't be used when cross compiling"
-    fi
-    continue
-  elif [ x"$x" = x"-dumpversion" ]; then
-    echo $GCC_VERSION
-    exit 0
-  elif [ x"$x" = x"-Wl,--version" ]; then
-    GOT_SOME=1
-  elif [ x"$x" = x"-dumpmachine" ]; then
-    GOT_SOME=1
-  fi
-  set -- "$@" "$x"
-done
-
-if [ "$GOT_SOME" -eq 0 ]; then
-  fatal_error "no input files"
-fi
-
-if [ $RELOCATABLE -eq 1 ]; then
-  LDFLAGS="$LDFLAGS -r"
-fi
-
-if [ x"$MODE" = x"nox87" ]; then
-  CPPFLAGS="$CPPFLAGS -mlong-double-64"
-fi
-
-# support --ftrace unless optimizing for size
-if [ x"$OPT" != x"-Os" ] &&                # $OPT != -Os
-   [ x"${MODE%tiny}" = x"${MODE}" ]; then  # $MODE not in (tiny, aarch64-tiny)
-  if [ x"$ARCH" = x"x86_64" ]; then
-    CFLAGS="$CFLAGS -fpatchable-function-entry=18,16"
-  elif [ x"$ARCH" = x"aarch64" ]; then
-    CFLAGS="$CFLAGS -fpatchable-function-entry=7,6"
-  fi
-fi
-
-# ask compiler to generate sanitization code in debug mode
-if [ x"$MODE" != x"${MODE%*dbg}" ]; then  # endswith($MODE, "dbg")
-  if [ x"$ARCH" = x"x86_64" ]; then
-    CPPFLAGS="$CPPFLAGS -fsanitize=address -fsanitize=undefined"
-  else
-    CPPFLAGS="$CPPFLAGS -fsanitize=undefined"
-  fi
-fi
-
-# ask compiler to generate memory safety code in asan mode
-if [ x"$MODE" != x"${MODE%*asan}" ]; then  # endswith($MODE, "asan")
-  if [ x"$ARCH" = x"x86_64" ]; then
-    CPPFLAGS="$CPPFLAGS -fsanitize=address"
-  else
-    fatal_error "address sanitizer not supported on non-x86 yet"
-  fi
-fi
-
-# maximize frame pointers unless optimizing for size
-if [ x"$OPT" != x"-Os" ] &&               # $OPT != "-Os"
-   [ x"$MODE" != x"${MODE%tiny}" ]; then  # endswith($MODE, "tiny")
-  CFLAGS="$CFLAGS -fno-optimize-sibling-calls -mno-omit-leaf-frame-pointer"
-fi
-
-if [ $INTENT = cpp ]; then
-  set -- "$CC" $PLATFORM $CPPFLAGS "$@"
-elif [ $INTENT = cc ]; then
-  set -- "$CC" $PLATFORM $PREDEF $CFLAGS $CPPFLAGS "$@" $PRECIOUS
-else
-  set -- "$CC" $PLATFORM $PREDEF $CFLAGS $CPPFLAGS $CRT "$@" $LDFLAGS $LDLIBS $PRECIOUS
-fi
-
-log_command "$@"
-"$@" || exit
-
-if [ -n "$OUTPUT" ] && [ -f "$OUTPUT" ]; then
-  if [ $INTENT = cc ] || [ $INTENT = ld ]; then
-    "$COSMO/o//tool/build/fixupobj.com" \
-      "$OUTPUT" || exit
-  fi
-  if [ $INTENT = ld ]; then
-    if [ x"$OUTPUT" != x"${OUTPUT%.com}" ] ||
-       [ x"$OUTPUT" != x"${OUTPUT%.exe}" ]; then
-      # cosmocc -o foo.com ...
-      # -> foo.com (ape)
-      # -> foo.com.dbg (elf)
-      mv -f "$OUTPUT" "$OUTPUT.dbg" || exit
-      "$COSMO/o/third_party/gcc/bin/$ARCH-linux-$BRAND-objcopy" \
-        $OBJCOPYFLAGS \
-        "$OUTPUT.dbg" \
-        "$OUTPUT" || exit
-      "$COSMO/o//tool/build/zipcopy.com" \
-        "$OUTPUT.dbg" \
-        "$OUTPUT" || exit
-    elif [ $SFLAG -eq 1 ]; then
-      "$COSMO/o/third_party/gcc/bin/$ARCH-linux-$BRAND-strip" \
-        "$OUTPUT" || exit
-    fi
-  fi
-fi

bin/fatcosmoar

@@ -1,119 +0,0 @@
-#!/bin/sh
-PROG=${0##*/}
-MODE=${MODE:-$m}
-COSMO=${COSMO:-/opt/cosmo}
-
-fatal_error() {
-  echo "$PROG: $1" >&2
-  exit 1
-}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-if [ ! -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-ar" ]; then
-  fatal_error "you need to run: fatcosmocc --update"
-fi
-
-AR_X86_64="$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-ar"
-AR_AARCH64="$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-ar"
-if [ "$1" = "--version" ]; then
-  # note: only the underlying gnu compiler binaries are gpl
-  #       our shell script is released with the isc license
-  cat <<EOF
-$PROG (GNU Binutils) 2.38
-Copyright (C) 2022 Free Software Foundation, Inc.
-This program is free software; you may redistribute it under the terms of
-the GNU General Public License version 3 or (at your option) any later version.
-This program has absolutely no warranty.
-EOF
-  exit 0
-elif [ "$1" = "--help" ]; then
-  "$AR_X86_64" --help |
-    sed "s!$AR_X86_64!$PROG!g" 2>/dev/null ||
-    "$AR_X86_64" --help
-  exit
-fi
-
-FIRST=1
-STATE=0
-OUTPUT_X86_64=
-OUTPUT_AARCH64=
-INPUTS=
-for x; do
-  if [ $FIRST -eq 1 ]; then
-    set --
-    FIRST=0
-  fi
-  if [ $STATE -eq 0 ]; then
-    if [ x"$x" != x"${x#--*}" ]; then  # startswith(x, "--")
-      set -- "$@" "$x"  # this is a flag
-    else
-      set -- "$@" "$x"  # command argument, e.g. rcu, rcsD
-      STATE=1
-    fi
-  elif [ $STATE -eq 1 ]; then
-    OUTPUT_X86_64=$x
-    STATE=2
-  elif [ x"$x" != x"${x#* }" ]; then
-    fatal_error "input arguments containing spaces unsupported"
-  elif [ x"$x" != x"${x#@}" ]; then
-    fatal_error "input argument @file not supported yet"
-  elif [ -z "$INPUTS" ]; then
-    INPUTS=$x
-  else
-    INPUTS="$INPUTS $x"
-  fi
-done
-if [ -z "$OUTPUT_X86_64" ]; then
-  fatal_error "missing output path"
-fi
-
-mangle_object_path() {
-  path=$1
-  arch=$2
-  outdir=${path%/*}
-  outbas=${path##*/}
-  if [ x"$outdir" = x"$path" ]; then
-    outdir=
-  elif [ -n "$outdir" ]; then
-    outdir="$outdir/"
-  fi
-  if [ ! -d "$outdir.$arch" ]; then
-    mkdir -p "$outdir.$arch" || Exit
-  fi
-  mangled_path="${outdir}.$arch/$outbas"
-}
-
-OBJECTS_X86_64=
-OBJECTS_AARCH64=
-for x in $INPUTS; do
-  if [ ! -f "$x" ]; then
-    fatal_error "$x: no such file"
-  fi
-  mangle_object_path "$x" aarch64
-  if [ ! -f "$mangled_path" ]; then
-    fatal_error "$x: missing concomitant $mangled_path file"
-  fi
-  OBJECTS_X86_64="${OBJECTS_X86_64} $x"
-  OBJECTS_AARCH64="${OBJECTS_AARCH64} $mangled_path"
-done
-
-mangle_object_path "$OUTPUT_X86_64" aarch64
-OUTPUT_AARCH64="$mangled_path"
-
-"$AR_X86_64" "$@" "$OUTPUT_X86_64" $OBJECTS_X86_64 &
-pid1=$!
-
-"$AR_AARCH64" "$@" "$OUTPUT_AARCH64" $OBJECTS_AARCH64 &
-pid2=$!
-
-if ! wait $pid1; then
-  kill $pid2 2>/dev/null
-  wait
-  exit 1
-fi
-wait $pid2 || exit

bin/fatcosmoc++

@@ -1 +0,0 @@
-fatcosmocc

bin/fatcosmocc

@@ -1,650 +0,0 @@
-#!/bin/sh
-#
-# fat cosmopolitan c/c++ compiler
-#
-#   - this command is a drop-in replacement for the cc or gcc command.
-#     the difference is that (1) your binaries will be linked with the
-#     cosmopolitan c library, rather than your system specific tooling
-#     and (2) they'll be fat ape executables that run on the platforms
-#
-#     * amd64
-#       + linux
-#       + macos
-#       + windows
-#       + freebsd
-#       + openbsd
-#       + netbsd
-#     * arm64
-#       + linux
-#       + macos
-#       + windows (non-native)
-#
-#   - you need to use linux to build your binaries currently, but you
-#     can scp and distribute the output files to the above platforms!
-#
-# installation
-#
-#     sudo chmod 1777 /opt  # sticky bit isn't required
-#     git clone https://github.com/jart/cosmopolitan /opt/cosmo
-#     export PATH="/opt/cosmo/bin:/opt/cosmos/bin:$PATH"
-#     echo 'export PATH="/opt/cosmo/bin:/opt/cosmos/bin:$PATH"' >>~/.profile
-#     ape-install  # optionally install a faster systemwide ape loader
-#     fatcosmocc --update  # pull and rebuild toolchain artifacts
-#
-# getting started
-#
-#     fatcosmocc -o hello.com hello.c
-#     ./foo.com
-#     unzip -vl ./foo.com
-#     ./foo.com --strace
-#     ./foo.com --ftrace
-#
-# building in tiny mode
-#
-#     export MODE=tiny
-#     fatcosmocc --update
-#     fatcosmocc -Os -o foo.com foo.c
-#
-# building in debug mode
-#
-#     export MODE=dbg
-#     fatcosmocc --update
-#     fatcosmocc -g -o foo.com foo.c
-#
-# how to build a project like lua 5.4.6
-#
-#     make all test CC=fatcosmocc AR='fatcosmoar rcu'
-#     make install INSTALL_TOP=/opt/cosmos INSTALL=fatcosmoinstall
-#
-# how to build a project like ncurses 6.4
-#
-#     ./configure CC=fatcosmocc \
-#                 CXX=fatcosmoc++ \
-#                 AR=fatcosmoar \
-#                 INSTALL="$(command -v fatcosmoinstall)" \
-#                 --prefix=/opt/cosmos \
-#                 --disable-shared
-#     make -j8
-#     make install
-#
-# detecting this environment
-#
-#   - `__FATCOSMOCC__` is defined by fatcosmocc
-#   - `__COSMOCC__` is defined by cosmocc and fatcosmocc
-#   - `__COSMOPOLITAN__` is always defined by cosmopolitan
-#
-# some notes on this compiler
-#
-#   - the underlying compiler itself is gcc
-#   - we use cosmopolitan libc rather than glibc
-#   - we use llvm's compiler-rt and libcxx runtimes
-#   - we patched gcc so switch case can have symbols
-#   - our scanf() implementation is somewhat troubled
-#   - you may need to recalibrate `make -jN` as `N/2`
-#
-# compiler flags that work differently
-#
-#   - `-v` will log fatcosmocc subcommands to stderr
-#          you can also use `export BUILDLOG=/tmp/build.log`
-#   - `-s` will ask apelink to not embed symbol tables in zip
-#   - `-E` can't be fat and runs once with x86_64 macros undefined
-#   - `-save-temps` will prevent deleting your arch-specific executables
-#
-# compiler flags that aren't supported
-#
-#   - `-fexceptions` cosmopolitan doesn't support c++ exceptions yet
-#   - `-frtti` cosmopolitan doesn't support c++ runtime reflection yet
-#   - `-mred-zone` the system v red zone doesn't exist on windows and metal
-#   - `-fpic`, '-fPIC', `-shared`, `-pie`, etc. no shared object support yet
-#   - `-fsanitize=thread` cosmopolitan doesn't have thread sanitizer runtime yet
-#   - `-fomit-frame-pointer` is partially supported (apple forbids full removal)
-#
-# for further details, run `man gcc`
-
-PROG=${0##*/}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos}
-ORIGINAL="$0 $*"
-TMPDIR=${TMPDIR:-/tmp}
-GCC_VERSION=11.2.0
-
-if [ "$1" = "--version" ]; then
-cat <<EOF
-$PROG (GCC) $GCC_VERSION
-Copyright (c) 2023 Justine Alexandra Roberts Tunney
-Cosmopolitan Libc and LLVM libcxx/compiler-rt are subject to non-GPL
-notice licenses, e.g. ISC, MIT, etc. Your compiled programs must embed
-our copyright notices. This toolchain is configured to do so default.
-Cosmopolitan comes with absolutely NO WARRANTY of any kind.
-For more information, see the Cosmopolitan LICENSE files.
-Copyright (C) 2019 Free Software Foundation, Inc.
-This launches GNU GCC/Binutils subprocesses, which is free software; see
-Cosmopolitan's third_party/gcc/ for source code and copying conditions.
-There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.
-EOF
-exit
-fi
-
-if [ "$1" = "--help" ]; then
-  if [ -t 1 ]; then
-    exec less "$0"
-  else
-    exec cat "$0"
-  fi
-fi
-
-MODE=${MODE:-$m}
-if [ x"$MODE" = x"" ]; then
-  MODE_AARCH64=aarch64
-elif [ x"$MODE" = x"tiny" ]; then
-  MODE_AARCH64=aarch64-tiny
-elif [ x"$MODE" = x"zero" ]; then
-  MODE_AARCH64=aarch64-zero
-elif [ x"$MODE" = x"dbg" ]; then
-  MODE_AARCH64=aarch64-dbg
-else
-  echo "$PROG: build MODE=$MODE not supported by fatcosmocc" >&2
-  exit 1
-fi
-
-if [ "$1" = "--update" ]; then
-  cd $COSMO || exit
-  echo "building cosmo host toolchain..." >&2
-  make --silent -j toolchain MODE= || exit
-  echo "building cosmo x86_64 target (MODE=$MODE) toolchain..." >&2
-  make --silent -j toolchain MODE="$MODE" || exit
-  echo "building cosmo aarch64 target (MODE=$MODE_AARCH64) toolchain..." >&2
-  make --silent -j toolchain MODE="$MODE_AARCH64" || exit
-  echo "setting up your cosmos..." >&2
-  for arch in "" .aarch64/; do
-    mkdir -p "$COSMOS/lib/$arch" || exit
-    for lib in c dl gcc_s m pthread resolv rt dl z stdc++; do
-      if [ ! -f "$COSMOS/lib/${arch}lib${lib}.a" ]; then
-        printf '\041\074\141\162\143\150\076\012' >"$COSMOS/lib/${arch}lib${lib}.a" || exit
-      fi
-    done
-  done
-  echo "successfully updated your cosmo toolchain" >&2
-  exit
-fi
-
-if [ ! -d "$COSMO" ]; then
-  echo "$PROG: you need to clone cosmopolitan to your $COSMO directory" >&2
-  exit 1
-fi
-
-if [ ! -f "$COSMOS/lib/libc.a" ] ||
-   [ ! -f "$COSMOS/lib/.aarch64/libc.a" ] ||
-   [ ! -f "$COSMO/o/$MODE/cosmopolitan.a" ] ||
-   [ ! -f "$COSMO/o/$MODE_AARCH64/cosmopolitan.a" ]; then
-  echo "$PROG: you need to run: $PROG --update" >&2
-  exit 1
-fi
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-FIXUPOBJ="$COSMO/o//tool/build/fixupobj.com"
-TEMP_FILES=
-SAVE_TEMPS=0
-
-Exit() {
-  rc=${1:-$?}
-  if [ $SAVE_TEMPS -eq 0 ]; then
-    rm -f $TEMP_FILES
-  fi
-  exit $rc
-}
-
-show_warning() {
-  echo "$PROG: warning: $1" >&2
-}
-
-fatal_error() {
-  echo "$PROG: fatal error: $1" >&2
-  echo "compilation terminated." >&2
-  Exit 1
-}
-
-log_original() {
-  if [ -n "$BUILDLOG" ]; then
-    printf '# %s\n' "$ORIGINAL" >>"$BUILDLOG"
-  fi
-}
-
-log_command() {
-  if [ -n "$BUILDLOG" ]; then
-    printf '(cd %s; %s)\n' "$PWD" "$*" >>"$BUILDLOG"
-  fi
-}
-
-if [ x"$TMPDIR" != x"${TMPDIR#* }" ]; then
-  fatal_error '$TMPDIR containing spaces not supported'
-elif [ ! -d "$TMPDIR" ]; then
-  if ! mkdir -p "$TMPDIR" 2>/dev/null; then
-    fatal_error "$TMPDIR: not a directory"
-  fi
-fi
-
-OPT=
-ARGS=
-FLAGS=
-OUTPUT=
-MCOSMO=0
-INTENT=ld
-NEED_JOIN=
-NEED_EQUAL=
-NEED_OUTPUT=
-APELINKFLAGS=
-INPUT_FILE_COUNT=0
-for x; do
-  if [ x"$x" != x"${x#* }" ]; then
-    fatal_error "arguments containing spaces unsupported: $x"
-  fi
-  if [ -n "$NEED_OUTPUT" ]; then
-    NEED_OUTPUT=
-    OUTPUT=$x
-    continue
-  elif [ -n "$NEED_JOIN" ]; then
-    x="${NEED_JOIN}${x}"
-    NEED_JOIN=
-  elif [ -n "$NEED_EQUAL" ]; then
-    x="${NEED_EQUAL}=${x}"
-    NEED_EQUAL=
-  elif [ x"$x" = x"-" ] ||           # is alias for stdin
-       [ x"$x" = x"${x#-*}" ]; then  # !startswith(x, "-")
-    if [ x"$x" != x"${x%.s}" ] ||
-       [ x"$x" != x"${x%.S}" ]; then
-      fatal_error "$x: assembler input files not supported"
-    elif [ x"$x" != x"${x%.so}" ] ||
-         [ x"$x" != x"${x%.dll}" ] ||
-         [ x"$x" != x"${x%.dylib}" ]; then
-      fatal_error "$x: dynamic shared object input files not supported"
-    elif [ x"$x" != x"-" ] && [ ! -f "$x" ]; then
-      fatal_error "$x: no such file"
-    fi
-    INPUT_FILE_COUNT=$((INPUT_FILE_COUNT + 1))
-    ARGS="$ARGS $x"  # don't add to $FLAGS array
-    continue
-  elif [ x"$x" = x"-o" ]; then
-    NEED_OUTPUT=1
-    continue
-  elif [ x"$x" != x"${x#-o}" ]; then  # startswith(x, "-o")
-    OUTPUT=${x#-o}
-    continue
-  elif [ x"$x" != x"${x#-O}" ]; then  # startswith(x, "-O")
-    OPT=$x
-  elif [ x"$x" = x"-c" ]; then
-    INTENT=cc
-  elif [ x"$x" = x"-E" ]; then
-    INTENT=cpp
-  elif [ x"$x" = x"-s" ]; then
-    APELINKFLAGS="$APELINKFLAGS -s"
-    continue
-  elif [ x"$x" = x"-v" ]; then
-    exec 3<&2  # dup2(2, 3) b/c stderr will be redirected later
-    BUILDLOG=/dev/fd/3
-    continue
-  elif [ x"$x" = x"-save-temps" ]; then
-    SAVE_TEMPS=1
-  elif [ x"$x" = x"-mcosmo" ]; then
-    MCOSMO=1
-    continue
-  elif [ x"$x" = x"-fomit-frame-pointer" ]; then
-    # Quoth Apple: "The frame pointer register must always address a
-    # valid frame record. Some functions — such as leaf functions or
-    # tail calls — may opt not to create an entry in this list. As a
-    # result, stack traces are always meaningful, even without debug
-    # information."
-    x="-momit-leaf-frame-pointer -foptimize-sibling-calls"
-  elif [ x"$x" = x"-r" ] ||
-       [ x"$x" = x"-S" ] ||
-       [ x"$x" = x"-pie" ] ||
-       [ x"$x" = x"-frtti" ] ||
-       [ x"$x" = x"-shared" ] ||
-       [ x"$x" = x"-nostdlib" ] ||
-       [ x"$x" = x"-mred-zone" ] ||
-       [ x"$x" = x"-fexceptions" ] ||
-       [ x"$x" = x"-fsanitize=thread" ]; then
-    fatal_error "$x flag not supported"
-  elif [ x"$x" = x"-fsanitize=all" ] ||
-       [ x"$x" = x"-fsanitize=address" ] ||
-       [ x"$x" = x"-fsanitize=undefined" ]; then
-    fatal_error "use cosmo MODE=dbg rather than passing $x"
-  elif [ x"$x" = x"-mno-red-zone" ]; then
-    # "Any memory below the stack beyond the red zone is considered
-    # volatile and may be modified by the operating system at any time."
-    # https://devblogs.microsoft.com/oldnewthing/20190111-00/?p=100685
-    continue
-  elif [ x"$x" = x"-fpic" ] || [ x"$x" = x"-fPIC" ]; then
-    # no support for building dynamic shared objects yet. reports
-    # indicate that ignoring these flags, helps let autoconf know
-    continue
-  elif [ x"$x" = x"-Werror" ] || \
-       [ x"$x" = x"-pedantic-errors" ]; then
-    # this toolchain is intended for building other people's code
-    # elevating warnings into errors, should only be done by devs
-    continue
-  elif [ x"$x" = x"-static-libgcc" ] || \
-       [ x"$x" = x"-shared-libgcc" ]; then
-    # cosmopolitan.a always has llvm compiler runtime static code
-    continue
-  elif [ x"$x" = x"-march=native" ]; then
-    fatal_error "-march=native can't be used when building fat binaries"
-  elif [ x"$x" = x"-dumpversion" ]; then
-    echo $GCC_VERSION
-    Exit 0
-  elif [ x"$x" = x"-e" ] ||
-       [ x"$x" = x"-z" ] ||
-       [ x"$x" = x"-T" ] ||
-       [ x"$x" = x"-L" ] ||
-       [ x"$x" = x"-I" ] ||
-       [ x"$x" = x"-D" ] ||
-       [ x"$x" = x"-U" ] ||
-       [ x"$x" = x"-iquote" ] ||
-       [ x"$x" = x"-isystem" ] ||
-       [ x"$x" = x"-include" ]; then
-    NEED_JOIN=$x
-    continue
-  elif [ x"$x" = x"--param" ]; then
-    NEED_EQUAL=$x
-    continue
-  fi
-  FLAGS="$FLAGS $x"
-  ARGS="$ARGS $x"
-done
-
-if [ $INPUT_FILE_COUNT -eq 0 ]; then
-  fatal_error "no input files"
-elif [ -z "$INPUT" ] &&
-     [ $INTENT != ld ] &&
-     [ $INPUT_FILE_COUNT -gt 1 ]; then
-  fatal_error "cannot specify '-o' with '-c', or '-E' with multiple files"
-fi
-
-PLATFORM="-D__COSMOPOLITAN__ -D__COSMOCC__ -D__FATCOSMOCC__"
-PREDEF="-include libc/integral/normalize.inc"
-CPPFLAGS="-fno-pie -nostdinc -fno-math-errno -iquote $COSMO -isystem $COSMOS/include -isystem $COSMO/libc/isystem"
-CFLAGS="-fportcosmo -fno-dwarf2-cfi-asm -fno-unwind-tables -fno-asynchronous-unwind-tables -fno-semantic-interposition"
-LDFLAGS="-static -nostdlib -no-pie -fuse-ld=bfd -Wl,-z,norelro -Wl,--gc-sections"
-PRECIOUS="-fno-omit-frame-pointer"
-
-if [ x"$OPT" != x"-Os" ] && [ x"$MODE" != x"tiny" ]; then
-  CFLAGS="$CFLAGS -fno-optimize-sibling-calls -mno-omit-leaf-frame-pointer"
-fi
-
-CC_X86_64="$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-gcc"
-CC_AARCH64="$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-gcc"
-if [ x"$PROG" != x"${PROG%++}" ]; then
-  CC_X86_64="$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-g++"
-  CC_AARCH64="$COSMO/o/third_party/gcc/bin/aarch64-linux-$BRAND-g++"
-  CFLAGS="$CFLAGS -fno-rtti -fno-exceptions -fuse-cxa-atexit"
-fi
-
-CRT_X86_64="$COSMO/o/$MODE/ape/ape.o $COSMO/o/$MODE/libc/crt/crt.o"
-CPPFLAGS_X86_64="$CPPFLAGS -mno-red-zone"
-CFLAGS_X86_64="$CFLAGS -mno-tls-direct-seg-refs"
-LDFLAGS_X86_64="$LDFLAGS -L$COSMOS/lib -Wl,-T,$COSMO/o/$MODE/ape/ape.lds -Wl,-z,common-page-size=4096 -Wl,-z,max-page-size=16384"
-LDLIBS_X86_64="$COSMO/o/$MODE/cosmopolitan.a"
-if [ $MCOSMO -eq 1 ]; then
-  CPPFLAGS_X86_64="${CPPFLAGS_X86_64} -D_COSMO_SOURCE"
-fi
-
-CRT_AARCH64="$COSMO/o/$MODE_AARCH64/libc/crt/crt.o"
-CPPFLAGS_AARCH64="$CPPFLAGS"
-CFLAGS_AARCH64="$CFLAGS -ffixed-x18 -ffixed-x28 -mno-outline-atomics"
-LDFLAGS_AARCH64="$LDFLAGS -L$COSMOS/lib/.aarch64 -Wl,-T,$COSMO/o/${MODE_AARCH64}/ape/aarch64.lds -Wl,-z,common-page-size=16384 -Wl,-z,max-page-size=16384"
-LDLIBS_AARCH64="$COSMO/o/${MODE_AARCH64}/cosmopolitan.a"
-
-if [ x"$OPT" != x"-Os" ] && [ x"$MODE" != x"tiny" ]; then
-  CFLAGS_X86_64="${CFLAGS_X86_64} -fpatchable-function-entry=18,16"
-  CFLAGS_AARCH64="${CFLAGS_AARCH64} -fpatchable-function-entry=7,6"
-fi
-
-if [ x"$PROG" != x"${PROG%++}" ]; then
-  LDLIBS_X86_64="$COSMO/o/$MODE/third_party/libcxx/libcxx.a ${LDLIBS_X86_64}"
-  LDLIBS_AARCH64="$COSMO/o/${MODE_AARCH64}/third_party/libcxx/libcxx.a ${LDLIBS_AARCH64}"
-fi
-
-if [ x"$MODE" = x"dbg" ]; then
-  CPPFLAGS_X86_64="${CPPFLAGS_X86_64} -fsanitize=address -fsanitize=undefined"
-  CPPFLAGS_AARCH64="${CPPFLAGS_AARCH64} -fsanitize=undefined"
-fi
-
-log_original
-
-if [ $INTENT = cpp ]; then
-  if [ -n "$OUTPUT" ]; then
-    ARGS="$ARGS -o$OUTPUT"
-  fi
-  set -- \
-      "$CC_X86_64" \
-      -U__k8 \
-      -U__k8__ \
-      -U__amd64 \
-      -U__amd64__ \
-      -U__x86_64 \
-      -U__x86_64__ \
-      -U__SSE__ \
-      -U__SSE2__ \
-      -U__SSE2_MATH__ \
-      -mno-red-zone \
-      $PLATFORM \
-      $CPPFLAGS \
-      $ARGS
-  log_command "$@"
-  MODE="$MODE" exec "$@"
-fi
-
-mangle_object_path() {
-  path=$1
-  arch=$2
-  outdir=${path%/*}
-  outbas=${path##*/}
-  if [ x"$outdir" = x"$path" ]; then
-    outdir=
-  elif [ -n "$outdir" ]; then
-    outdir="$outdir/"
-  fi
-  if [ ! -d "$outdir.$arch" ]; then
-    mkdir -p "$outdir.$arch" || Exit
-  fi
-  mangled_path="${outdir}.$arch/$outbas"
-}
-
-mktemper() {
-  "$COSMO/o//tool/build/mktemper.com" \
-    "$TMPDIR/fatcosmocc.XXXXXXXXXXXXX$1"
-}
-
-build_object() {
-  out2=$(mktemper .txt) || Exit
-  TEMP_FILES="${TEMP_FILES} $out2"
-  (
-    set -- \
-        "$CC_X86_64" \
-        -o"$OUTPUT_X86_64" \
-        $PLATFORM \
-        $PREDEF \
-        $CFLAGS_X86_64 \
-        $CPPFLAGS_X86_64 \
-        "$@" \
-        $PRECIOUS
-    log_command "$@"
-    "$@" || exit
-    set -- \
-        "$COSMO/o//tool/build/fixupobj.com" \
-        "$OUTPUT_X86_64"
-    log_command "$@"
-    exec "$@"
-  ) &
-  pid1=$!
-  (
-    set -- \
-        "$CC_AARCH64" \
-        -o"$OUTPUT_AARCH64" \
-        $PLATFORM \
-        $PREDEF \
-        $CFLAGS_AARCH64 \
-        $CPPFLAGS_AARCH64 \
-        "$@" \
-        $PRECIOUS &&
-    log_command "$@"
-    "$@" || exit
-    set -- \
-        "$COSMO/o//tool/build/fixupobj.com" \
-        "$OUTPUT_AARCH64"
-    log_command "$@"
-    exec "$@"
-  ) 2>"$out2" &
-  pid2=$!
-  if ! wait $pid1; then
-    kill $pid2 2>/dev/null
-    wait
-    Exit 1
-  fi
-  if ! wait $pid2; then
-    echo "$PROG: x86_64 succeeded but aarch64 failed to build object" >&2
-    cat "$out2" >&2
-    Exit 1
-  fi
-}
-
-# turn source files into objects
-LDARGS_X86_64=
-LDARGS_AARCH64=
-for x in $ARGS; do
-  if [ x"$x" != x"-" ] &&           # is alias for stdin
-     [ x"$x" != x"${x#-*}" ]; then  # startswith(x, "-")
-    # this argument is a flag
-    LDARGS_X86_64="${LDARGS_X86_64} $x"
-    if [ x"$x" != x"${x#-L}" ]; then  # startswith(x, "-L")
-      x="$x/.aarch64"
-    fi
-    LDARGS_AARCH64="${LDARGS_AARCH64} $x"
-  else
-    # this argument is an input file
-    if [ x"$x" != x"${x%.o}" ] ||
-       [ x"$x" != x"${x%.a}" ]; then
-      if [ $INTENT = cc ]; then
-        show_warning "$x: linker input file unused because linking not done"
-      else
-        mangle_object_path "$x" aarch64
-        if [ ! -f "$mangled_path" ]; then
-          fatal_error "$x: linker input missing concomitant $mangled_path file"
-        fi
-        LDARGS_X86_64="${LDARGS_X86_64} $x"
-        LDARGS_AARCH64="${LDARGS_AARCH64} $mangled_path"
-      fi
-    elif [ $INTENT = cc ]; then
-      if [ -n "$OUTPUT" ]; then
-        # e.g. `cc -c -o bar.o foo.c` is specified by user
-        OUTPUT_X86_64=$OUTPUT
-        mangle_object_path "$OUTPUT" aarch64
-        OUTPUT_AARCH64="$mangled_path"
-        build_object $FLAGS -c "$x"
-      else
-        # e.g. `cc -c dir/foo.c` builds foo.o
-        o=${x##*/}
-        OUTPUT_X86_64="${o%.*}.o"
-        mangle_object_path "${o%.*}.o" aarch64
-        OUTPUT_AARCH64="$mangled_path"
-        build_object $FLAGS -c "$x"
-      fi
-    else
-      # e.g. `cc foo.c` should build a.out
-      if [ -z "$OUTPUT" ]; then
-        OUTPUT=a.out
-      fi
-      # e.g. `cc -o foo foo.c` should *not* build foo.o
-      OUTPUT_X86_64=$(mktemper .o) || Exit
-      OUTPUT_AARCH64=$(mktemper .o) || Exit
-      TEMP_FILES="${TEMP_FILES} ${OUTPUT_X86_64} ${OUTPUT_AARCH64}"
-      build_object $FLAGS -c "$x"
-      LDARGS_X86_64="${LDARGS_X86_64} ${OUTPUT_X86_64}"
-      LDARGS_AARCH64="${LDARGS_AARCH64} ${OUTPUT_AARCH64}"
-    fi
-  fi
-done
-
-if [ $INTENT != ld ]; then
-  Exit
-fi
-
-OUTPUT_X86_64=$(mktemper ".com.dbg") || Exit
-OUTPUT_AARCH64=$(mktemper ".aarch64.elf") || Exit
-
-out2=$(mktemper .txt) || Exit
-TEMP_FILES="${TEMP_FILES} $out2"
-(
-  set -- \
-      "$CC_X86_64" \
-      -o"$OUTPUT_X86_64"\
-      $CRT_X86_64 \
-      $LDFLAGS_X86_64 \
-      $LDARGS_X86_64 \
-      $LDLIBS_X86_64
-  log_command "$@"
-  "$@" || exit
-  set -- \
-      "$COSMO/o//tool/build/fixupobj.com" \
-      "$OUTPUT_X86_64"
-  log_command "$@"
-  exec "$@"
-) &
-pid1=$!
-(
-  set -- \
-      "$CC_AARCH64" \
-      -o"$OUTPUT_AARCH64"\
-      $CRT_AARCH64 \
-      $LDFLAGS_AARCH64 \
-      $LDARGS_AARCH64 \
-      $LDLIBS_AARCH64
-  log_command "$@"
-  "$@" || exit
-  set -- \
-      "$COSMO/o//tool/build/fixupobj.com" \
-      "$OUTPUT_AARCH64"
-  log_command "$@"
-  exec "$@"
-) 2>"$out2" &
-pid2=$!
-if ! wait $pid1; then
-  kill $pid2 2>/dev/null
-  wait
-  Exit 1
-fi
-if ! wait $pid2; then
-  echo "$PROG: x86_64 succeeded but aarch64 failed to link executable" >&2
-  cat "$out2" >&2
-  Exit 1
-fi
-
-set -- \
-"$COSMO/o//tool/build/apelink.com" \
-  -l "$COSMO/o/$MODE/ape/ape.elf" \
-  -l "$COSMO/o/$MODE_AARCH64/ape/ape.elf" \
-  -M "$COSMO/ape/ape-m1.c" \
-  -o "$OUTPUT" \
-  $APELINKFLAGS \
-  "$OUTPUT_X86_64" \
-  "$OUTPUT_AARCH64"
-log_command "$@"
-"$@" || Exit
-
-set -- \
-"$COSMO/o//tool/build/pecheck.com" "$OUTPUT"
-log_command "$@"
-"$@" || Exit
-
-if [ $INTENT = ld ] && [ $SAVE_TEMPS -eq 0 ]; then
-  mv -f "$OUTPUT_X86_64" "${OUTPUT%.com}.com.dbg" || Exit
-  mv -f "$OUTPUT_AARCH64" "${OUTPUT%.com}.aarch64.elf" || Exit
-fi
-
-Exit

bin/unknown-unknown-cosmo-ar

@@ -1 +0,0 @@
-fatcosmoar

bin/unknown-unknown-cosmo-c++

@@ -1 +0,0 @@
-fatcosmocc

bin/unknown-unknown-cosmo-cc

@@ -1 +0,0 @@
-fatcosmocc

bin/unknown-unknown-cosmo-install

@@ -1 +0,0 @@
-fatcosmoinstall

bin/x86_64-unknown-cosmo-addr2line

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-$m}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-addr2line"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: x86_64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/x86_64-unknown-cosmo-apecopy

@@ -1 +0,0 @@
-apecopy

bin/x86_64-unknown-cosmo-ar

@@ -1,22 +0,0 @@
-#!/bin/sh
-
-PROG=${0##*/}
-MODE=${MODE:-$m}
-COSMO=${COSMO:-/opt/cosmo}
-
-fatal_error() {
-  echo "$PROG: $1" >&2
-  exit 1
-}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-if [ ! -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-ar" ]; then
-  fatal_error "you need to run: x86_64-unknown-cosmo-cc --update"
-fi
-
-exec "$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-ar" "$@"

bin/x86_64-unknown-cosmo-as

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-$m}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-as"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: x86_64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/x86_64-unknown-cosmo-c++

@@ -1 +0,0 @@
-cosmocc

bin/x86_64-unknown-cosmo-cc

@@ -1 +0,0 @@
-cosmocc

bin/x86_64-unknown-cosmo-nm

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-$m}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-nm"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: x86_64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/x86_64-unknown-cosmo-objcopy

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-$m}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-objcopy"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: x86_64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/x86_64-unknown-cosmo-objdump

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-$m}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-objdump"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: x86_64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

bin/x86_64-unknown-cosmo-strip

@@ -1,19 +0,0 @@
-#!/bin/sh
-MODE=${MODE:-$m}
-COSMO=${COSMO:-/opt/cosmo}
-COSMOS=${COSMOS:-/opt/cosmos}
-
-if [ -x "$COSMO/o/third_party/gcc/bin/x86_64-linux-musl-gcc" ]; then
-  BRAND=musl
-else
-  BRAND=cosmo
-fi
-
-TOOL="$COSMO/o/third_party/gcc/bin/x86_64-linux-$BRAND-strip"
-
-if [ ! -x "$TOOL" ]; then
-  echo "$0: you need to run: x86_64-unknown-cosmo-cc --update" >&2
-  exit 1
-fi
-
-exec "$TOOL" "$@"

build/config.mk

@@ -1,5 +1,5 @@
 #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘
+#── vi: set et ft=make ts=8 sw=8 fenc=utf-8 :vi ──────────────────────┘
 
 # Default Mode
 #
@@ -228,6 +228,27 @@ PYFLAGS +=				\
 	-O2				\
 	-B
 endif
+ifeq ($(MODE), x86_64-tiny)
+CONFIG_CPPFLAGS +=			\
+	-DTINY				\
+	-DNDEBUG			\
+	-DTRUSTWORTHY
+CONFIG_CCFLAGS +=			\
+	-Os				\
+	-fno-align-functions		\
+	-fno-align-jumps		\
+	-fno-align-labels		\
+	-fno-align-loops		\
+	-fschedule-insns2		\
+	-momit-leaf-frame-pointer	\
+	-foptimize-sibling-calls	\
+	-DDWARFLESS
+TARGET_ARCH ?=				\
+	-msse3
+PYFLAGS +=				\
+	-O2				\
+	-B
+endif
 ifeq ($(MODE), aarch64-tiny)
 # TODO(jart): -mcmodel=tiny
 CONFIG_CPPFLAGS +=			\

build/definitions.mk

@@ -1,5 +1,5 @@
 #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘
+#── vi: set et ft=make ts=8 sw=8 fenc=utf-8 :vi ──────────────────────┘
 #
 # SYNOPSIS
 #
@@ -53,89 +53,6 @@
 #     OVERRIDE_FOO set ~/.cosmo.mk and target-specific (use rarely)
 #
 
-LC_ALL = C
-SOURCE_DATE_EPOCH = 0
-
-ARFLAGS = rcsD
-ZFLAGS ?=
-XARGS ?= xargs -P4 -rs8000
-DOT ?= dot
-CLANG = clang
-TMPDIR = o/tmp
-
-AR = build/bootstrap/ar.com
-CP = build/bootstrap/cp.com
-RM = build/bootstrap/rm.com -f
-GZIP = build/bootstrap/gzip.com
-ECHO = build/bootstrap/echo.com
-CHMOD = build/bootstrap/chmod.com
-TOUCH = build/bootstrap/touch.com
-PKG = build/bootstrap/package.com
-MKDEPS = build/bootstrap/mkdeps.com
-ZIPOBJ = build/bootstrap/zipobj.com
-ZIPCOPY = build/bootstrap/zipcopy.com
-PECHECK = build/bootstrap/pecheck.com
-FIXUPOBJ = build/bootstrap/fixupobj.com
-MKDIR = build/bootstrap/mkdir.com -p
-COMPILE = build/bootstrap/compile.com -V9 -P4096 $(QUOTA)
-
-COMMA := ,
-PWD := $(shell build/bootstrap/pwd.com)
-
-IGNORE := $(shell $(MKDIR) $(TMPDIR))
-
-ifneq ($(findstring aarch64,$(MODE)),)
-ARCH = aarch64
-HOSTS ?= pi silicon
-else
-ARCH = x86_64
-HOSTS ?= freebsd rhel7 xnu win10 openbsd netbsd
-endif
-
-ifeq ($(PREFIX),)
-ifeq ($(USE_SYSTEM_TOOLCHAIN),)
-ifeq ($(ARCH),x86_64)
-ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-linux-cosmo-*)","")
-PREFIX = o/third_party/gcc/bin/x86_64-linux-cosmo-
-else
-IGNORE := $(shell build/bootstrap/unbundle.com)
-PREFIX = o/third_party/gcc/bin/x86_64-linux-musl-
-endif
-endif # ($(ARCH),x86_64))
-ifeq ($(ARCH),aarch64)
-ifneq ("$(wildcard o/third_party/gcc/bin/aarch64-linux-cosmo-*)","")
-PREFIX = o/third_party/gcc/bin/aarch64-linux-cosmo-
-else
-IGNORE := $(shell build/bootstrap/unbundle.com)
-PREFIX = o/third_party/gcc/bin/aarch64-linux-musl-
-endif
-endif # ($(ARCH),aarch64)
-endif # ($(USE_SYSTEM_TOOLCHAIN),)
-endif # ($(PREFIX),)
-
-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
-ifneq ($(wildcard $(PWD)/$(PREFIX)addr2line),)
-ADDR2LINE = $(PWD)/$(PREFIX)addr2line
-else
-ADDR2LINE = $(PREFIX)addr2line
-endif
-
-export ADDR2LINE
-export LC_ALL
-export MKDIR
-export MODE
-export SOURCE_DATE_EPOCH
-export TMPDIR
-
 ifeq ($(LANDLOCKMAKE_VERSION),)
 TMPSAFE = $(join $(TMPDIR),$(subst /,_,$@)).tmp
 else
@@ -222,7 +139,8 @@ DEFAULT_CPPFLAGS +=							\
 	-D_COSMO_SOURCE							\
 	-DMODE='"$(MODE)"'						\
 	-nostdinc							\
-	-iquote .
+	-iquote.							\
+	-isystem libc/isystem
 
 DEFAULT_CFLAGS =							\
 	-std=gnu2x

build/download-cosmocc.sh

@@ -0,0 +1,91 @@
+#!/bin/sh
+# cosmocc downloader script
+# https://justine.lol/cosmo3/#install
+# https://github.com/jart/cosmopolitan/blob/master/tool/cosmocc/README.md
+
+# collect arguments
+OUTPUT_DIR=${1:?OUTPUT_DIR}
+COSMOCC_VERSION=${2:?COSMOCC_VERSION}
+COSMOCC_SHA256SUM=${3:?COSMOCC_SHA256SUM}
+URL1="https://github.com/jart/cosmopolitan/releases/download/${COSMOCC_VERSION}/cosmocc-${COSMOCC_VERSION}.zip"
+URL2="https://cosmo.zip/pub/cosmocc/cosmocc-${COSMOCC_VERSION}.zip"
+
+# helper function
+abort() {
+  printf '%s\n' "download terminated." >&2
+  exit 1
+}
+
+# exit if already downloaded
+# we need it because directory timestamps work wierdly
+OUTPUT_DIR=${OUTPUT_DIR%/}
+if [ -d "${OUTPUT_DIR}" ]; then
+  exit 0
+fi
+
+# find commands we need to securely download cosmocc
+if ! UNZIP=$(command -v unzip 2>/dev/null); then
+  printf '%s\n' "$0: fatal error: you need the unzip command" >&2
+  printf '%s\n' "please download https://cosmo.zip/pub/cosmos/bin/unzip and put it on the system path" >&2
+  abort
+fi
+if ! SHA256SUM=$(command -v sha256sum 2>/dev/null); then
+  if [ ! -f build/sha256sum.c ]; then
+    printf '%s\n' "$0: fatal error: you need to install sha256sum" >&2
+    printf '%s\n' "please download https://cosmo.zip/pub/cosmos/bin/sha256sum and put it on the system path" >&2
+    abort
+  fi
+  if ! SHA256SUM=$(command -v "$PWD/o/build/sha256sum" 2>/dev/null); then
+    if ! CC=$(command -v "$CC" 2>/dev/null); then
+      if ! CC=$(command -v cc 2>/dev/null); then
+        if ! CC=$(command -v cosmocc 2>/dev/null); then
+          printf '%s\n' "$0: fatal error: you need to install either sha256sum, cc, or cosmocc" >&2
+          printf '%s\n' "please download https://cosmo.zip/pub/cosmos/bin/sha256sum and put it on the system path" >&2
+          abort
+        fi
+      fi
+    fi
+    mkdir -p o/build || abort
+    SHA256SUM="$PWD/o/build/sha256sum"
+    printf '%s\n' "${CC} -w -O2 -o ${SHA256SUM} build/sha256sum.c" >&2
+    "${CC}" -w -O2 -o "${SHA256SUM}.$$" build/sha256sum.c || abort
+    mv -f "${SHA256SUM}.$$" "${SHA256SUM}" || abort
+  fi
+fi
+if WGET=$(command -v wget 2>/dev/null); then
+  DOWNLOAD=$WGET
+  DOWNLOAD_ARGS=-O
+elif CURL=$(command -v curl 2>/dev/null); then
+  DOWNLOAD=$CURL
+  DOWNLOAD_ARGS=-fLo
+else
+  printf '%s\n' "$0: fatal error: you need to install either wget or curl" >&2
+  printf '%s\n' "please download https://cosmo.zip/pub/cosmos/bin/wget and put it on the system path" >&2
+  abort
+fi
+
+# create temporary output directory
+OLDPWD=$PWD
+OUTPUT_TMP="${OUTPUT_DIR}.tmp.$$/"
+mkdir -p "${OUTPUT_TMP}" || abort
+cd "${OUTPUT_TMP}"
+die() {
+  cd "${OLDPWD}"
+  rm -rf "${OUTPUT_TMP}"
+  abort
+}
+
+# download cosmocc toolchain
+# multiple urls avoids outages and national firewalls
+if ! "${DOWNLOAD}" ${DOWNLOAD_ARGS} cosmocc.zip "${URL1}"; then
+  rm -f cosmocc.zip
+  "${DOWNLOAD}" ${DOWNLOAD_ARGS} cosmocc.zip "${URL2}" || die
+fi
+printf '%s\n' "${COSMOCC_SHA256SUM} *cosmocc.zip" >cosmocc.zip.sha256sum
+"${SHA256SUM}" -c cosmocc.zip.sha256sum || die
+"${UNZIP}" cosmocc.zip || die
+rm -f cosmocc.zip cosmocc.zip.sha256sum
+
+# commit output directory
+cd "${OLDPWD}" || die
+mv "${OUTPUT_TMP}" "${OUTPUT_DIR}" || die

build/functions.mk

@@ -1,5 +1,5 @@
 #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘
+#── vi: set et ft=make ts=8 sw=8 fenc=utf-8 :vi ──────────────────────┘
 #
 # SYNOPSIS
 #

build/htags

@@ -1,6 +1,6 @@
 #!/bin/sh
 #-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+#── vi: set et ft=sh ts=2 sts=2 fenc=utf-8 :vi ─────────────┘
 #
 # OVERVIEW
 #

build/objdump

@@ -6,14 +6,14 @@ if [ -n "$OBJDUMP" ]; then
 fi
 
 find_objdump() {
-  if [ -x o/third_party/gcc/bin/$1-linux-cosmo-objdump ]; then
-    OBJDUMP=o/third_party/gcc/bin/$1-linux-cosmo-objdump
-  elif [ -x o/third_party/gcc/bin/$1-linux-musl-objdump ]; then
-    OBJDUMP=o/third_party/gcc/bin/$1-linux-musl-objdump
-  elif [ -x "$COSMO/o/third_party/gcc/bin/$1-linux-cosmo-objdump" ]; then
-    OBJDUMP="$COSMO/o/third_party/gcc/bin/$1-linux-cosmo-objdump"
-  elif [ -x "$COSMO/o/third_party/gcc/bin/$1-linux-musl-objdump" ]; then
-    OBJDUMP="$COSMO/o/third_party/gcc/bin/$1-linux-musl-objdump"
+  if [ -x cosmocc/3.2/bin/$1-linux-cosmo-objdump ]; then
+    OBJDUMP=cosmocc/3.2/bin/$1-linux-cosmo-objdump
+  elif [ -x cosmocc/3.2/bin/$1-linux-musl-objdump ]; then
+    OBJDUMP=cosmocc/3.2/bin/$1-linux-musl-objdump
+  elif [ -x "$COSMO/cosmocc/3.2/bin/$1-linux-cosmo-objdump" ]; then
+    OBJDUMP="$COSMO/cosmocc/3.2/bin/$1-linux-cosmo-objdump"
+  elif [ -x "$COSMO/cosmocc/3.2/bin/$1-linux-musl-objdump" ]; then
+    OBJDUMP="$COSMO/cosmocc/3.2/bin/$1-linux-musl-objdump"
   else
     echo "error: toolchain not found (try running 'cosmocc --update' or 'make' in the cosmo monorepo)" >&2
     exit 1

build/online.mk

@@ -1,5 +1,5 @@
 #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘
+#── vi: set et ft=make ts=8 sw=8 fenc=utf-8 :vi ──────────────────────┘
 #
 # SYNOPSIS
 #

build/realify.sed

@@ -1,5 +1,5 @@
 #-*-mode:sed;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#───vi: et ft=sed ts=8 tw=8 fenc=utf-8 :vi─────────────────┘
+#── vi: et ft=sed ts=8 sw=8 fenc=utf-8 :vi ────────────────┘
 #
 # SYNOPSIS
 #

build/rules.mk

@@ -1,5 +1,5 @@
 #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘
+#── vi: set et ft=make ts=8 sw=8 fenc=utf-8 :vi ──────────────────────┘
 #
 # SYNOPSIS
 #

dsp/BUILD.mk

@@ -0,0 +1,8 @@
+#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
+#── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
+
+.PHONY:		o/$(MODE)/dsp
+o/$(MODE)/dsp:	o/$(MODE)/dsp/core	\
+		o/$(MODE)/dsp/mpeg	\
+		o/$(MODE)/dsp/scale	\
+		o/$(MODE)/dsp/tty

dsp/bmp/bmp.mk

@@ -1,5 +1,5 @@
 #-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘
+#── vi: set et ft=make ts=8 sw=8 fenc=utf-8 :vi ──────────────────────┘
 
 PKGS += DSP_BMP
 

dsp/core/BUILD.mk

@@ -0,0 +1,61 @@
+#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
+#── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
+
+PKGS += DSP_CORE
+
+DSP_CORE_ARTIFACTS += DSP_CORE_A
+DSP_CORE = $(DSP_CORE_A_DEPS) $(DSP_CORE_A)
+DSP_CORE_A = o/$(MODE)/dsp/core/core.a
+DSP_CORE_A_FILES := $(wildcard dsp/core/*)
+DSP_CORE_A_HDRS = $(filter %.h,$(DSP_CORE_A_FILES))
+DSP_CORE_A_SRCS = $(filter %.c,$(DSP_CORE_A_FILES))
+DSP_CORE_A_OBJS = $(DSP_CORE_A_SRCS:%.c=o/$(MODE)/%.o)
+
+DSP_CORE_A_CHECKS =				\
+	$(DSP_CORE_A).pkg			\
+	$(DSP_CORE_A_HDRS:%=o/$(MODE)/%.ok)
+
+DSP_CORE_A_DIRECTDEPS =				\
+	LIBC_INTRIN				\
+	LIBC_MEM				\
+	LIBC_NEXGEN32E				\
+	LIBC_STR				\
+	LIBC_TINYMATH
+
+DSP_CORE_A_DEPS :=				\
+	$(call uniq,$(foreach x,$(DSP_CORE_A_DIRECTDEPS),$($(x))))
+
+$(DSP_CORE_A):	dsp/core/			\
+		$(DSP_CORE_A).pkg		\
+		$(DSP_CORE_A_OBJS)
+
+$(DSP_CORE_A).pkg:				\
+		$(DSP_CORE_A_OBJS)		\
+		$(foreach x,$(DSP_CORE_A_DIRECTDEPS),$($(x)_A).pkg)
+
+o/$(MODE)/dsp/core/dct.o			\
+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: private	\
+		CFLAGS +=			\
+			$(MATHEMATICAL)
+
+o/tiny/dsp/core/scalevolume.o: private		\
+		CFLAGS +=			\
+			-Os
+
+o/$(MODE)/dsp/core/det3.o: private		\
+		CFLAGS +=			\
+			-ffast-math
+
+DSP_CORE_LIBS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)))
+DSP_CORE_SRCS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_SRCS))
+DSP_CORE_HDRS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_HDRS))
+DSP_CORE_CHECKS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_CHECKS))
+DSP_CORE_OBJS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_OBJS))
+$(DSP_CORE_OBJS): $(BUILD_FILES) dsp/core/BUILD.mk
+
+.PHONY: o/$(MODE)/dsp/core
+o/$(MODE)/dsp/core: $(DSP_CORE_CHECKS)

dsp/core/alaw.c

@@ -1,5 +1,5 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2021 Justine Alexandra Roberts Tunney                              │
 │                                                                              │

dsp/core/byte2double.c

@@ -1,5 +1,5 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2020 Justine Alexandra Roberts Tunney                              │
 │                                                                              │

dsp/core/c11.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C11_H_
 #define COSMOPOLITAN_DSP_CORE_C11_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 /**
  * Fixed-point 8-bit rounded mean kernel.
@@ -17,5 +16,4 @@ __funline unsigned char C11(unsigned char al, unsigned char bl) {
   return al;
 }
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_C11_H_ */

dsp/core/c121.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C121_H_
 #define COSMOPOLITAN_DSP_CORE_C121_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 __funline unsigned char C121(unsigned char al, unsigned char bl,
@@ -16,5 +15,4 @@ __funline unsigned char C121(unsigned char al, unsigned char bl,
 }
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_C121_H_ */

dsp/core/c121s.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C121S_H_
 #define COSMOPOLITAN_DSP_CORE_C121S_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 __funline signed char C121S(signed char al, signed char bl, signed char cl) {
   short ax;
@@ -13,5 +12,4 @@ __funline signed char C121S(signed char al, signed char bl, signed char cl) {
   return ax;
 }
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_C121S_H_ */

dsp/core/c1331.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C1331_H_
 #define COSMOPOLITAN_DSP_CORE_C1331_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 /**
  * Byte sized kernel for resampling memory in half.
@@ -24,5 +23,4 @@ __funline unsigned char C1331(unsigned char al, unsigned char bl,
   return al;
 }
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_C1331_H_ */

dsp/core/c1331s.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C1331S_H_
 #define COSMOPOLITAN_DSP_CORE_C1331S_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 /**
  * Byte sized kernel for resampling difference samples in half.
@@ -22,5 +21,4 @@ __funline signed char C1331S(signed char al, signed char bl, signed char cl,
   return ax;
 }
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_C1331S_H_ */

dsp/core/c161.h

@@ -1,7 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C161_H_
 #define COSMOPOLITAN_DSP_CORE_C161_H_
 #include "libc/macros.internal.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 #define EXTRA_SHARP 2
 
@@ -28,5 +27,4 @@ __funline unsigned char C161(unsigned char al, unsigned char bl,
   return MIN(255, MAX(0, ax));
 }
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_C161_H_ */

dsp/core/c161s.h

@@ -2,7 +2,6 @@
 #define COSMOPOLITAN_DSP_CORE_C161S_H_
 #include "dsp/core/c161.h"
 #include "libc/macros.internal.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 __funline signed char C161S(signed char al, signed char bl, signed char cl) {
   short ax, bx, cx;
@@ -20,5 +19,4 @@ __funline signed char C161S(signed char al, signed char bl, signed char cl) {
   return al;
 }
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_C161S_H_ */

dsp/core/c331.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C331_H_
 #define COSMOPOLITAN_DSP_CORE_C331_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 /**
@@ -25,5 +24,4 @@ __funline unsigned char C331(unsigned char al, unsigned char bl,
 }
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_C331_H_ */

dsp/core/core.h

@@ -9,8 +9,9 @@ int mulaw(int);
 int unmulaw(int);
 void *double2byte(long, const void *, double, double) vallocesque;
 void *byte2double(long, const void *, double, double) vallocesque;
-void *dct(float[8][8], float, float, float, float, float);
-void *dctjpeg(float[8][8]);
+void *dct(float[restrict hasatleast 8][8], unsigned,
+          float, float, float, float, float);
+void *dctjpeg(float[restrict hasatleast 8][8], unsigned);
 double det3(const double[3][3]) nosideeffect;
 void *inv3(double[restrict 3][3], const double[restrict 3][3], double);
 void *matmul3(double[restrict 3][3], const double[3][3], const double[3][3]);

dsp/core/core.mk

@@ -1,61 +0,0 @@
-#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘
-
-PKGS += DSP_CORE
-
-DSP_CORE_ARTIFACTS += DSP_CORE_A
-DSP_CORE = $(DSP_CORE_A_DEPS) $(DSP_CORE_A)
-DSP_CORE_A = o/$(MODE)/dsp/core/core.a
-DSP_CORE_A_FILES := $(wildcard dsp/core/*)
-DSP_CORE_A_HDRS = $(filter %.h,$(DSP_CORE_A_FILES))
-DSP_CORE_A_SRCS = $(filter %.c,$(DSP_CORE_A_FILES))
-DSP_CORE_A_OBJS = $(DSP_CORE_A_SRCS:%.c=o/$(MODE)/%.o)
-
-DSP_CORE_A_CHECKS =				\
-	$(DSP_CORE_A).pkg			\
-	$(DSP_CORE_A_HDRS:%=o/$(MODE)/%.ok)
-
-DSP_CORE_A_DIRECTDEPS =				\
-	LIBC_INTRIN				\
-	LIBC_MEM				\
-	LIBC_NEXGEN32E				\
-	LIBC_STR				\
-	LIBC_TINYMATH
-
-DSP_CORE_A_DEPS :=				\
-	$(call uniq,$(foreach x,$(DSP_CORE_A_DIRECTDEPS),$($(x))))
-
-$(DSP_CORE_A):	dsp/core/			\
-		$(DSP_CORE_A).pkg		\
-		$(DSP_CORE_A_OBJS)
-
-$(DSP_CORE_A).pkg:				\
-		$(DSP_CORE_A_OBJS)		\
-		$(foreach x,$(DSP_CORE_A_DIRECTDEPS),$($(x)_A).pkg)
-
-o/$(MODE)/dsp/core/dct.o			\
-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: private	\
-		CFLAGS +=			\
-			$(MATHEMATICAL)
-
-o/tiny/dsp/core/scalevolume.o: private		\
-		CFLAGS +=			\
-			-Os
-
-o/$(MODE)/dsp/core/det3.o: private		\
-		CFLAGS +=			\
-			-ffast-math
-
-DSP_CORE_LIBS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)))
-DSP_CORE_SRCS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_SRCS))
-DSP_CORE_HDRS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_HDRS))
-DSP_CORE_CHECKS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_CHECKS))
-DSP_CORE_OBJS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_OBJS))
-$(DSP_CORE_OBJS): $(BUILD_FILES) dsp/core/core.mk
-
-.PHONY: o/$(MODE)/dsp/core
-o/$(MODE)/dsp/core: $(DSP_CORE_CHECKS)