Release Cosmopolitan v3.0

https://git.musl-libc.org/cgit/musl/snapshot/musl-1.2.4.tar.gz

.clang-format

@@ -8,6 +8,7 @@ AlwaysBreakBeforeMultilineStrings: false
 AllowShortFunctionsOnASingleLine: false
 KeepEmptyLinesAtTheStartOfBlocks: true
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
+IncludeBlocks: Merge
 ---
 Language: Cpp
 AllowShortFunctionsOnASingleLine: false

.gitattributes

@@ -1,3 +1,4 @@
 # -*- conf -*-
+*.gz                         binary
 /build/bootstrap/*.com       binary
 /usr/share/zoneinfo/*        binary

.github/workflows/build.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        mode: ["", tiny, opt, rel]
+        mode: ["", tiny, rel, tinylinux, optlinux]
     steps:
       - uses: actions/checkout@v3
 

.gitignore

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

.vscode/c_cpp_properties.json

@@ -15,7 +15,7 @@
 				"alignas(x)",
 				"alignof(x)",
 				"artificial=",
-				"dontdiscard=",
+				"__wur=",
 				"mayalias=",
 				"forceinline=",
 				"forcealign(x)=",
@@ -35,14 +35,13 @@
 				"returnstwice=",
 				"textwindows=",
 				"privileged=",
-				"compatfn=",
-				"noinstrument=",
+				"dontinstrument=",
 				"nodebuginfo=",
 				"interruptfn=",
 				"optimizespeed=",
 				"forcealignargpointer=",
-				"noasan=",
-				"noubsan=",
+				"dontasan=",
+				"dontubsan=",
 				"donothing=",
 				"nosideeffect=",
 				"unreachable=",,
@@ -78,7 +77,6 @@
 				"-Wa,-W",
 				"-Wa,-I.",
 				"-Wa,--noexecstack",
-				"-Wa,--nocompress-debug-sections",
 				"-Og",
 				"-g",
 				"-gdescribe-dies",
@@ -103,8 +101,7 @@
 			],
 			"defines": [
 				"COSMO",
-				"MODE=",
-				"IMAGE_BASE_VIRTUAL=0x400000"
+				"MODE="
 			]
 		}
 	],

Makefile

@@ -60,13 +60,12 @@
 #   build/config.mk
 
 SHELL      = build/bootstrap/cocmd.com
-HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 xnu win10
 MAKEFLAGS += --no-builtin-rules
 
 .SUFFIXES:
 .DELETE_ON_ERROR:
 .FEATURES: output-sync
-.PHONY: all o bins check test depend tags
+.PHONY: all o bins check test depend tags aarch64 clean
 
 ifneq ($(m),)
 ifeq ($(MODE),)
@@ -74,9 +73,38 @@ MODE := $(m)
 endif
 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.12.zip and unzip it inside the cosmo directory)
+endif
+endif
+endif
+
+# the default build modes is empty string
+# on x86_64 hosts, MODE= is the same as MODE=x86_64
+# on aarch64 hosts, MODE= is changed to MODE=aarch64
+ifeq ($(MODE),)
+ifeq ($(UNAME_M),arm64)
+MODE := aarch64
+endif
+ifeq ($(UNAME_M),aarch64)
+MODE := aarch64
+endif
+endif
+
+# primary build rules
 all:	o
 o:	o/$(MODE)
-
 o/$(MODE):			\
 	o/$(MODE)/ape		\
 	o/$(MODE)/dsp		\
@@ -87,20 +115,39 @@ o/$(MODE):			\
 	o/$(MODE)/examples	\
 	o/$(MODE)/third_party
 
+# 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)
+ifneq ($(LANDLOCKMAKE_VERSION),)
+ifeq ($(UNAME_S),Linux)
+ifeq ($(wildcard /usr/bin/ape),)
+$(warning please run ape/apeinstall.sh if you intend to use landlock make)
+$(shell sleep .5)
+endif
+endif
+ifeq ($(USE_SYSTEM_TOOLCHAIN),)
 .STRICT = 1
-.PLEDGE = stdio rpath wpath cpath fattr proc
-.UNVEIL =			\
-	libc/integral		\
-	libc/disclaimer.inc	\
-	rwc:/dev/shm		\
-	rx:build/bootstrap	\
-	rx:o/third_party/gcc	\
-	/proc/stat		\
-	rw:/dev/null		\
-	w:o/stack.log		\
-	/etc/hosts		\
-	~/.runit.psk		\
-	/proc/self/status	\
+endif
+endif
+
+.PLEDGE += stdio rpath wpath cpath fattr proc
+.UNVEIL +=					\
+	libc/integral				\
+	libc/stdbool.h				\
+	libc/disclaimer.inc			\
+	rwc:/dev/shm				\
+	rx:build/bootstrap			\
+	rx:o/third_party/gcc			\
+	r:build/portcosmo.h			\
+	/proc/stat				\
+	rw:/dev/null				\
+	rw:/dev/full				\
+	w:o/stack.log				\
+	/etc/hosts				\
+	~/.runit.psk				\
+	/proc/self/status			\
+	rx:/usr/bin/qemu-aarch64		\
+	rx:o/third_party/qemu/qemu-aarch64	\
 	/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
 
 PKGS =
@@ -110,54 +157,59 @@ include build/functions.mk			#─┐
 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/stubs/stubs.mk			#─┘
+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 libc/linux/linux.mk			# │  You can manipulate arrays
+include third_party/compiler_rt/compiler_rt.mk	# │  You can manipulate arrays
 include libc/tinymath/tinymath.mk		# │  You can issue raw system calls
-include third_party/compiler_rt/compiler_rt.mk	# │
 include libc/str/str.mk				# │
 include third_party/xed/xed.mk			# │
-include third_party/zlib/zlib.mk		# │
-include third_party/double-conversion/dc.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/calls/calls.mk			#─┐
-include third_party/getopt/getopt.mk		# │
-include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
-include libc/crt/crt.mk				# │  You can issue system calls
 include third_party/nsync/nsync.mk		# │
+include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
+include third_party/double-conversion/dc.mk	# │  You can issue system calls
+include libc/crt/crt.mk				# │
 include third_party/dlmalloc/dlmalloc.mk	#─┘
 include libc/mem/mem.mk				#─┐
-include libc/zipos/zipos.mk			# ├──DYNAMIC RUNTIME
-include third_party/gdtoa/gdtoa.mk		# │  You can now use stdio
-include libc/time/time.mk			# │  You can finally call malloc()
-include third_party/nsync/mem/mem.mk		# │
-include libc/thread/thread.mk			# │
+include 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 third_party/libcxx/libcxx.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/musl/musl.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
@@ -172,6 +224,8 @@ 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
@@ -186,15 +240,15 @@ 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/emucrt/emucrt.mk
-include tool/build/emubin/emubin.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
@@ -205,7 +259,6 @@ include tool/lambda/lambda.mk
 include tool/plinko/lib/lib.mk
 include tool/plinko/plinko.mk
 include test/tool/plinko/test.mk
-include tool/hash/hash.mk
 include tool/net/net.mk
 include tool/viz/viz.mk
 include tool/tool.mk
@@ -226,8 +279,8 @@ 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/zipos/test.mk
 include test/libc/release/test.mk
 include test/libc/test.mk
 include test/net/http/test.mk
@@ -266,14 +319,14 @@ tags:	TAGS HTAGS
 o/$(MODE)/.x:
 	@$(COMPILE) -AMKDIR -tT$@ $(MKDIR) $(@D)
 
-o/$(MODE)/srcs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
+o/$(MODE)/srcs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x)))) $(SRCS)
 	$(file >$@,$(SRCS))
-o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
+o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x)))) $(HDRS) $(INCS)
 	$(file >$@,$(HDRS) $(INCS))
-o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x))))
+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 $@ -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)))
@@ -281,12 +334,12 @@ o/$(MODE)/hdrs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS
 	$(file >$@) $(foreach x,$(HDRS) $(INCS),$(file >>$@,$(x)))
 
 TAGS: private .UNSANDBOXED = 1
-TAGS:	o/$(MODE)/srcs-old.txt $(SRCS) o/$(MODE)/third_party/ctags/ctags.com
+TAGS:	o/$(MODE)/srcs-old.txt $(SRCS) #o/$(MODE)/third_party/ctags/ctags.com
 	@$(RM) $@
 	@o/$(MODE)/third_party/ctags/ctags.com $(TAGSFLAGS) -L $< -o $@
 
 HTAGS: private .UNSANDBOXED = 1
-HTAGS:	o/$(MODE)/hdrs-old.txt $(HDRS) o/$(MODE)/third_party/ctags/ctags.com
+HTAGS:	o/$(MODE)/hdrs-old.txt $(filter-out third_party/libcxx/%,$(HDRS)) #o/$(MODE)/third_party/ctags/ctags.com
 	@$(RM) $@
 	@build/htags o/$(MODE)/third_party/ctags/ctags.com -L $< -o $@
 
@@ -298,23 +351,23 @@ loc: o/$(MODE)/tool/build/summy.com
 # PLEASE: MAINTAIN TOPOLOGICAL ORDER
 # FROM HIGHEST LEVEL TO LOWEST LEVEL
 COSMOPOLITAN_OBJECTS =			\
+	TOOL_ARGS			\
 	NET_HTTP			\
 	LIBC_DNS			\
 	LIBC_SOCK			\
 	LIBC_NT_WS2_32			\
 	LIBC_NT_IPHLPAPI		\
-	LIBC_NT_MSWSOCK			\
 	LIBC_X				\
 	THIRD_PARTY_GETOPT		\
 	LIBC_LOG			\
 	LIBC_TIME			\
-	LIBC_ZIPOS			\
-	THIRD_PARTY_ZLIB		\
 	THIRD_PARTY_MUSL		\
+	THIRD_PARTY_ZLIB_GZ		\
 	LIBC_STDIO			\
 	THIRD_PARTY_GDTOA		\
 	THIRD_PARTY_REGEX		\
 	LIBC_THREAD			\
+	LIBC_PROC			\
 	THIRD_PARTY_NSYNC_MEM		\
 	LIBC_MEM			\
 	THIRD_PARTY_DLMALLOC		\
@@ -329,12 +382,13 @@ COSMOPOLITAN_OBJECTS =			\
 	LIBC_NT_PDH			\
 	LIBC_NT_GDI32			\
 	LIBC_NT_COMDLG32		\
-	LIBC_NT_URL			\
 	LIBC_NT_USER32			\
 	LIBC_NT_NTDLL			\
 	LIBC_NT_ADVAPI32		\
 	LIBC_NT_SYNCHRONIZATION		\
 	LIBC_FMT			\
+	THIRD_PARTY_ZLIB		\
+	THIRD_PARTY_PUFF		\
 	THIRD_PARTY_COMPILER_RT		\
 	LIBC_TINYMATH			\
 	THIRD_PARTY_XED			\
@@ -359,6 +413,7 @@ COSMOPOLITAN_HEADERS =			\
 	LIBC_RUNTIME			\
 	LIBC_SOCK			\
 	LIBC_STDIO			\
+	LIBC_PROC			\
 	THIRD_PARTY_NSYNC		\
 	THIRD_PARTY_XED			\
 	LIBC_STR			\
@@ -367,9 +422,9 @@ COSMOPOLITAN_HEADERS =			\
 	LIBC_TIME			\
 	LIBC_TINYMATH			\
 	LIBC_X				\
-	LIBC_ZIPOS			\
 	LIBC_VGA			\
 	NET_HTTP			\
+	TOOL_ARGS			\
 	THIRD_PARTY_DLMALLOC		\
 	THIRD_PARTY_GDTOA		\
 	THIRD_PARTY_GETOPT		\
@@ -385,7 +440,10 @@ o/cosmopolitan.h:							\
 		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS))	\
 		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_INCS))
 	$(file >$(TMPDIR)/$(subst /,_,$@),libc/integral/normalize.inc $(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS)))
-	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >$@
+	@$(ECHO) '#ifndef __STRICT_ANSI__' >$@
+	@$(ECHO) '#define _COSMO_SOURCE' >>$@
+	@$(ECHO) '#endif' >>$@
+	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >>$@
 
 o/cosmopolitan.html: private .UNSANDBOXED = 1
 o/cosmopolitan.html:							\
@@ -396,7 +454,7 @@ o/cosmopolitan.html:							\
 	$(file >$(TMPDIR)/$(subst /,_,$@),$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS))))
 	o/$(MODE)/third_party/chibicc/chibicc.com.dbg -J		\
 		-fno-common -include libc/integral/normalize.inc -o $@	\
-		@$(TMPDIR)/$(subst /,_,$@)
+		-DCOSMO @$(TMPDIR)/$(subst /,_,$@)
 
 $(SRCS):					\
 	libc/integral/normalize.inc		\
@@ -406,14 +464,50 @@ $(SRCS):					\
 	libc/integral/lp64arg.inc		\
 	libc/integral/lp64.inc
 
+ifeq ($(ARCH), x86_64)
+TOOLCHAIN_ARTIFACTS =				\
+	o/cosmopolitan.h			\
+	o/$(MODE)/ape/ape.lds			\
+	o/$(MODE)/libc/crt/crt.o		\
+	o/$(MODE)/ape/ape.elf			\
+	o/$(MODE)/ape/ape.o			\
+	o/$(MODE)/ape/ape-copy-self.o		\
+	o/$(MODE)/ape/ape-no-modify-self.o	\
+	o/$(MODE)/cosmopolitan.a		\
+	o/$(MODE)/third_party/libcxx/libcxx.a	\
+	o/$(MODE)/tool/build/march-native.com	\
+	o/$(MODE)/tool/build/ar.com		\
+	o/$(MODE)/tool/build/mktemper.com	\
+	o/$(MODE)/tool/build/fixupobj.com	\
+	o/$(MODE)/tool/build/zipcopy.com	\
+	o/$(MODE)/tool/build/apelink.com	\
+	o/$(MODE)/tool/build/pecheck.com
+else
+TOOLCHAIN_ARTIFACTS =				\
+	o/$(MODE)/ape/ape.elf			\
+	o/$(MODE)/ape/aarch64.lds		\
+	o/$(MODE)/libc/crt/crt.o		\
+	o/$(MODE)/cosmopolitan.a		\
+	o/$(MODE)/third_party/libcxx/libcxx.a	\
+	o/$(MODE)/tool/build/march-native.com	\
+	o/$(MODE)/tool/build/fixupobj.com	\
+	o/$(MODE)/tool/build/zipcopy.com
+endif
+
 .PHONY: toolchain
-toolchain:	o/cosmopolitan.h				\
-		o/$(MODE)/ape/public/ape.lds			\
-		o/$(MODE)/libc/crt/crt.o			\
-		o/$(MODE)/ape/ape.o				\
-		o/$(MODE)/ape/ape-copy-self.o			\
-		o/$(MODE)/ape/ape-no-modify-self.o		\
-		o/$(MODE)/cosmopolitan.a
+toolchain: $(TOOLCHAIN_ARTIFACTS)
+
+.PHONY: clean_toolchain
+clean_toolchain:
+	$(RM) $(TOOLCHAIN_ARTIFACTS)
+
+aarch64: private .INTERNET = true
+aarch64: private .UNSANDBOXED = true
+aarch64:
+	$(MAKE) m=aarch64
+
+clean:
+	$(RM) -r o
 
 # UNSPECIFIED PREREQUISITES TUTORIAL
 #

README.md

@@ -19,133 +19,334 @@ libc](https://justine.lol/cosmopolitan/index.html) website. We also have
 
 ## Getting Started
 
-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:
+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.
 
 ```sh
-wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-2.2.zip
-unzip cosmopolitan-amalgamation-2.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 \
-  -include cosmopolitan.h crt.o ape-no-modify-self.o cosmopolitan.a
-objcopy -S -O binary hello.com.dbg hello.com
+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
 ```
 
-You now have a portable program.
+You've now successfully installed your very own cosmos. Now let's build
+an example program:
+
+```c
+// hello.c
+#include <stdio.h>
+
+int main() {
+  printf("hello world\n");
+}
+```
+
+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.
 
 ```sh
+cosmocc -o hello.com hello.c
 ./hello.com
-bash -c './hello.com'  # zsh/fish workaround (we patched them in 2021)
+./hello.com.dbg
 ```
 
-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):
+You can use the `cosmocc` toolchain to build conventional open source
+projects which use autotools. This strategy normally works:
 
 ```sh
-sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
+export CC=cosmocc
+export CXX=cosmoc++
+./configure --prefix=/opt/cosmos
+make -j
+make install
 ```
 
-If the same command produces puzzling errors on WSL or WINE when using
-Redbean 2.x, they may be fixed by disabling binfmt_misc:
+The Cosmopolitan Libc runtime links some heavyweight troubleshooting
+features by default, which are very useful for developers and admins.
+Here's how you can log system calls:
 
 ```sh
-sudo sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/status'
+./hello.com --strace
 ```
 
-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.
+Here's how you can get a much more verbose log of function calls:
 
 ```sh
-# System-Wide APE Install
-# for Linux, Darwin, and BSDs
-# 1. Copies APE Loader to /usr/bin/ape
-# 2. Registers w/ binfmt_misc too if Linux
-ape/apeinstall.sh
-
-# System-Wide APE Uninstall
-# for Linux, Darwin, and BSDs
-ape/apeuninstall.sh
+./hello.com --ftrace
 ```
 
-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.
+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:
 
 ```sh
-$ file hello.com
-hello.com: DOS/MBR boot sector
-./hello.com --assimilate
-$ file hello.com
-hello.com: ELF 64-bit LSB executable
+export MODE=tiny
+cosmocc --update
 ```
 
-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:
+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
-./hello.com --strace   # log system calls to stderr
-./hello.com --ftrace   # log function calls to stderr
+export MODE=tiny
+cosmocc -Os -o hello2.com hello2.c
+./hello2.com
 ```
 
-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:
+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
-make m=tiny
+export MODE=tinylinux
+cosmocc --update
+cosmocc -Os -o hello2.com hello2.c
+./hello2.com  # <-- actually an ELF executable
 ```
 
-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>.
+## ARM
 
-### MacOS
-
-If you're developing on MacOS you can install the GNU compiler
-collection for x86_64-elf via homebrew:
+Cosmo supports cross-compiling binaries for machines with ARM
+microprocessors. For example:
 
 ```sh
-brew install x86_64-elf-gcc
+make -j8 m=aarch64 o/aarch64/third_party/ggml/llama.com
+make -j8 m=aarch64-tiny o/aarch64-tiny/third_party/ggml/llama.com
 ```
 
-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.
+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.
 
-### 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.
-
-```
-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
+```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
 ```
 
-## Source Builds
+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
+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.
+
+```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)
+```
+
+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.
@@ -169,7 +370,7 @@ 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
-ape/apeinstall.sh
+bin/ape-install
 ```
 
 Since the Cosmopolitan repository is very large, you might only want to
@@ -212,6 +413,104 @@ build/bootstrap/make.com m=tinylinux # tiniest linux-only 4kb binaries
 
 For further details, see [//build/config.mk](build/config.mk).
 
+## Cosmopolitan Amalgamation
+
+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:
+
+```sh
+wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-3.0.zip
+unzip cosmopolitan-amalgamation-3.0.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
+```
+
+You now have a portable program.
+
+```sh
+./hello.com
+bash -c './hello.com'  # older zsh/fish workaround (patched in zsh 5.9 and fish 3.3.0)
+```
+
+If `./hello.com` executed on Linux throws an error about not finding an
+interpreter, it should be fixed by running the following command (although
+note that it may not survive a system restart):
+
+```sh
+sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
+```
+
+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:
@@ -239,10 +538,50 @@ src
 You normally run the `.com.dbg` file under gdb. If you need to debug the
 `.com` file itself, then you can load the debug symbols independently as
 
-```
+```sh
 gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
 ```
 
+## Alternative Development Environments
+
+### MacOS
+
+If you're developing on MacOS you can install the GNU compiler
+collection for x86_64-elf via homebrew:
+
+```sh
+brew install x86_64-elf-gcc
+```
+
+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.
+
+```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
+```
+
+## Discord Chatroom
+
+The Cosmopolitan development team collaborates on the Redbean Discord
+server. You're welcome to join us! <https://discord.gg/FwAVVu7eJ4>
+
 ## Support Vector
 
 | Platform        | Min Version | Circa |
@@ -252,7 +591,7 @@ gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
 | Linux           | 2.6.18      | 2007  |
 | Windows         | 8 [1]       | 2012  |
 | Mac OS X        | 15.6        | 2018  |
-| OpenBSD         | 6.4         | 2018  |
+| OpenBSD         | 7           | 2021  |
 | FreeBSD         | 13          | 2020  |
 | NetBSD          | 9.2         | 2021  |
 

ape/aarch64.lds

@@ -0,0 +1,294 @@
+/*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
+│vi: set et sts=2 tw=2 fenc=utf-8                                           :vi│
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/tls.h"
+
+ENTRY(_start)
+OUTPUT_ARCH(aarch64)
+OUTPUT_FORMAT("elf64-littleaarch64",
+              "elf64-bigaarch64",
+              "elf64-littleaarch64")
+
+SECTIONS {
+
+  . = SEGMENT_START("text-segment", 0x010000000000);
+  __executable_start = .;
+  . += SIZEOF_HEADERS;
+
+  .interp            : { *(.interp) }
+  .note.gnu.build-id : { *(.note.gnu.build-id) }
+  .hash              : { *(.hash) }
+  .gnu.hash          : { *(.gnu.hash) }
+  .dynsym            : { *(.dynsym) }
+  .dynstr            : { *(.dynstr) }
+  .gnu.version       : { *(.gnu.version) }
+  .gnu.version_d     : { *(.gnu.version_d) }
+  .gnu.version_r     : { *(.gnu.version_r) }
+  .rela.init         : { *(.rela.init) }
+  .rela.text         : { *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) }
+  .rela.fini         : { *(.rela.fini) }
+  .rela.rodata       : { *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) }
+  .rela.data.rel.ro  : { *(.rela.data.rel.ro .rela.data.rel.ro.* .rela.gnu.linkonce.d.rel.ro.*) }
+  .rela.data         : { *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) }
+  .rela.tdata        : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
+  .rela.tbss         : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
+  .rela.ctors        : { *(.rela.ctors) }
+  .rela.dtors        : { *(.rela.dtors) }
+  .rela.got          : { *(.rela.got) }
+  .rela.bss          : { *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) }
+  .rela.ifunc        : { *(.rela.ifunc) }
+
+  .rela.plt : {
+    *(.rela.plt)
+    __rela_iplt_start = .;
+    *(.rela.iplt)
+    __rela_iplt_end = .;
+  }
+
+  .init : {
+    *(.start)
+    KEEP(*(.initprologue))
+    KEEP(*(SORT_NONE(.init)))
+    KEEP(*(.initepilogue))
+  } =0x1f2003d5
+
+  .plt : ALIGN(16) {
+    *(.plt)
+    *(.iplt)
+  }
+
+  .text : {
+    *(.text.unlikely .text.*_unlikely .text.unlikely.*)
+    *(.text.antiquity .text.antiquity.*)
+    *(.text.exit .text.exit.*)
+    *(.text.startup .text.startup.*)
+    *(.text.hot .text.hot.*)
+    *(.text.modernity .text.modernity.*)
+    *(.text .stub .text.* .gnu.linkonce.t.*)
+    *(.gnu.warning)
+  } =0x1f2003d5
+
+  .fini : {
+    KEEP(*(SORT_NONE(.fini)))
+  } =0x1f2003d5
+
+  . += CONSTANT(MAXPAGESIZE);
+
+  .privileged : {
+    __privileged_start = ABSOLUTE(.) & -CONSTANT(MAXPAGESIZE);
+    *(.privileged*)
+  } =0x1f2003d6
+
+  .rodata : {
+    KEEP(*(.rodata.pytab.0));
+    KEEP(*(.rodata.pytab.1));
+    KEEP(*(.rodata.pytab.2));
+    KEEP(*(SORT_BY_NAME(.sort.rodata.*)))
+    *(.rodata .rodata.* .gnu.linkonce.r.*)
+    *(.ubsan.types)
+    *(.ubsan.data)
+  }
+
+  .comment : {
+    __comment_start = .;
+    KEEP(*(.comment))
+    BYTE(0);
+  }
+
+  .eh_frame_hdr : {
+    *(.eh_frame_hdr)
+    *(.eh_frame_entry .eh_frame_entry.*)
+  }
+
+  .eh_frame : ONLY_IF_RO {
+    KEEP(*(.eh_frame))
+    *(.eh_frame.*)
+  }
+
+  .gcc_except_table : ONLY_IF_RO {
+    *(.gcc_except_table .gcc_except_table.*)
+  }
+
+  .gnu_extab : ONLY_IF_RO {
+    *(.gnu_extab*)
+  }
+
+  .exception_ranges : ONLY_IF_RO {
+    *(.exception_ranges*)
+  }
+
+  __etext = .;
+  _etext = .;
+  PROVIDE(etext = .);
+
+  . += CONSTANT(MAXPAGESIZE);
+  . = DATA_SEGMENT_ALIGN(CONSTANT(MAXPAGESIZE), CONSTANT(COMMONPAGESIZE));
+
+  .eh_frame : ONLY_IF_RW {
+    KEEP(*(.eh_frame))
+    *(.eh_frame.*)
+  }
+
+  .gnu_extab : ONLY_IF_RW {
+    *(.gnu_extab)
+  }
+
+  .gcc_except_table : ONLY_IF_RW {
+    *(.gcc_except_table .gcc_except_table.*)
+  }
+
+  .exception_ranges : ONLY_IF_RW {
+    *(.exception_ranges*)
+  }
+
+  .tdata : {
+    _tdata_start = .;
+    __tdata_start = .;
+    *(.tdata .tdata.* .gnu.linkonce.td.*)
+    _tdata_end = .;
+  }
+
+  .tbss : {
+    _tbss_start = .;
+    *(.tbss .tbss.* .gnu.linkonce.tb.*)
+    *(.tcommon)
+    _tbss_end = .;
+  }
+
+  .init_array : {
+    __init_array_start = .;
+    KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
+    KEEP(*(.init_array EXCLUDE_FILE(*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
+    __init_array_end = .;
+  }
+
+  .fini_array : {
+    __fini_array_start = .;
+    KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
+    KEEP(*(.fini_array EXCLUDE_FILE(*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
+    __fini_array_end = .;
+  }
+
+  .data.rel.ro : {
+    KEEP(*(SORT_BY_NAME(.piro.relo.sort.*)))
+    *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*)
+    *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*)
+  }
+
+  .dynamic : {
+    *(.dynamic)
+  }
+
+  .got : {
+    *(.got)
+    *(.igot)
+  }
+
+  . = DATA_SEGMENT_RELRO_END(24, .);
+
+  .got.plt : {
+    *(.got.plt)
+    *(.igot.plt)
+  }
+
+  .data : {
+    __data_start = .;
+    KEEP(*(SORT_BY_NAME(.piro.data.sort.*)))
+    *(.data .data.* .gnu.linkonce.d.*)
+    KEEP(*(SORT_BY_NAME(.sort.data.*)))
+    SORT(CONSTRUCTORS)
+  }
+
+  _edata = .;
+  PROVIDE(edata = .);
+
+  . = .;
+  __bss_start = .;
+  __bss_start__ = .;
+
+  .bss : {
+    *(.dynbss)
+    *(.bss .bss.* .gnu.linkonce.b.*)
+    KEEP(*(SORT_BY_NAME(.piro.bss.sort.*)))
+    *(COMMON)
+    . = ALIGN(CONSTANT(COMMONPAGESIZE));
+  }
+
+  _bss_end__ = .;
+  __bss_end__ = .;
+  . = ALIGN(64 / 8);
+  . = SEGMENT_START("ldata-segment", .);
+  . = ALIGN(64 / 8);
+  __end__ = .;
+  _end = .;
+  PROVIDE(end = .);
+
+  . = DATA_SEGMENT_END(.);
+
+  .stab               0 : { *(.stab) }
+  .stabstr            0 : { *(.stabstr) }
+  .stab.excl          0 : { *(.stab.excl) }
+  .stab.exclstr       0 : { *(.stab.exclstr) }
+  .stab.index         0 : { *(.stab.index) }
+  .stab.indexstr      0 : { *(.stab.indexstr) }
+  .gnu.build.attributes : { *(.gnu.build.attributes .gnu.build.attributes.*) }
+  .debug              0 : { *(.debug) }
+  .line               0 : { *(.line) }
+  .debug_srcinfo      0 : { *(.debug_srcinfo) }
+  .debug_sfnames      0 : { *(.debug_sfnames) }
+  .debug_aranges      0 : { *(.debug_aranges) }
+  .debug_pubnames     0 : { *(.debug_pubnames) }
+  .debug_info         0 : { *(.debug_info .gnu.linkonce.wi.*) }
+  .debug_abbrev       0 : { *(.debug_abbrev) }
+  .debug_line         0 : { *(.debug_line .debug_line.* .debug_line_end) }
+  .debug_frame        0 : { *(.debug_frame) }
+  .debug_str          0 : { *(.debug_str) }
+  .debug_loc          0 : { *(.debug_loc) }
+  .debug_macinfo      0 : { *(.debug_macinfo) }
+  .debug_weaknames    0 : { *(.debug_weaknames) }
+  .debug_funcnames    0 : { *(.debug_funcnames) }
+  .debug_typenames    0 : { *(.debug_typenames) }
+  .debug_varnames     0 : { *(.debug_varnames) }
+  .debug_pubtypes     0 : { *(.debug_pubtypes) }
+  .debug_ranges       0 : { *(.debug_ranges) }
+  .debug_macro        0 : { *(.debug_macro) }
+  .debug_addr         0 : { *(.debug_addr) }
+  .ARM.attributes     0 : { KEEP(*(.ARM.attributes)) KEEP(*(.gnu.attributes)) }
+  .note.gnu.arm.ident 0 : { KEEP(*(.note.gnu.arm.ident)) }
+
+  .zip 0 : {
+    KEEP(*(.zip.file))
+    __zip_cdir_start = .;
+    KEEP(*(.zip.cdir))
+    __zip_cdir_size = . - __zip_cdir_start;
+    KEEP(*(.zip.eocd))
+  }
+
+  /DISCARD/ : {
+    *(__patchable_function_entries)
+    *(.GCC.command.line)
+    *(.note.GNU-stack)
+    *(.gnu_debuglink)
+    *(.text.windows)
+    *(.gnu.lto_*)
+    *(.eh_frame)
+    *(.idata.*)
+    *(.yoink)
+    *(.head)
+  }
+}
+
+ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000;
+ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : 8 * 1024 * 1024;
+ape_stack_align = DEFINED(ape_stack_align) ? ape_stack_align : 16;
+ape_stack_round = -ape_stack_align;
+
+_tls_size = _tbss_end - _tdata_start;
+_tdata_size = _tdata_end - _tdata_start;
+_tbss_size = _tbss_end - _tbss_start;
+_tbss_offset = _tbss_start - _tdata_start;
+_tls_content = (_tdata_end - _tdata_start) + (_tbss_end - _tbss_start);
+_tls_align = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
+
+ASSERT(ALIGNOF(.tdata) <= TLS_ALIGNMENT && ALIGNOF(.tbss) <= TLS_ALIGNMENT,
+       "_Thread_local _Alignof can't exceed TLS_ALIGNMENT");

ape/ape.h

@@ -0,0 +1,13 @@
+#ifndef COSMOPOLITAN_APE_APE_H_
+#define COSMOPOLITAN_APE_APE_H_
+
+#define APE_VERSION_MAJOR 1
+#define APE_VERSION_MINOR 8
+#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)
+
+#define APE_VERSION_STR__(x, y) #x "." #y
+#define APE_VERSION_STR_(x, y)  APE_VERSION_STR__(x, y)
+#define APE_VERSION_NOTE_(x, y) (100000000 * (x) + 1000000 * (y))
+
+#endif /* COSMOPOLITAN_APE_APE_H_ */

ape/ape.internal.h

@@ -0,0 +1,9 @@
+#ifndef COSMOPOLITAN_APE_APE_INTERNAL_H_
+#define COSMOPOLITAN_APE_APE_INTERNAL_H_
+#include "libc/dce.h"
+
+#if SupportsWindows() || SupportsMetal() || SupportsXnu()
+#define APE_IS_SHELL_SCRIPT
+#endif
+
+#endif /* COSMOPOLITAN_APE_APE_INTERNAL_H_ */

ape/ape.lds

@@ -181,16 +181,39 @@
 #include "libc/elf/pf2prot.internal.h"
 #include "libc/nt/pedef.internal.h"
 #include "libc/thread/tls.h"
-#include "libc/zip.h"
+#include "ape/ape.internal.h"
+
+/* uncomment if .com.dbg won't execute on your kernel (will break .com file) */
+/* #define APE_FIX_COM_DBG */
+
+#ifdef __x86__
+#define CODE_GRANULE 1
+#else
+#define CODE_GRANULE 4
+#endif
+
+#ifdef APE_FIX_COM_DBG
+#define SKEW SIZEOF_HEADERS
+#else
+#define SKEW 0
+#endif
+
+#ifndef IMAGE_BASE_VIRTUAL
+#define IMAGE_BASE_VIRTUAL 0x400000
+#endif
+
+#if IMAGE_BASE_VIRTUAL > 0xffffffff
+#error "please use 32-bit addresses for image data"
+#endif
 
 ENTRY(_start)
 
 PHDRS {
   Head PT_LOAD FLAGS(PF_X|PF_R);
-  Rom PT_LOAD FLAGS(PF_X|PF_R);
-  Ram PT_LOAD FLAGS(PF_W|PF_R);
+  Cod PT_LOAD FLAGS(PF_X|PF_R);
+  Rom PT_LOAD FLAGS(PF_R);
   Tls PT_TLS FLAGS(PF_W|PF_R);
-  Bss PT_LOAD FLAGS(PF_W|PF_R);
+  Ram PT_LOAD FLAGS(PF_W|PF_R);
   stack PT_GNU_STACK FLAGS(PF_W|PF_R);
 }
 
@@ -201,44 +224,49 @@ SECTIONS {
 /*BEGIN: linux addressability guarantee */
 /*BEGIN: bsd addressability guarantee */
 
-  .head SEGMENT_START("text-segment", IMAGE_BASE_VIRTUAL) : AT(IMAGE_BASE_REAL) {
-    HIDDEN(_base = .);
+  .head SEGMENT_START("text-segment", IMAGE_BASE_VIRTUAL) + SKEW : AT(IMAGE_BASE_REAL) {
+    __executable_start = .;
 
     /* Real Mode */
     KEEP(*(.head))
     KEEP(*(.apesh))
-    KEEP(*(.head2))
     KEEP(*(.text.head))
 
     /* Executable & Linkable Format */
-    . = ALIGN(__SIZEOF_POINTER__);
-    HIDDEN(ape_phdrs = .);
+    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
+    ape_phdrs = .;
     KEEP(*(.elf.phdrs))
-    HIDDEN(ape_phdrs_end = .);
+    ape_phdrs_end = .;
 
+    KEEP(*(.emushprologue))
     KEEP(*(.emush))
+    KEEP(*(.emushepilogue))
 
     /* OpenBSD */
-    . = ALIGN(__SIZEOF_POINTER__);
-    HIDDEN(ape_note = .);
+    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
+    ape_note = .;
     KEEP(*(.note.openbsd.ident))
     KEEP(*(.note.netbsd.ident))
-    HIDDEN(ape_note_end = .);
+    ape_note_end = .;
 
     /* Portable Executable */
     KEEP(*(.pe.header))
-    HIDDEN(ape_pe_sections = .);
+    ape_pe_sections = .;
     KEEP(*(.pe.sections))
-    HIDDEN(ape_pe_sections_end = .);
+    ape_pe_sections_end = .;
 
     /* Mach-O */
     KEEP(*(.macho))
-    . = ALIGN(__SIZEOF_POINTER__);
-    HIDDEN(ape_macho_end = .);
+    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
+    ape_macho_end = .;
+
+    /* APE loader */
+    KEEP(*(.ape.loader))
+    . = ALIGN(. != 0 ? CODE_GRANULE : 0);
 
     KEEP(*(.ape.pad.head))
-    . = ALIGN(SupportsWindows() || SupportsMetal() ? PAGESIZE : 16);
-    HIDDEN(_ehead = .);
+    . = ALIGN(. != 0 ? (SupportsWindows() || SupportsMetal() ? CONSTANT(COMMONPAGESIZE) : 16) : 0);
+    _ehead = .;
   } :Head
 
 /*BEGIN: nt addressability guarantee */
@@ -248,12 +276,10 @@ SECTIONS {
     /* Code that needs to be addressable in Real Mode */
     *(.text.real)
     KEEP(*(SORT_BY_NAME(.sort.text.real.*)))
-    /* Code we want earlier in the binary w/o modifications */
-    KEEP(*(.ape.loader))
-    HIDDEN(_ereal = .);
+    _ereal = .;
 /*END: realmode addressability guarantee */
 /*BEGIN: morphable code */
-    . += 1;
+    . += CODE_GRANULE;
 
     /* Normal Code */
     *(.start)
@@ -283,7 +309,6 @@ SECTIONS {
     KEEP(*(.keep.text))
     *(.text .stub .text.*)
     KEEP(*(SORT_BY_NAME(.sort.text.*)))
-    *(.subrs)
 
     KEEP(*(.ape.pad.test));
     *(.test.unlikely)
@@ -291,17 +316,20 @@ SECTIONS {
 
     /* Privileged code invulnerable to magic */
     KEEP(*(.ape.pad.privileged));
-    . += . > 0 ? 1 : 0;
+    . = ALIGN(__privileged_end > __privileged_start ? CONSTANT(COMMONPAGESIZE) : 0);
 /*END: morphable code */
-    HIDDEN(__privileged_start = .);
-    . += . > 0 ? 1 : 0;
+    __privileged_start = .;
     *(.privileged)
-    HIDDEN(__privileged_end = .);
-    . += . > 0 ? 1 : 0;
+    __privileged_end = .;
+
+    KEEP(*(.ape.pad.text))
+    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
+/*END: Read Only Data (only needed for initialization) */
+  } :Cod
 
 /*BEGIN: Read Only Data */
 
-    KEEP(*(.ape.pad.rodata));
+  .rodata . : {
     KEEP(*(.rodata.pytab.0));
     KEEP(*(.rodata.pytab.1));
     KEEP(*(.rodata.pytab.2));
@@ -310,10 +338,6 @@ SECTIONS {
     *(.ubsan.types)
     *(.ubsan.data)
 
-    /* Unit Test & Fixture Registry */
-
-/*BEGIN: Read only data that needn't be mapped after initialization */
-
     /* Legal Notices */
 #if !defined(IM_FEELING_NAUGHTY) || defined(EMBED_NOTICES)
     KEEP(*(.commentprologue))
@@ -321,37 +345,23 @@ SECTIONS {
     KEEP(*(.commentepilogue))
 #endif
 
+/*BEGIN: read-only data that's only needed for initialization */
+
+#if SupportsWindows()
     /* Windows DLL Import Directory */
     KEEP(*(.idata.ro));
     KEEP(*(SORT_BY_NAME(.idata.ro.*)))
-
-    . = ALIGN(__SIZEOF_POINTER__);
-    PROVIDE_HIDDEN(__init_array_start = .);
-    KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*)
-           SORT_BY_INIT_PRIORITY(.ctors.*)))
-    KEEP(*(.ctors))
-    KEEP(*(.init_array))
-    KEEP(*(.preinit_array))
-    PROVIDE_HIDDEN(__init_array_end = .);
-
-    . = ALIGN(__SIZEOF_POINTER__);
-    PROVIDE_HIDDEN(__fini_array_start = .);
-    KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*)
-           SORT_BY_INIT_PRIORITY(.dtors.*)))
-    KEEP(*(.dtors))
-    PROVIDE_HIDDEN(__fini_array_end = .);
+#endif
 
     /* Encoded Data Structures w/ Linear Initialization Order */
     KEEP(*(.initroprologue))
     KEEP(*(SORT_BY_NAME(.initro.*)))
     KEEP(*(.initroepilogue))
     KEEP(*(SORT_BY_NAME(.sort.rodata.*)))
+    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0); /* don't delete this line :o */
+
+/*END: read-only data that's only needed for initialization */
 
-    KEEP(*(.ape.pad.text))
-    . = ALIGN(PAGESIZE);
-    HIDDEN(_etext = .);
-    PROVIDE_HIDDEN(etext = .);
-/*END: Read Only Data (only needed for initialization) */
   } :Rom
 
 /* initialization image for thread-local storage, this is copied */
@@ -361,29 +371,38 @@ SECTIONS {
     *(SORT_BY_ALIGNMENT(.tdata))
     *(SORT_BY_ALIGNMENT(.tdata.*))
     _tdata_end = .;
-    . = ALIGN(PAGESIZE);
+    KEEP(*(.ape.pad.rodata))
+    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
+    _etext = .;
+    PROVIDE(etext = .);
   } :Tls :Rom
 /*END: Read Only Data */
 
+  . = ALIGN(CONSTANT(COMMONPAGESIZE));
+
 /* this only tells the linker about the layout of uninitialized */
 /* TLS data, and does not advance the linker's location counter */
-  .tbss . : {
+  .tbss : {
     _tbss_start = .;
     *(SORT_BY_ALIGNMENT(.tbss))
     *(SORT_BY_ALIGNMENT(.tbss.*))
-    . = ALIGN(TLS_ALIGNMENT);
+    KEEP(*(.fstls))
     /* the %fs register is based on this location */
     _tbss_end = .;
   } :Tls
 
-  .data ALIGN(PAGESIZE) : {
+  .data . : {
 /*BEGIN: Read/Write Data */
+#if SupportsWindows()
     KEEP(*(SORT_BY_NAME(.piro.data.sort.iat.*)))
+#endif
 /*BEGIN: NT FORK COPYING */
     KEEP(*(.dataprologue))
     *(.data .data.*)
+    *(.PyRuntime) /* for python */
+    *(.subrs) /* for emacs */
     KEEP(*(SORT_BY_NAME(.sort.data.*)))
-    . += . > 0 ? 1 : 0;
+    . += . > 0 ? CODE_GRANULE : 0;
 
     KEEP(*(.gotprologue))
     *(.got)
@@ -393,34 +412,51 @@ SECTIONS {
     *(.got.plt)
     KEEP(*(.gotpltepilogue))
 
+    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
+    __init_array_start = .;
+    KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*)
+           SORT_BY_INIT_PRIORITY(.ctors.*)))
+    KEEP(*(.ctors))
+    KEEP(*(.init_array))
+    KEEP(*(.preinit_array))
+    __init_array_end = .;
+
+    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
+    __fini_array_start = .;
+    KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*)
+           SORT_BY_INIT_PRIORITY(.dtors.*)))
+    KEEP(*(.fini_array))
+    KEEP(*(.dtors))
+    __fini_array_end = .;
+
 /*BEGIN: Post-Initialization Read-Only */
-    . = ALIGN(__SIZEOF_POINTER__);
+    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
     KEEP(*(SORT_BY_NAME(.piro.relo.sort.*)))
-    PROVIDE_HIDDEN(__relo_end = .);
-    . = ALIGN(__SIZEOF_POINTER__);
+    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
     KEEP(*(SORT_BY_NAME(.piro.data.sort.*)))
     KEEP(*(.piro.pad.data))
     KEEP(*(.dataepilogue))
+    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
 /*END: NT FORK COPYING */
-    HIDDEN(_edata = .);
-    PROVIDE_HIDDEN(edata = .);
-    KEEP(*(SORT_BY_NAME(.zip.*)))
-    HIDDEN(_ezip = .);
-    . = ALIGN(PAGESIZE);
+    _edata = .;
+    PROVIDE(edata = .);
+    _ezip = .; /* <-- very deprecated */
   } :Ram
 
+  . = ALIGN(CONSTANT(COMMONPAGESIZE));
+
 /*END:   file content that's loaded by o/s */
 /*END:   file content */
 /*BEGIN: bss memory that's addressable */
 
-  .bss ALIGN(64) : {
+  .bss : {
 /*BEGIN: NT FORK COPYING */
     KEEP(*(.bssprologue))
     KEEP(*(SORT_BY_NAME(.piro.bss.init.*)))
     *(.piro.bss)
     KEEP(*(SORT_BY_NAME(.piro.bss.sort.*)))
-    HIDDEN(__piro_end = .);
-    . += . > 0 ? 1 : 0;
+    __piro_end = .;
+    . += . > 0 ? CODE_GRANULE : 0;
 /*END: Post-Initialization Read-Only */
 
     /* Statically Allocated Empty Space */
@@ -431,11 +467,15 @@ SECTIONS {
     KEEP(*(SORT_BY_NAME(.sort.bss.*)))
 
     KEEP(*(.bssepilogue))
+
+    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
+
 /*END: NT FORK COPYING */
-    . = ALIGN(PAGESIZE);
-    HIDDEN(_end = .);
-    PROVIDE_HIDDEN(end = .);
-  } :Bss
+  } :Ram
+
+  . = ALIGN(CONSTANT(COMMONPAGESIZE));
+  _end = .;
+  PROVIDE(end = .);
 
 /*END: nt addressability guarantee */
 /*END: bsd addressability guarantee */
@@ -478,14 +518,32 @@ SECTIONS {
   .gnu.attributes    0 : { KEEP(*(.gnu.attributes)) }
   .GCC.command.line  0 : { *(.GCC.command.line) }
 
+  .zip 0 : {
+    KEEP(*(.zip.file))
+    __zip_cdir_start = .;
+    KEEP(*(.zip.cdir))
+    __zip_cdir_size = . - __zip_cdir_start;
+    KEEP(*(.zip.eocd))
+  }
+
   /DISCARD/ : {
+#if !SupportsWindows()
+    *(.idata.ro);
+    *(.idata.ro.*)
+    *(.piro.data.sort.iat.*)
+#endif
+    *(__patchable_function_entries)
     *(__mcount_loc)
     *(.discard)
     *(.yoink)
-    *(.*)
   }
 }
 
+ape_pe_filealignment = 512;
+ape_pe_sectionalignment = 4096;
+ape_pe_sizeofheaders = SIZEOF(.head);
+ape_pe_sizeofimage = ROUNDUP(_end - __executable_start, ape_pe_sectionalignment);
+
 PFSTUB8(ape_elf_entry, _start);
 PFSTUB8(ape_elf_phoff, RVA(ape_phdrs));
 PFSTUB8(ape_elf_shoff, 0);
@@ -493,70 +551,58 @@ PFSTUB4(ape_elf_phnum, (ape_phdrs_end - ape_phdrs) / 56);
 PFSTUB4(ape_elf_shnum, 0);
 PFSTUB4(ape_elf_shstrndx, 0);
 
-HIDDEN(_tls_size = _tbss_end - _tdata_start);
-HIDDEN(_tdata_size = _tdata_end - _tdata_start);
-HIDDEN(_tbss_size = _tbss_end - _tbss_start);
-HIDDEN(_tbss_offset = _tbss_start - _tdata_start);
-HIDDEN(_tls_content = (_tdata_end - _tdata_start) + (_tbss_end - _tbss_start));
+_tls_size = _tbss_end - _tdata_start;
+_tdata_size = _tdata_end - _tdata_start;
+_tbss_size = _tbss_end - _tbss_start;
+_tbss_offset = _tbss_start - _tdata_start;
+_tls_content = (_tdata_end - _tdata_start) + (_tbss_end - _tbss_start);
+_tls_align = 1;
 
-HIDDEN(__privileged_addr = ROUNDDOWN(__privileged_start, PAGESIZE));
-HIDDEN(__privileged_size = (ROUNDUP(__privileged_end, PAGESIZE) -
-                            ROUNDDOWN(__privileged_start, PAGESIZE)));
+ape_cod_offset = 0;
+ape_cod_vaddr = ADDR(.head);
+ape_cod_paddr = LOADADDR(.head);
+ape_cod_filesz = ADDR(.rodata) - ADDR(.head);
+ape_cod_memsz = ape_cod_filesz;
+ape_cod_align = CONSTANT(COMMONPAGESIZE);
+ape_cod_rva = RVA(ape_cod_vaddr);
 
-HIDDEN(ape_rom_offset = 0);
-HIDDEN(ape_rom_vaddr = ADDR(.head));
-HIDDEN(ape_rom_paddr = LOADADDR(.head));
-HIDDEN(ape_rom_filesz = LOADADDR(.data) - ape_rom_paddr);
-HIDDEN(ape_rom_memsz = ADDR(.data) - ADDR(.head));
-HIDDEN(ape_rom_align = PAGESIZE);
-HIDDEN(ape_rom_rva = RVA(ape_rom_vaddr));
+ape_rom_vaddr = ADDR(.rodata);
+ape_rom_offset = ape_rom_vaddr - __executable_start;
+ape_rom_paddr = LOADADDR(.rodata);
+ape_rom_filesz = ADDR(.tbss) - ADDR(.rodata);
+ape_rom_memsz = ape_rom_filesz;
+ape_rom_align = CONSTANT(COMMONPAGESIZE);
+ape_rom_rva = RVA(ape_rom_vaddr);
 
-HIDDEN(ape_ram_offset = ape_rom_offset + ape_rom_filesz);
-HIDDEN(ape_ram_vaddr = ADDR(.data));
-HIDDEN(ape_ram_paddr = LOADADDR(.data));
-HIDDEN(ape_ram_filesz = SIZEOF(.data));
-HIDDEN(ape_ram_memsz = ADDR(.bss) + SIZEOF(.bss) - ape_ram_vaddr);
-HIDDEN(ape_ram_align = PAGESIZE);
-HIDDEN(ape_ram_rva = RVA(ape_ram_vaddr));
+ape_ram_vaddr = ADDR(.data);
+ape_ram_offset = ape_ram_vaddr - __executable_start;
+ape_ram_paddr = LOADADDR(.data);
+ape_ram_filesz = ADDR(.bss) - ADDR(.data);
+ape_ram_memsz = _end - ADDR(.data);
+ape_ram_align = CONSTANT(COMMONPAGESIZE);
+ape_ram_rva = RVA(ape_ram_vaddr);
 
-HIDDEN(ape_stack_pf = DEFINED(ape_stack_pf) ? ape_stack_pf : PF_R | PF_W);
-HIDDEN(ape_stack_prot = _PF2PROT(ape_stack_pf));
-HIDDEN(ape_stack_offset = ape_ram_offset + ape_ram_filesz);
-HIDDEN(ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000);
-HIDDEN(ape_stack_paddr = ape_ram_paddr + ape_ram_filesz);
-HIDDEN(ape_stack_filesz = 0);
-HIDDEN(ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : STACKSIZE);
-HIDDEN(ape_stack_align = 16);
+ape_stack_pf = DEFINED(ape_stack_pf) ? ape_stack_pf : PF_R | PF_W;
+ape_stack_prot = _PF2PROT(ape_stack_pf);
+ape_stack_offset = 0;
+ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000;
+ape_stack_paddr = ape_ram_paddr + ape_ram_filesz;
+ape_stack_filesz = 0;
+ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : 8 * 1024 * 1024;
+ape_stack_align = DEFINED(ape_stack_align) ? ape_stack_align : 16;
+ape_stack_round = -ape_stack_align;
 
-HIDDEN(ape_note_offset = ape_rom_offset + (ape_note - ape_rom_vaddr));
-HIDDEN(ape_note_vaddr = ape_note);
-HIDDEN(ape_note_paddr = ape_rom_paddr + ape_note_offset);
-HIDDEN(ape_note_filesz = ape_note_end - ape_note);
-HIDDEN(ape_note_memsz = ape_note_filesz);
-HIDDEN(ape_note_align = __SIZEOF_POINTER__);
+ape_note_offset = ape_cod_offset + (ape_note - ape_cod_vaddr);
+ape_note_filesz = ape_note_end - ape_note;
+ape_note_memsz = ape_note_filesz;
 
-HIDDEN(ape_text_offset = ape_rom_offset + LOADADDR(.text) - ape_rom_paddr);
-HIDDEN(ape_text_paddr = LOADADDR(.text));
-HIDDEN(ape_text_vaddr = ADDR(.text));
-HIDDEN(ape_text_filesz = SIZEOF(.text) + SIZEOF(.tdata));
-HIDDEN(ape_text_memsz = SIZEOF(.text) + SIZEOF(.tdata));
-HIDDEN(ape_text_align = PAGESIZE);
-HIDDEN(ape_text_rva = RVA(ape_text_vaddr));
-
-HIDDEN(ape_data_offset = ape_ram_offset + LOADADDR(.data) - ape_ram_paddr);
-HIDDEN(ape_data_paddr = LOADADDR(.data));
-HIDDEN(ape_data_vaddr = ADDR(.data));
-HIDDEN(ape_data_filesz = SIZEOF(.data));
-HIDDEN(ape_data_memsz = SIZEOF(.data));
-HIDDEN(ape_data_align = PAGESIZE);
-HIDDEN(ape_data_rva = RVA(ape_data_vaddr));
-
-HIDDEN(ape_bss_offset = ape_ram_offset + LOADADDR(.bss) - ape_ram_paddr);
-HIDDEN(ape_bss_paddr = LOADADDR(.bss));
-HIDDEN(ape_bss_vaddr = ADDR(.bss));
-HIDDEN(ape_bss_filesz = 0);
-HIDDEN(ape_bss_memsz = SIZEOF(.bss));
-HIDDEN(ape_bss_align = PAGESIZE);
+ape_text_vaddr = ADDR(.text);
+ape_text_offset = ape_text_vaddr - __executable_start;
+ape_text_paddr = LOADADDR(.text);
+ape_text_filesz = ADDR(.rodata) - ADDR(.text);
+ape_text_memsz = ape_text_filesz;
+ape_text_align = CONSTANT(COMMONPAGESIZE);
+ape_text_rva = RVA(ape_text_vaddr);
 
 /* we roundup here because xnu wants the file load segments page-aligned */
 /* but we don't want to add the nop padding to the ape program, so we'll */
@@ -564,226 +610,42 @@ HIDDEN(ape_bss_align = PAGESIZE);
 SHSTUB2(ape_loader_dd_skip, DEFINED(ape_loader) ? RVA(ape_loader) / 64 : 0);
 SHSTUB2(ape_loader_dd_count,
         DEFINED(ape_loader_end)
-            ? ROUNDUP(ape_loader_end - ape_loader, PAGESIZE) / 64
+            ? ROUNDUP(ape_loader_end - ape_loader, CONSTANT(COMMONPAGESIZE)) / 64
             : 0);
 
-HIDDEN(blink_aarch64_b0 = RVA(blink_aarch64) % 10 + 48);
-HIDDEN(blink_aarch64_b1 = RVA(blink_aarch64) < 10 ? 32 : RVA(blink_aarch64) / 10 % 10 + 48);
-HIDDEN(blink_aarch64_b2 = RVA(blink_aarch64) < 100 ? 32 : RVA(blink_aarch64) / 100 % 10 + 48);
-HIDDEN(blink_aarch64_b3 = RVA(blink_aarch64) < 1000 ? 32 : RVA(blink_aarch64) / 1000 % 10 + 48);
-HIDDEN(blink_aarch64_b4 = RVA(blink_aarch64) < 10000 ? 32 : RVA(blink_aarch64) / 10000 % 10 + 48);
-HIDDEN(blink_aarch64_b5 = RVA(blink_aarch64) < 100000 ? 32 : RVA(blink_aarch64) / 100000 % 10 + 48);
-HIDDEN(blink_aarch64_b6 = RVA(blink_aarch64) < 1000000 ? 32 : RVA(blink_aarch64) / 1000000 % 10 + 48);
-HIDDEN(blink_aarch64_b7 = RVA(blink_aarch64) < 10000000 ? 32 : RVA(blink_aarch64) / 10000000 % 10 + 48);
-HIDDEN(blink_aarch64_b8 = RVA(blink_aarch64) < 100000000 ? 32 : RVA(blink_aarch64) / 100000000 % 10 + 48);
-HIDDEN(blink_aarch64_b9 = RVA(blink_aarch64) < 1000000000 ? 32 : RVA(blink_aarch64) / 1000000000 % 10 + 48);
+#if defined(APE_IS_SHELL_SCRIPT) && !IsTiny()
 
-HIDDEN(blink_aarch64_size_b0 = blink_aarch64_size % 10 + 48);
-HIDDEN(blink_aarch64_size_b1 = blink_aarch64_size < 10 ? 32 : blink_aarch64_size / 10 % 10 + 48);
-HIDDEN(blink_aarch64_size_b2 = blink_aarch64_size < 100 ? 32 : blink_aarch64_size / 100 % 10 + 48);
-HIDDEN(blink_aarch64_size_b3 = blink_aarch64_size < 1000 ? 32 : blink_aarch64_size / 1000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b4 = blink_aarch64_size < 10000 ? 32 : blink_aarch64_size / 10000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b5 = blink_aarch64_size < 100000 ? 32 : blink_aarch64_size / 100000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b6 = blink_aarch64_size < 1000000 ? 32 : blink_aarch64_size / 1000000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b7 = blink_aarch64_size < 10000000 ? 32 : blink_aarch64_size / 10000000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b8 = blink_aarch64_size < 100000000 ? 32 : blink_aarch64_size / 100000000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b9 = blink_aarch64_size < 1000000000 ? 32 : blink_aarch64_size / 1000000000 % 10 + 48);
+#define IDENTITY(X) X
 
-HIDDEN(blink_darwin_arm64_b0 = RVA(blink_darwin_arm64) % 10 + 48);
-HIDDEN(blink_darwin_arm64_b1 = RVA(blink_darwin_arm64) < 10 ? 32 : RVA(blink_darwin_arm64) / 10 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b2 = RVA(blink_darwin_arm64) < 100 ? 32 : RVA(blink_darwin_arm64) / 100 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b3 = RVA(blink_darwin_arm64) < 1000 ? 32 : RVA(blink_darwin_arm64) / 1000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b4 = RVA(blink_darwin_arm64) < 10000 ? 32 : RVA(blink_darwin_arm64) / 10000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b5 = RVA(blink_darwin_arm64) < 100000 ? 32 : RVA(blink_darwin_arm64) / 100000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b6 = RVA(blink_darwin_arm64) < 1000000 ? 32 : RVA(blink_darwin_arm64) / 1000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b7 = RVA(blink_darwin_arm64) < 10000000 ? 32 : RVA(blink_darwin_arm64) / 10000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b8 = RVA(blink_darwin_arm64) < 100000000 ? 32 : RVA(blink_darwin_arm64) / 100000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b9 = RVA(blink_darwin_arm64) < 1000000000 ? 32 : RVA(blink_darwin_arm64) / 1000000000 % 10 + 48);
+#define APE_DECLARE_FIXED_DECIMAL(F, X)                                                      \
+    X##_quad = DEFINED(X) ? ((F(X) < 1000000000 ? 32 : F(X) / 1000000000 % 10 + 48) << 000 | \
+                             (F(X) < 100000000 ? 32 : F(X) / 100000000 % 10 + 48) << 010 |   \
+                             (F(X) < 10000000 ? 32 : F(X) / 10000000 % 10 + 48) << 020 |     \
+                             (F(X) < 1000000 ? 32 : F(X) / 1000000 % 10 + 48) << 030 |       \
+                             (F(X) < 100000 ? 32 : F(X) / 100000 % 10 + 48) << 040 |         \
+                             (F(X) < 10000 ? 32 : F(X) / 10000 % 10 + 48) << 050 |           \
+                             (F(X) < 1000 ? 32 : F(X) / 1000 % 10 + 48) << 060 |             \
+                             (F(X) < 100 ? 32 : F(X) / 100 % 10 + 48) << 070) : 0;           \
+    X##_short = DEFINED(X) ? ((F(X) < 10 ? 32 : F(X) / 10 % 10 + 48) << 000 |                \
+                              (F(X) % 10 + 48) << 010) : 0
 
-HIDDEN(blink_darwin_arm64_size_b0 = blink_darwin_arm64_size % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b1 = blink_darwin_arm64_size < 10 ? 32 : blink_darwin_arm64_size / 10 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b2 = blink_darwin_arm64_size < 100 ? 32 : blink_darwin_arm64_size / 100 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b3 = blink_darwin_arm64_size < 1000 ? 32 : blink_darwin_arm64_size / 1000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b4 = blink_darwin_arm64_size < 10000 ? 32 : blink_darwin_arm64_size / 10000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b5 = blink_darwin_arm64_size < 100000 ? 32 : blink_darwin_arm64_size / 100000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b6 = blink_darwin_arm64_size < 1000000 ? 32 : blink_darwin_arm64_size / 1000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b7 = blink_darwin_arm64_size < 10000000 ? 32 : blink_darwin_arm64_size / 10000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b8 = blink_darwin_arm64_size < 100000000 ? 32 : blink_darwin_arm64_size / 100000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b9 = blink_darwin_arm64_size < 1000000000 ? 32 : blink_darwin_arm64_size / 1000000000 % 10 + 48);
+APE_DECLARE_FIXED_DECIMAL(RVA,      blink_linux_aarch64);
+APE_DECLARE_FIXED_DECIMAL(IDENTITY, blink_linux_aarch64_size);
+APE_DECLARE_FIXED_DECIMAL(RVA,      blink_xnu_aarch64);
+APE_DECLARE_FIXED_DECIMAL(IDENTITY, blink_xnu_aarch64_size);
 
-HIDDEN(blink_arm_b0 = RVA(blink_arm) % 10 + 48);
-HIDDEN(blink_arm_b1 = RVA(blink_arm) < 10 ? 32 : RVA(blink_arm) / 10 % 10 + 48);
-HIDDEN(blink_arm_b2 = RVA(blink_arm) < 100 ? 32 : RVA(blink_arm) / 100 % 10 + 48);
-HIDDEN(blink_arm_b3 = RVA(blink_arm) < 1000 ? 32 : RVA(blink_arm) / 1000 % 10 + 48);
-HIDDEN(blink_arm_b4 = RVA(blink_arm) < 10000 ? 32 : RVA(blink_arm) / 10000 % 10 + 48);
-HIDDEN(blink_arm_b5 = RVA(blink_arm) < 100000 ? 32 : RVA(blink_arm) / 100000 % 10 + 48);
-HIDDEN(blink_arm_b6 = RVA(blink_arm) < 1000000 ? 32 : RVA(blink_arm) / 1000000 % 10 + 48);
-HIDDEN(blink_arm_b7 = RVA(blink_arm) < 10000000 ? 32 : RVA(blink_arm) / 10000000 % 10 + 48);
-HIDDEN(blink_arm_b8 = RVA(blink_arm) < 100000000 ? 32 : RVA(blink_arm) / 100000000 % 10 + 48);
-HIDDEN(blink_arm_b9 = RVA(blink_arm) < 1000000000 ? 32 : RVA(blink_arm) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_arm_size_b0 = blink_arm_size % 10 + 48);
-HIDDEN(blink_arm_size_b1 = blink_arm_size < 10 ? 32 : blink_arm_size / 10 % 10 + 48);
-HIDDEN(blink_arm_size_b2 = blink_arm_size < 100 ? 32 : blink_arm_size / 100 % 10 + 48);
-HIDDEN(blink_arm_size_b3 = blink_arm_size < 1000 ? 32 : blink_arm_size / 1000 % 10 + 48);
-HIDDEN(blink_arm_size_b4 = blink_arm_size < 10000 ? 32 : blink_arm_size / 10000 % 10 + 48);
-HIDDEN(blink_arm_size_b5 = blink_arm_size < 100000 ? 32 : blink_arm_size / 100000 % 10 + 48);
-HIDDEN(blink_arm_size_b6 = blink_arm_size < 1000000 ? 32 : blink_arm_size / 1000000 % 10 + 48);
-HIDDEN(blink_arm_size_b7 = blink_arm_size < 10000000 ? 32 : blink_arm_size / 10000000 % 10 + 48);
-HIDDEN(blink_arm_size_b8 = blink_arm_size < 100000000 ? 32 : blink_arm_size / 100000000 % 10 + 48);
-HIDDEN(blink_arm_size_b9 = blink_arm_size < 1000000000 ? 32 : blink_arm_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_i486_b0 = RVA(blink_i486) % 10 + 48);
-HIDDEN(blink_i486_b1 = RVA(blink_i486) < 10 ? 32 : RVA(blink_i486) / 10 % 10 + 48);
-HIDDEN(blink_i486_b2 = RVA(blink_i486) < 100 ? 32 : RVA(blink_i486) / 100 % 10 + 48);
-HIDDEN(blink_i486_b3 = RVA(blink_i486) < 1000 ? 32 : RVA(blink_i486) / 1000 % 10 + 48);
-HIDDEN(blink_i486_b4 = RVA(blink_i486) < 10000 ? 32 : RVA(blink_i486) / 10000 % 10 + 48);
-HIDDEN(blink_i486_b5 = RVA(blink_i486) < 100000 ? 32 : RVA(blink_i486) / 100000 % 10 + 48);
-HIDDEN(blink_i486_b6 = RVA(blink_i486) < 1000000 ? 32 : RVA(blink_i486) / 1000000 % 10 + 48);
-HIDDEN(blink_i486_b7 = RVA(blink_i486) < 10000000 ? 32 : RVA(blink_i486) / 10000000 % 10 + 48);
-HIDDEN(blink_i486_b8 = RVA(blink_i486) < 100000000 ? 32 : RVA(blink_i486) / 100000000 % 10 + 48);
-HIDDEN(blink_i486_b9 = RVA(blink_i486) < 1000000000 ? 32 : RVA(blink_i486) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_i486_size_b0 = blink_i486_size % 10 + 48);
-HIDDEN(blink_i486_size_b1 = blink_i486_size < 10 ? 32 : blink_i486_size / 10 % 10 + 48);
-HIDDEN(blink_i486_size_b2 = blink_i486_size < 100 ? 32 : blink_i486_size / 100 % 10 + 48);
-HIDDEN(blink_i486_size_b3 = blink_i486_size < 1000 ? 32 : blink_i486_size / 1000 % 10 + 48);
-HIDDEN(blink_i486_size_b4 = blink_i486_size < 10000 ? 32 : blink_i486_size / 10000 % 10 + 48);
-HIDDEN(blink_i486_size_b5 = blink_i486_size < 100000 ? 32 : blink_i486_size / 100000 % 10 + 48);
-HIDDEN(blink_i486_size_b6 = blink_i486_size < 1000000 ? 32 : blink_i486_size / 1000000 % 10 + 48);
-HIDDEN(blink_i486_size_b7 = blink_i486_size < 10000000 ? 32 : blink_i486_size / 10000000 % 10 + 48);
-HIDDEN(blink_i486_size_b8 = blink_i486_size < 100000000 ? 32 : blink_i486_size / 100000000 % 10 + 48);
-HIDDEN(blink_i486_size_b9 = blink_i486_size < 1000000000 ? 32 : blink_i486_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_riscv64_b0 = RVA(blink_riscv64) % 10 + 48);
-HIDDEN(blink_riscv64_b1 = RVA(blink_riscv64) < 10 ? 32 : RVA(blink_riscv64) / 10 % 10 + 48);
-HIDDEN(blink_riscv64_b2 = RVA(blink_riscv64) < 100 ? 32 : RVA(blink_riscv64) / 100 % 10 + 48);
-HIDDEN(blink_riscv64_b3 = RVA(blink_riscv64) < 1000 ? 32 : RVA(blink_riscv64) / 1000 % 10 + 48);
-HIDDEN(blink_riscv64_b4 = RVA(blink_riscv64) < 10000 ? 32 : RVA(blink_riscv64) / 10000 % 10 + 48);
-HIDDEN(blink_riscv64_b5 = RVA(blink_riscv64) < 100000 ? 32 : RVA(blink_riscv64) / 100000 % 10 + 48);
-HIDDEN(blink_riscv64_b6 = RVA(blink_riscv64) < 1000000 ? 32 : RVA(blink_riscv64) / 1000000 % 10 + 48);
-HIDDEN(blink_riscv64_b7 = RVA(blink_riscv64) < 10000000 ? 32 : RVA(blink_riscv64) / 10000000 % 10 + 48);
-HIDDEN(blink_riscv64_b8 = RVA(blink_riscv64) < 100000000 ? 32 : RVA(blink_riscv64) / 100000000 % 10 + 48);
-HIDDEN(blink_riscv64_b9 = RVA(blink_riscv64) < 1000000000 ? 32 : RVA(blink_riscv64) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_riscv64_size_b0 = blink_riscv64_size % 10 + 48);
-HIDDEN(blink_riscv64_size_b1 = blink_riscv64_size < 10 ? 32 : blink_riscv64_size / 10 % 10 + 48);
-HIDDEN(blink_riscv64_size_b2 = blink_riscv64_size < 100 ? 32 : blink_riscv64_size / 100 % 10 + 48);
-HIDDEN(blink_riscv64_size_b3 = blink_riscv64_size < 1000 ? 32 : blink_riscv64_size / 1000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b4 = blink_riscv64_size < 10000 ? 32 : blink_riscv64_size / 10000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b5 = blink_riscv64_size < 100000 ? 32 : blink_riscv64_size / 100000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b6 = blink_riscv64_size < 1000000 ? 32 : blink_riscv64_size / 1000000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b7 = blink_riscv64_size < 10000000 ? 32 : blink_riscv64_size / 10000000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b8 = blink_riscv64_size < 100000000 ? 32 : blink_riscv64_size / 100000000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b9 = blink_riscv64_size < 1000000000 ? 32 : blink_riscv64_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_mipsel_b0 = RVA(blink_mipsel) % 10 + 48);
-HIDDEN(blink_mipsel_b1 = RVA(blink_mipsel) < 10 ? 32 : RVA(blink_mipsel) / 10 % 10 + 48);
-HIDDEN(blink_mipsel_b2 = RVA(blink_mipsel) < 100 ? 32 : RVA(blink_mipsel) / 100 % 10 + 48);
-HIDDEN(blink_mipsel_b3 = RVA(blink_mipsel) < 1000 ? 32 : RVA(blink_mipsel) / 1000 % 10 + 48);
-HIDDEN(blink_mipsel_b4 = RVA(blink_mipsel) < 10000 ? 32 : RVA(blink_mipsel) / 10000 % 10 + 48);
-HIDDEN(blink_mipsel_b5 = RVA(blink_mipsel) < 100000 ? 32 : RVA(blink_mipsel) / 100000 % 10 + 48);
-HIDDEN(blink_mipsel_b6 = RVA(blink_mipsel) < 1000000 ? 32 : RVA(blink_mipsel) / 1000000 % 10 + 48);
-HIDDEN(blink_mipsel_b7 = RVA(blink_mipsel) < 10000000 ? 32 : RVA(blink_mipsel) / 10000000 % 10 + 48);
-HIDDEN(blink_mipsel_b8 = RVA(blink_mipsel) < 100000000 ? 32 : RVA(blink_mipsel) / 100000000 % 10 + 48);
-HIDDEN(blink_mipsel_b9 = RVA(blink_mipsel) < 1000000000 ? 32 : RVA(blink_mipsel) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_mipsel_size_b0 = blink_mipsel_size % 10 + 48);
-HIDDEN(blink_mipsel_size_b1 = blink_mipsel_size < 10 ? 32 : blink_mipsel_size / 10 % 10 + 48);
-HIDDEN(blink_mipsel_size_b2 = blink_mipsel_size < 100 ? 32 : blink_mipsel_size / 100 % 10 + 48);
-HIDDEN(blink_mipsel_size_b3 = blink_mipsel_size < 1000 ? 32 : blink_mipsel_size / 1000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b4 = blink_mipsel_size < 10000 ? 32 : blink_mipsel_size / 10000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b5 = blink_mipsel_size < 100000 ? 32 : blink_mipsel_size / 100000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b6 = blink_mipsel_size < 1000000 ? 32 : blink_mipsel_size / 1000000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b7 = blink_mipsel_size < 10000000 ? 32 : blink_mipsel_size / 10000000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b8 = blink_mipsel_size < 100000000 ? 32 : blink_mipsel_size / 100000000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b9 = blink_mipsel_size < 1000000000 ? 32 : blink_mipsel_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_powerpc64le_b0 = RVA(blink_powerpc64le) % 10 + 48);
-HIDDEN(blink_powerpc64le_b1 = RVA(blink_powerpc64le) < 10 ? 32 : RVA(blink_powerpc64le) / 10 % 10 + 48);
-HIDDEN(blink_powerpc64le_b2 = RVA(blink_powerpc64le) < 100 ? 32 : RVA(blink_powerpc64le) / 100 % 10 + 48);
-HIDDEN(blink_powerpc64le_b3 = RVA(blink_powerpc64le) < 1000 ? 32 : RVA(blink_powerpc64le) / 1000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b4 = RVA(blink_powerpc64le) < 10000 ? 32 : RVA(blink_powerpc64le) / 10000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b5 = RVA(blink_powerpc64le) < 100000 ? 32 : RVA(blink_powerpc64le) / 100000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b6 = RVA(blink_powerpc64le) < 1000000 ? 32 : RVA(blink_powerpc64le) / 1000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b7 = RVA(blink_powerpc64le) < 10000000 ? 32 : RVA(blink_powerpc64le) / 10000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b8 = RVA(blink_powerpc64le) < 100000000 ? 32 : RVA(blink_powerpc64le) / 100000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b9 = RVA(blink_powerpc64le) < 1000000000 ? 32 : RVA(blink_powerpc64le) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_powerpc64le_size_b0 = blink_powerpc64le_size % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b1 = blink_powerpc64le_size < 10 ? 32 : blink_powerpc64le_size / 10 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b2 = blink_powerpc64le_size < 100 ? 32 : blink_powerpc64le_size / 100 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b3 = blink_powerpc64le_size < 1000 ? 32 : blink_powerpc64le_size / 1000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b4 = blink_powerpc64le_size < 10000 ? 32 : blink_powerpc64le_size / 10000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b5 = blink_powerpc64le_size < 100000 ? 32 : blink_powerpc64le_size / 100000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b6 = blink_powerpc64le_size < 1000000 ? 32 : blink_powerpc64le_size / 1000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b7 = blink_powerpc64le_size < 10000000 ? 32 : blink_powerpc64le_size / 10000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b8 = blink_powerpc64le_size < 100000000 ? 32 : blink_powerpc64le_size / 100000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b9 = blink_powerpc64le_size < 1000000000 ? 32 : blink_powerpc64le_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_powerpc_b0 = RVA(blink_powerpc) % 10 + 48);
-HIDDEN(blink_powerpc_b1 = RVA(blink_powerpc) < 10 ? 32 : RVA(blink_powerpc) / 10 % 10 + 48);
-HIDDEN(blink_powerpc_b2 = RVA(blink_powerpc) < 100 ? 32 : RVA(blink_powerpc) / 100 % 10 + 48);
-HIDDEN(blink_powerpc_b3 = RVA(blink_powerpc) < 1000 ? 32 : RVA(blink_powerpc) / 1000 % 10 + 48);
-HIDDEN(blink_powerpc_b4 = RVA(blink_powerpc) < 10000 ? 32 : RVA(blink_powerpc) / 10000 % 10 + 48);
-HIDDEN(blink_powerpc_b5 = RVA(blink_powerpc) < 100000 ? 32 : RVA(blink_powerpc) / 100000 % 10 + 48);
-HIDDEN(blink_powerpc_b6 = RVA(blink_powerpc) < 1000000 ? 32 : RVA(blink_powerpc) / 1000000 % 10 + 48);
-HIDDEN(blink_powerpc_b7 = RVA(blink_powerpc) < 10000000 ? 32 : RVA(blink_powerpc) / 10000000 % 10 + 48);
-HIDDEN(blink_powerpc_b8 = RVA(blink_powerpc) < 100000000 ? 32 : RVA(blink_powerpc) / 100000000 % 10 + 48);
-HIDDEN(blink_powerpc_b9 = RVA(blink_powerpc) < 1000000000 ? 32 : RVA(blink_powerpc) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_powerpc_size_b0 = blink_powerpc_size % 10 + 48);
-HIDDEN(blink_powerpc_size_b1 = blink_powerpc_size < 10 ? 32 : blink_powerpc_size / 10 % 10 + 48);
-HIDDEN(blink_powerpc_size_b2 = blink_powerpc_size < 100 ? 32 : blink_powerpc_size / 100 % 10 + 48);
-HIDDEN(blink_powerpc_size_b3 = blink_powerpc_size < 1000 ? 32 : blink_powerpc_size / 1000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b4 = blink_powerpc_size < 10000 ? 32 : blink_powerpc_size / 10000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b5 = blink_powerpc_size < 100000 ? 32 : blink_powerpc_size / 100000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b6 = blink_powerpc_size < 1000000 ? 32 : blink_powerpc_size / 1000000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b7 = blink_powerpc_size < 10000000 ? 32 : blink_powerpc_size / 10000000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b8 = blink_powerpc_size < 100000000 ? 32 : blink_powerpc_size / 100000000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b9 = blink_powerpc_size < 1000000000 ? 32 : blink_powerpc_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_s390x_b0 = RVA(blink_s390x) % 10 + 48);
-HIDDEN(blink_s390x_b1 = RVA(blink_s390x) < 10 ? 32 : RVA(blink_s390x) / 10 % 10 + 48);
-HIDDEN(blink_s390x_b2 = RVA(blink_s390x) < 100 ? 32 : RVA(blink_s390x) / 100 % 10 + 48);
-HIDDEN(blink_s390x_b3 = RVA(blink_s390x) < 1000 ? 32 : RVA(blink_s390x) / 1000 % 10 + 48);
-HIDDEN(blink_s390x_b4 = RVA(blink_s390x) < 10000 ? 32 : RVA(blink_s390x) / 10000 % 10 + 48);
-HIDDEN(blink_s390x_b5 = RVA(blink_s390x) < 100000 ? 32 : RVA(blink_s390x) / 100000 % 10 + 48);
-HIDDEN(blink_s390x_b6 = RVA(blink_s390x) < 1000000 ? 32 : RVA(blink_s390x) / 1000000 % 10 + 48);
-HIDDEN(blink_s390x_b7 = RVA(blink_s390x) < 10000000 ? 32 : RVA(blink_s390x) / 10000000 % 10 + 48);
-HIDDEN(blink_s390x_b8 = RVA(blink_s390x) < 100000000 ? 32 : RVA(blink_s390x) / 100000000 % 10 + 48);
-HIDDEN(blink_s390x_b9 = RVA(blink_s390x) < 1000000000 ? 32 : RVA(blink_s390x) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_s390x_size_b0 = blink_s390x_size % 10 + 48);
-HIDDEN(blink_s390x_size_b1 = blink_s390x_size < 10 ? 32 : blink_s390x_size / 10 % 10 + 48);
-HIDDEN(blink_s390x_size_b2 = blink_s390x_size < 100 ? 32 : blink_s390x_size / 100 % 10 + 48);
-HIDDEN(blink_s390x_size_b3 = blink_s390x_size < 1000 ? 32 : blink_s390x_size / 1000 % 10 + 48);
-HIDDEN(blink_s390x_size_b4 = blink_s390x_size < 10000 ? 32 : blink_s390x_size / 10000 % 10 + 48);
-HIDDEN(blink_s390x_size_b5 = blink_s390x_size < 100000 ? 32 : blink_s390x_size / 100000 % 10 + 48);
-HIDDEN(blink_s390x_size_b6 = blink_s390x_size < 1000000 ? 32 : blink_s390x_size / 1000000 % 10 + 48);
-HIDDEN(blink_s390x_size_b7 = blink_s390x_size < 10000000 ? 32 : blink_s390x_size / 10000000 % 10 + 48);
-HIDDEN(blink_s390x_size_b8 = blink_s390x_size < 100000000 ? 32 : blink_s390x_size / 100000000 % 10 + 48);
-HIDDEN(blink_s390x_size_b9 = blink_s390x_size < 1000000000 ? 32 : blink_s390x_size / 1000000000 % 10 + 48);
+#endif /* APE_IS_SHELL_SCRIPT */
 
 #if SupportsMetal()
-HIDDEN(v_ape_realsectors =
-           MIN(0x70000 - IMAGE_BASE_REAL, ROUNDUP(RVA(_ezip), 512)) / 512);
-HIDDEN(v_ape_realbytes = v_ape_realsectors * 512);
-HIDDEN(v_ape_realdwords = v_ape_realsectors * (512 / 4));
-HIDDEN(v_ape_allsectors = ROUNDUP(RVA(_ezip), 512) / 512);
-HIDDEN(v_ape_allbytes = v_ape_allsectors * 512);
-HIDDEN(v_ape_highsectors = v_ape_allsectors - v_ape_realsectors);
+v_ape_realsectors = MIN(0x70000 - IMAGE_BASE_REAL, ROUNDUP(RVA(_ezip), 512)) / 512;
+v_ape_realbytes = v_ape_realsectors * 512;
+v_ape_realdwords = v_ape_realsectors * (512 / 4);
+v_ape_allsectors = ROUNDUP(RVA(_ezip), 512) / 512;
+v_ape_allbytes = v_ape_allsectors * 512;
+v_ape_highsectors = MIN(0xffff, v_ape_allsectors - v_ape_realsectors);
 TSSDESCSTUB2(_tss, _tss, _tss_end ? _tss_end - _tss - 1 : 0);
 #endif
 
-/* ZIP End of Central Directory header */
-#define ZIPCONST(NAME, VAL) HIDDEN(NAME = DEFINED(__zip_start) ? VAL : 0);
-ZIPCONST(v_zip_cdoffset, __zip_start - IMAGE_BASE_VIRTUAL);
-ZIPCONST(v_zip_cdirsize, __zip_end - __zip_start);
-ASSERT(v_zip_cdirsize % kZipCdirHdrLinkableSize == 0, "bad zip cdir");
-ZIPCONST(v_zip_records, v_zip_cdirsize / kZipCdirHdrLinkableSize);
-ZIPCONST(v_zip_commentsize, _ezip - __zip_end - kZipCdirHdrMinSize);
-
 #if SupportsXnu()
 /* Generates deterministic ID. */
 #define PHI 0x9e3779b9925d4c17
@@ -802,19 +664,8 @@ ZIPCONST(v_zip_commentsize, _ezip - __zip_end - kZipCdirHdrMinSize);
   KMH(ape_uuid1, X);      \
   XORSHIFT(ape_uuid2, X); \
   KMH(ape_uuid2, X)
-HIDDEN(ape_uuid1 = 88172645463325252);
-HIDDEN(ape_uuid2 = 88172645463325252);
-CHURN(ape_bss_align);
-CHURN(ape_bss_filesz);
-CHURN(ape_bss_memsz);
-CHURN(ape_bss_offset);
-CHURN(ape_bss_paddr);
-CHURN(ape_data_filesz);
-CHURN(ape_data_memsz);
-CHURN(ape_data_offset);
-CHURN(ape_data_paddr);
-CHURN(ape_data_rva);
-CHURN(ape_data_vaddr);
+ape_uuid1 = 88172645463325252;
+ape_uuid2 = 88172645463325252;
 CHURN(ape_elf_entry);
 CHURN(ape_elf_phnum);
 CHURN(ape_elf_phoff);
@@ -823,13 +674,10 @@ CHURN(ape_elf_shoff);
 CHURN(ape_elf_shstrndx);
 CHURN(ape_macho_end);
 CHURN(ape_note);
-CHURN(ape_note_align);
 CHURN(ape_note_end);
 CHURN(ape_note_filesz);
 CHURN(ape_note_memsz);
 CHURN(ape_note_offset);
-CHURN(ape_note_paddr);
-CHURN(ape_note_vaddr);
 CHURN(ape_ram_align);
 CHURN(ape_ram_filesz);
 CHURN(ape_ram_memsz);
@@ -843,7 +691,14 @@ CHURN(ape_rom_memsz);
 CHURN(ape_rom_offset);
 CHURN(ape_rom_paddr);
 CHURN(ape_rom_rva);
-CHURN(ape_rom_vaddr);
+CHURN(ape_cod_vaddr);
+CHURN(ape_cod_align);
+CHURN(ape_cod_filesz);
+CHURN(ape_cod_memsz);
+CHURN(ape_cod_offset);
+CHURN(ape_cod_paddr);
+CHURN(ape_cod_rva);
+CHURN(ape_cod_vaddr);
 CHURN(ape_text_align);
 CHURN(ape_text_filesz);
 CHURN(ape_text_memsz);
@@ -876,22 +731,23 @@ CHURN(WinMain);
 #if SupportsWindows() || SupportsMetal()
 #define LINK_WINDOWS (SupportsWindows() && !DEFINED(EfiMain))
 PFSTUB4(ape_pe_offset, ape_pe - ape_mz);
-HIDDEN(ape_pe_optsz = ape_pe_sections - (ape_pe + 24));
-HIDDEN(ape_pe_shnum = (ape_pe_sections_end - ape_pe_sections) / 40);
-HIDDEN(ape_pe_base = IMAGE_BASE_VIRTUAL);
-HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_iat) : 0);
-HIDDEN(ape_idata_iatsize = LINK_WINDOWS ? ape_idata_iatend - ape_idata_iat : 0);
-HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_idt) : 0);
-HIDDEN(ape_idata_idtsize = LINK_WINDOWS ? ape_idata_idtend - ape_idata_idt : 0);
-HIDDEN(v_ntversion = LINK_WINDOWS ? 6 : 1);
-HIDDEN(v_ntdllchar = LINK_WINDOWS ? 288 : 0);
-HIDDEN(v_ntsubversion = LINK_WINDOWS ? 6 : 5);
-HIDDEN(v_ntsubsystem = (LINK_WINDOWS
-                        ? (DEFINED(GetMessage)
-                           ? kNtImageSubsystemWindowsGui
-                           : kNtImageSubsystemWindowsCui)
-                        : kNtImageSubsystemEfiApplication));
-HIDDEN(ape_pe_entry = LINK_WINDOWS ? WinMain : EfiMain);
+ape_pe_optsz = ape_pe_sections - (ape_pe + 24);
+ASSERT(ape_pe_optsz % 8 == 0, "SizeOfOptionalHeader must be multiple of 8");
+ape_pe_shnum = (ape_pe_sections_end - ape_pe_sections) / 40;
+ape_pe_base = IMAGE_BASE_VIRTUAL;
+ape_idataz = LINK_WINDOWS ? RVA(ape_idata_iat) : 0;
+ape_idata_iatsize = LINK_WINDOWS ? ape_idata_iatend - ape_idata_iat : 0;
+ape_idata = LINK_WINDOWS ? RVA(ape_idata_idt) : 0;
+ape_idata_idtsize = LINK_WINDOWS ? ape_idata_idtend - ape_idata_idt : 0;
+v_ntversion = LINK_WINDOWS ? 6 : 1;
+v_ntdllchar = LINK_WINDOWS ? 288 : 0;
+v_ntsubversion = LINK_WINDOWS ? 6 : 5;
+v_ntsubsystem = (LINK_WINDOWS
+                 ? (DEFINED(GetMessage)
+                    ? kNtImageSubsystemWindowsGui
+                    : kNtImageSubsystemWindowsCui)
+                 : kNtImageSubsystemEfiApplication);
+ape_pe_entry = LINK_WINDOWS ? WinMain : EfiMain;
 #endif
 
 #if SupportsXnu()
@@ -909,12 +765,6 @@ ASSERT(((DEFINED(__init_rodata_end) ? __init_rodata_end : 0) %
 ASSERT((!DEFINED(ape_grub) ? 1 : RVA(ape_grub) < 8192),
        "grub stub needs to be in first 8kb of image");
 
-ASSERT(DEFINED(_start) || DEFINED(_start16),
-       "please link a _start() or _start16() entrypoint");
-
-ASSERT(!DEFINED(_start16) || REAL(_end) < 65536,
-       "ape won't support non-tiny real mode programs");
-
 ASSERT(IS2POW(ape_stack_memsz),
        "ape_stack_memsz must be a two power");
 
@@ -924,6 +774,8 @@ ASSERT(ape_stack_vaddr % ape_stack_memsz == 0,
 ASSERT(ALIGNOF(.tdata) <= TLS_ALIGNMENT && ALIGNOF(.tbss) <= TLS_ALIGNMENT,
        "_Thread_local _Alignof can't exceed TLS_ALIGNMENT");
 
+ASSERT(DEFINED(main), "main() function not defined");
+
 /* Let's not be like Knight Capital. */
 /* NOCROSSREFS_TO(.test .text) */
 

ape/ape.mk

@@ -15,23 +15,51 @@
 
 PKGS += APE
 
-APE =	o/$(MODE)/ape/ape.o			\
-	o/$(MODE)/ape/ape.lds
+APE_FILES := $(wildcard ape/*.*)
+APE_HDRS = $(filter %.h,$(APE_FILES))
+APE_INCS = $(filter %.inc,$(APE_FILES))
 
-APE_NO_MODIFY_SELF =				\
-	o/$(MODE)/ape/ape.lds			\
-	o/$(MODE)/ape/ape-no-modify-self.o
+ifeq ($(ARCH), aarch64)
 
-APE_COPY_SELF =					\
-	o/$(MODE)/ape/ape.lds			\
-	o/$(MODE)/ape/ape-copy-self.o
+APE = o/$(MODE)/ape/aarch64.lds
 
 APELINK =					\
 	$(COMPILE)				\
 	-ALINK.ape				\
 	$(LINK)					\
 	$(LINKARGS)				\
-	$(OUTPUT_OPTION)
+	$(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				\
@@ -42,78 +70,99 @@ APE_LOADER_FLAGS =				\
 	-Os					\
 	-ffreestanding				\
 	-mgeneral-regs-only			\
-	-mno-red-zone				\
+	-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_FILES := $(wildcard ape/*.*)
-APE_HDRS = $(filter %.h,$(APE_FILES))
-APE_INCS = $(filter %.inc,$(APE_FILES))
 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/$(MODE)/ape/ape.lds:				\
-		ape/ape.lds			\
-		ape/macros.internal.h		\
-		ape/relocations.h		\
-		libc/intrin/bits.h		\
-		libc/thread/tls.h		\
-		libc/calls/struct/timespec.h	\
-		libc/thread/thread.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/elf/pf2prot.internal.h	\
-		libc/macros.internal.h		\
-		libc/nt/pedef.internal.h	\
-		libc/str/str.h			\
-		libc/zip.h
-
-o/$(MODE)/ape/public/ape.lds: OVERRIDE_CPPFLAGS += -UCOSMO
-o/$(MODE)/ape/public/ape.lds:			\
-		ape/public/ape.lds		\
-		ape/ape.lds			\
-		ape/macros.internal.h		\
-		ape/relocations.h		\
-		libc/intrin/bits.h		\
-		libc/thread/tls.h		\
-		libc/calls/struct/timespec.h	\
-		libc/thread/thread.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/elf/pf2prot.internal.h	\
-		libc/macros.internal.h		\
-		libc/nt/pedef.internal.h	\
-		libc/str/str.h			\
-		libc/zip.h
-
 o/ape/idata.inc:				\
 		ape/idata.internal.h		\
 		ape/relocations.h
 
-o/$(MODE)/ape/ape.o:				\
-		ape/blink-aarch64.gz		\
-		ape/blink-arm.gz		\
-		ape/blink-darwin-arm64.gz	\
-		ape/blink-i486.gz		\
-		ape/blink-mipsel.gz		\
-		ape/blink-powerpc.gz		\
-		ape/blink-powerpc64le.gz	\
-		ape/blink-riscv64.gz		\
-		ape/blink-s390x.gz
-
 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		\
@@ -124,17 +173,9 @@ o/$(MODE)/ape/ape-no-modify-self.o:		\
 		libc/runtime/e820.internal.h	\
 		libc/runtime/mman.internal.h	\
 		libc/runtime/pc.internal.h	\
-		libc/runtime/symbolic.h		\
 		libc/sysv/consts/prot.h		\
-		ape/blink-aarch64.gz		\
-		ape/blink-arm.gz		\
-		ape/blink-darwin-arm64.gz	\
-		ape/blink-i486.gz		\
-		ape/blink-mipsel.gz		\
-		ape/blink-powerpc.gz		\
-		ape/blink-powerpc64le.gz	\
-		ape/blink-riscv64.gz		\
-		ape/blink-s390x.gz		\
+		ape/blink-linux-aarch64.gz	\
+		ape/blink-xnu-aarch64.gz	\
 		o/$(MODE)/ape/ape.elf
 	@$(COMPILE)				\
 		-AOBJECTIFY.S			\
@@ -145,11 +186,14 @@ o/$(MODE)/ape/ape-no-modify-self.o:		\
 
 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		\
@@ -160,58 +204,84 @@ o/$(MODE)/ape/ape-copy-self.o:			\
 		libc/runtime/e820.internal.h	\
 		libc/runtime/mman.internal.h	\
 		libc/runtime/pc.internal.h	\
-		libc/runtime/symbolic.h		\
 		libc/sysv/consts/prot.h		\
-		ape/blink-aarch64.gz		\
-		ape/blink-arm.gz		\
-		ape/blink-darwin-arm64.gz	\
-		ape/blink-i486.gz		\
-		ape/blink-mipsel.gz		\
-		ape/blink-powerpc.gz		\
-		ape/blink-powerpc64le.gz	\
-		ape/blink-riscv64.gz		\
-		ape/blink-s390x.gz
+		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 ape/loader.h
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b01111001 -g $(APE_LOADER_FLAGS)
+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=0b01111001 -S -g0 $(APE_LOADER_FLAGS)
+	@$(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=0b01111001 -S -g0 $(APE_LOADER_FLAGS)
+	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=121 -S -g0 $(APE_LOADER_FLAGS)
 
-o/$(MODE)/ape/loader-xnu.o: ape/loader.c ape/loader.h
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b00001000 -g $(APE_LOADER_FLAGS)
+o/$(MODE)/ape/loader-xnu.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=0b00001000 -S -g0 $(APE_LOADER_FLAGS)
+	@$(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=0b00001000 -S -g0 $(APE_LOADER_FLAGS)
+	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
 
 o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
-o/$(MODE)/ape/ape.macho: o/$(MODE)/ape/ape.macho.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.o		\
-		o/$(MODE)/ape/loader-elf.o	\
-		ape/loader.lds
-	@$(ELFLINK) -z max-page-size=0x10
-
-o/$(MODE)/ape/ape.macho.dbg:			\
-		o/$(MODE)/ape/loader-xnu.o	\
 		o/$(MODE)/ape/loader-macho.o	\
-		ape/loader-macho.lds
-	@$(ELFLINK) -z max-page-size=0x10
+		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/public/ape.lds	\
 		o/$(MODE)/ape/ape.elf		\
 		o/$(MODE)/ape/ape.macho		\
 		o/$(MODE)/ape/ape-copy-self.o	\
 		o/$(MODE)/ape/ape-no-modify-self.o
+
+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,128 +0,0 @@
-#!/bin/sh
-
-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
-
-################################################################################
-# INSTALL APE LOADER SYSTEMWIDE
-
-if [ -f o/depend ]; then
-  # mkdeps.com build was successfully run so assume we can build
-  echo >&2
-  echo "recompiling ape loader" >&2
-  echo "running: make -j8 o//ape" >&2
-  make -j8 o//ape || exit
-  echo "done" >&2
-elif [ -d build/bootstrap ]; then
-  # if make isn't being used then it's unlikely the user changed the sources
-  # in that case the prebuilt binaries should be completely up-to-date
-  echo "using prebuilt ape loader from cosmo repo" >&2
-  mkdir -p o//ape || exit
-  cp -af build/bootstrap/ape.elf o//ape/ape.elf || 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.elf to /usr/bin/ape" >&2
-    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
-    $SUDO cp -f o//ape/ape.macho /usr/bin/ape || exit
-    echo "done" >&2
-  fi
-else
-  if ! [ /usr/bin/ape -nt o//ape/ape.elf ]; then
-    echo >&2
-    echo "installing o//ape/ape.elf to /usr/bin/ape" >&2
-    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
-    $SUDO cp -f o//ape/ape.elf /usr/bin/ape || exit
-    echo "done" >&2
-  fi
-fi
-
-################################################################################
-# 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

ape/apeinstall.sh

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

ape/apeuninstall.sh

@@ -1,26 +0,0 @@
-#!/bin/sh
-
-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 o/tmp/.ape /tmp/.ape"
-  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
-$SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape o/tmp/ape /tmp/.ape /tmp/ape || exit

ape/apeuninstall.sh

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

ape/config.h

@@ -1,10 +0,0 @@
-#ifndef COSMOPOLITAN_APE_CONFIG_H_
-#define COSMOPOLITAN_APE_CONFIG_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-
-#define STATIC_SYMBOL(NAME, VALUE)   \
-  asm(".equ\t" NAME "," VALUE "\n\t" \
-      ".globl\t" NAME)
-
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_APE_CONFIG_H_ */

ape/idata.internal.h

@@ -31,7 +31,8 @@
 //	@see	libc/nt/master.sh
 //	@see	ape/ape.lds
 //	@see	winimp
-.macro	.imp	dll:req fn:req actual:req hint
+.macro	.imp	dll:req fn:req actual:req
+#ifdef __x86_64__
 	.dll	"\dll"
 	.section ".piro.data.sort.iat.2.\dll\().2.\actual","aw",@progbits
 	.type	\fn,@object
@@ -42,25 +43,28 @@
 	.hidden	\fn
 	.previous
 	.section ".idata.ro.ilt.\dll\().2.\actual","a",@progbits
-".Lidata.ilt.\dll\().\actual":
+"idata.ilt.\dll\().\actual":
 	.quad	RVA("\dll\().\actual")
-	.type	".Lidata.ilt.\dll\().\actual",@object
-	.size	".Lidata.ilt.\dll\().\actual",.-".Lidata.ilt.\dll\().\actual"
+	.type	"idata.ilt.\dll\().\actual",@object
+	.size	"idata.ilt.\dll\().\actual",.-"idata.ilt.\dll\().\actual"
 	.previous
 	.section ".idata.ro.hnt.\dll\().2.\actual","a",@progbits
 "\dll\().\actual":
-	.ifnb	\hint			# hint i.e. guess function ordinal
-	.short	\hint
-	.else
-	.short	0
-	.endif
+	.short	0			// hint
 	.asciz	"\actual"
-	.align	2			# documented requirement
+	.align	2			// documented requirement
 	.globl	"\dll\().\actual"
 	.hidden	"\dll\().\actual"
 	.type	"\dll\().\actual",@object
 	.size	"\dll\().\actual",.-"\dll\().\actual"
 	.previous
+#else
+	.section ".data.nt.\actual","aw",@progbits
+	.globl	"\fn"
+	.balign	8
+	.weak	"\actual"
+"\fn":	.quad	"\actual"
+#endif
 .endm
 
 //	Defines DLL import.
@@ -68,16 +72,16 @@
 .macro	.dll	name:req
   .section ".idata.ro.idt.2.\name","aG",@progbits,"\name",comdat
 	.equ	".Lidata.idt.\name",.
-	.long	RVA("idata.ilt.\name")		# ImportLookupTable
-	.long	0				# TimeDateStamp
-	.long	0				# ForwarderChain
-	.long	RVA(".Lidata.str.\name")	# DllNameRva
-	.long	RVA("idata.iat.\name")		# ImportAddressTable
+	.long	RVA("idata.ilt.\name")		// ImportLookupTable
+	.long	0				// TimeDateStamp
+	.long	0				// ForwarderChain
+	.long	RVA(".Lidata.str.\name")	// DllNameRva
+	.long	RVA("idata.iat.\name")		// ImportAddressTable
 	.type	".Lidata.idt.\name",@object
 	.size	".Lidata.idt.\name",.-".Lidata.idt.\name"
   .previous
   .section ".idata.ro.ilt.\name\().1","aG",@progbits,"\name",comdat
-	.align	__SIZEOF_POINTER__
+	.balign	__SIZEOF_POINTER__
 	.type	"idata.ilt.\name",@object
 "idata.ilt.\name":
 	.previous/*
@@ -88,12 +92,12 @@
 	.quad	0
   .previous
   .section ".idata.ro.hnt.\name\().1","aG",@progbits,"\name",comdat
-	.align	__SIZEOF_POINTER__
+	.balign	__SIZEOF_POINTER__
 	.type	"idata.hnt.\name",@object
 	.equ	"idata.hnt.\name",.
   .previous
   .section ".piro.data.sort.iat.2.\name\().1","awG",@progbits,"\name",comdat
-	.align	__SIZEOF_POINTER__
+	.balign	__SIZEOF_POINTER__
 	.type	"idata.iat.\name",@object
 "idata.iat.\name":
 	.previous/*

ape/launch.S

@@ -0,0 +1,92 @@
+/*-*- 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│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/macros.internal.h"
+
+//	Calls _start() function of loaded program.
+//
+//	When the program entrypoint is called, all registers shall be
+//	cleared, with the exception of (1) %rdi will be equal to %rsp
+//	on FreeBSD and (2) %cl will contain the detected host OS code
+//
+//	We clear all the general registers we can to have some wiggle
+//	room, to extend the behavior of this loader in the future. We
+//	don't need to clear the XMM registers because your APE loader
+//	should be compiled using gcc/clang's -mgeneral-regs-only flag
+//
+//	@param	rdi is passed through as-is
+//	@param	rsi is address of entrypoint (becomes zero)
+//	@param	rdx is stack pointer (becomes zero)
+//	@param	rcx is passed through as-is
+//	@noreturn
+Launch:
+#ifdef __aarch64__
+
+	mov	x16,x1
+	mov	sp,x2
+	mov	x1,0
+	mov	x2,0
+	mov	x3,0
+	mov	x4,0
+	mov	x5,0
+	mov	x6,0
+	mov	x7,0
+	mov	x8,0
+	mov	x9,0
+	mov	x10,0
+	mov	x11,0
+	mov	x12,0
+	mov	x13,0
+	mov	x14,0
+	mov	x15,0
+	mov	x17,0
+	mov	x19,0
+	mov	x20,0
+	mov	x21,0
+	mov	x22,0
+	mov	x23,0
+	mov	x24,0
+	mov	x25,0
+	mov	x26,0
+	mov	x27,0
+	mov	x28,0
+	mov	x29,0
+	mov	x30,0
+	br	x16
+
+#else
+
+	xor	%r8d,%r8d
+	xor	%r9d,%r9d
+	xor	%r10d,%r10d
+	xor	%r11d,%r11d
+	xor	%r12d,%r12d
+	xor	%r13d,%r13d
+	xor	%r14d,%r14d
+	xor	%r15d,%r15d
+	mov	%rdx,%rsp
+	xor	%edx,%edx
+	push	%rsi
+	xor	%esi,%esi
+	xor	%ebp,%ebp
+	xor	%ebx,%ebx
+	xor	%eax,%eax
+	ret
+
+#endif
+	.endfn	Launch,globl

ape/loader-elf.S

@@ -1,249 +0,0 @@
-/*-*- 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│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/elf/def.h"
-#include "libc/sysv/consts/prot.h"
-#include "libc/macho.internal.h"
-#include "libc/dce.h"
-#include "libc/macros.internal.h"
-
-//	APE Loader Executable Structure
-//	Linux, FreeBSD, NetBSD, OpenBSD
-
-	.align	8
-ehdr:	.ascii	"\177ELF"
-	.byte	ELFCLASS64
-	.byte	ELFDATA2LSB
-	.byte	1
-	.byte	ELFOSABI_FREEBSD
-	.quad	0
-	.word	ET_EXEC			# e_type
-	.word	EM_NEXGEN32E		# e_machine
-	.long	1			# e_version
-	.quad	_start			# e_entry
-	.quad	phdrs - ehdr		# e_phoff
-	.quad	0			# e_shoff
-	.long	0			# e_flags
-	.word	64			# e_ehsize
-	.word	56			# e_phentsize
-	.word	4			# e_phnum
-	.word	0			# e_shentsize
-	.word	0			# e_shnum
-	.word	0			# e_shstrndx
-	.endobj	ehdr,globl
-
-	.align	8
-phdrs:	.long	PT_LOAD			# p_type
-	.long	PF_R|PF_X		# p_flags
-	.quad	0			# p_offset
-	.quad	ehdr			# p_vaddr
-	.quad	ehdr			# p_paddr
-	.quad	filesz			# p_filesz
-	.quad	filesz			# p_memsz
-	.quad	PAGESIZE		# p_align
-
-	.long	PT_LOAD			# p_type
-	.long	PF_R|PF_W		# p_flags
-	.quad	0			# p_offset
-	.quad	bss			# p_vaddr
-	.quad	bss			# p_paddr
-	.quad	0			# p_filesz
-	.quad	bsssize			# p_memsz
-	.quad	PAGESIZE		# p_align
-
-	.long	PT_GNU_STACK		# p_type
-	.long	PF_R|PF_W		# p_flags
-	.quad	0			# p_offset
-	.quad	0			# p_vaddr
-	.quad	0			# p_paddr
-	.quad	0			# p_filesz
-	.quad	0			# p_memsz
-	.quad	16			# p_align
-
-	.long	PT_NOTE			# p_type
-	.long	PF_R			# p_flags
-	.quad	note - ehdr		# p_offset
-	.quad	note			# p_vaddr
-	.quad	note			# p_paddr
-	.quad	notesize		# p_filesz
-	.quad	notesize		# p_memsz
-	.quad	8			# p_align
-	.endobj	phdrs
-
-note:	.long	2f-1f
-	.long	4f-3f
-	.long	1
-1:	.asciz	"OpenBSD"
-2:	.align	4
-3:	.long	0
-4:	.long	2f-1f
-	.long	4f-3f
-	.long	1
-1:	.asciz	"NetBSD"
-2:	.align	4
-3:	.long	901000000
-4:	.endobj	note
-	notesize = . - note
-
-	.align	64,0				# for ape.S dd
-	.org	0x180				# for ape.S dd
-
-//	APE Loader XNU Header
-//
-//	This header is dd'd backwards by the APE shell script when
-//	running on Mac OS X.
-//
-//	@see	ape/ape.S
-macho:	.long	0xFEEDFACE+1
-	.long	MAC_CPU_NEXGEN32E
-	.long	MAC_CPU_NEXGEN32E_ALL
-	.long	MAC_EXECUTE
-	.long	5				# number of load commands
-	.long	60f-10f				# size of all load commands
-	.long	MAC_NOUNDEFS			# flags
-	.long	0				# reserved
-10:	.long	MAC_LC_SEGMENT_64
-	.long	20f-10b				# unmaps first page dir
-	.ascin	"__PAGEZERO",16			# consistent with linux
-	.quad	0,0x200000,0,0			# which forbids mem <2m
-	.long	0,0,0,0
-20:	.long	MAC_LC_SEGMENT_64
-	.long	30f-20b
-	.ascin	"__TEXT",16
-	.quad	ehdr				# vaddr
-	.quad	4096				# memsz
-	.quad	0				# file offset
-	.quad	filesz				# file size
-	.long	PROT_EXEC|PROT_READ|PROT_WRITE	# maxprot
-	.long	PROT_EXEC|PROT_READ		# initprot
-	.long	1				# segment section count
-	.long	0				# flags
-210:	.ascin	"__text",16			# section name (.text)
-	.ascin	"__TEXT",16
-	.quad	_start				# vaddr
-	.quad	textsz				# memsz
-	.long	textoff				# offset
-	.long	6				# align 2**6 = 64
-	.long	0				# reloc table offset
-	.long	0				# relocation count
-	.long	MAC_S_ATTR_SOME_INSTRUCTIONS	# section type & attributes
-	.long	0,0,0				# reserved
-30:	.long	MAC_LC_SEGMENT_64
-	.long	40f-30b
-	.ascin	"__DATA",16
-	.quad	bss				# vaddr
-	.quad	bsssize				# memsz
-	.quad	0				# offset
-	.quad	0				# file size
-	.long	PROT_EXEC|PROT_READ|PROT_WRITE	# maxprot
-	.long	PROT_READ|PROT_WRITE		# initprot
-	.long	1				# segment section count
-	.long	0				# flags
-310:	.ascin	"__bss",16			# section name (.bss)
-	.ascin	"__DATA",16
-	.quad	bss				# vaddr
-	.quad	bsssize				# memsz
-	.long	0				# offset
-	.long	12				# align 2**12 = 4096
-	.long	0				# reloc table offset
-	.long	0				# relocation count
-	.long	MAC_S_ZEROFILL			# section type & attributes
-	.long	0,0,0				# reserved
-40:	.long	MAC_LC_UUID
-	.long	50f-40b
-	.quad	0x3fb29ee4ac6c87aa		# uuid1
-	.quad	0xdd2c9bb866d9eef8		# uuid2
-50:	.long	MAC_LC_UNIXTHREAD
-	.long	60f-50b				# cmdsize
-	.long	MAC_THREAD_NEXGEN32E		# flavaflav
-	.long	(520f-510f)/4			# count
-510:	.quad	0				# rax
-	.quad	0				# rbx
-	.quad	0				# rcx
-	.quad	_HOSTXNU			# rdx
-	.quad	0				# rdi
-	.quad	0				# rsi
-	.quad	0				# rbp
-	.quad	0				# rsp
-	.quad	0				# r8
-	.quad	0				# r9
-	.quad	0				# r10
-	.quad	0				# r11
-	.quad	0				# r12
-	.quad	0				# r13
-	.quad	0				# r14
-	.quad	0				# r15
-	.quad	_start				# rip
-	.quad	0				# rflags
-	.quad	0				# cs
-	.quad	0				# fs
-	.quad	0				# gs
-520:
-60:
-	.endobj	macho
-
-	.align	64,0				# for ape.S dd
-	.org	0x400				# for ape.S dd
-
-//	Ape Loader Entrpoint
-//
-//	This is normally called by the operating system. However it may
-//	be called by the Actually Portable Executables themselves, when
-//	re-executing a program. Just do this:
-//
-//	    memcpy(0x200000, loader)
-//	    lea handoff(%rip),%rcx
-//	    lea argblock(%rip),%rsp
-//	    jmp 0x200400
-//
-//	@see	APE_LOADER_ENTRY
-//	@see	ape/loader.h
-_start:
-
-//	Hack for detecting M1 Rosetta environment.
-//	https://github.com/jart/cosmopolitan/issues/429#issuecomment-1166704377
-	cmp	$-1,%ebx
-	jne	0f
-	cmp	$+1,%edx
-	jne	0f
-	mov	$_HOSTXNU,%dl
-	xor	%ecx,%ecx
-
-0:	mov	%rsp,%rsi
-	jmp	ApeLoader
-	.endfn	_start,globl
-
-//	System Call Entrpoint
-//
-//	This function is used by the APE loader to make system calls.
-//	We also pass a reference to this function to the APE binary's
-//	_start() function. It's needed because on OpenBSD, msyscall()
-//	restricts which pages can issue system calls, and it can only
-//	be called once. Therefore if we want to be load and re-load a
-//	binary multiple times without calling the system execve(), we
-//	need to be able to handover the SYSCALL function. We hardcode
-//	this to a fixed address, but that shouldn't be used, since we
-//	would ideally want to move it to a random page in the future.
-__syscall_loader:
-	clc
-	syscall
-	jc	1f
-	ret
-1:	neg	%rax
-	ret
-	.endfn	__syscall_loader,globl

ape/loader-macho.S

@@ -21,118 +21,75 @@
 #include "libc/dce.h"
 #include "libc/macros.internal.h"
 
-//	APE Loader Executable Structure for XNU
+//	Apple Mach-O Executable Headers
+//	Fixups are applied by objbincopy.com
+//	There must exist a MAC_LC_SEGMENT_64 for every PT_LOAD
 
-	.align	4096
-macho:	.long	0xFEEDFACE+1
+	.section .macho,"a",@progbits
+	.balign	64
+	.long	0xFEEDFACE+1
 	.long	MAC_CPU_NEXGEN32E
 	.long	MAC_CPU_NEXGEN32E_ALL
 	.long	MAC_EXECUTE
-	.long	5				# number of load commands
-	.long	60f-10f				# size of all load commands
-	.long	MAC_NOUNDEFS			# flags
-	.long	0				# reserved
+	.long	5				// number of load commands
+	.long	60f-10f				// size of all load commands
+	.long	MAC_NOUNDEFS|MAC_SPLIT_SEGS	// flags
+	.long	0				// reserved
 10:	.long	MAC_LC_SEGMENT_64
-	.long	20f-10b				# unmaps first page dir
-	.ascin	"__PAGEZERO",16			# consistent with linux
-	.quad	0,0x200000,0,0			# which forbids mem <2m
+	.long	20f-10b				// unmaps first page dir
+	.ascin	"__PAGEZERO",16			// consistent with linux
+	.quad	0,0x200000,0,0			// which forbids mem <2m
 	.long	0,0,0,0
 20:	.long	MAC_LC_SEGMENT_64
 	.long	30f-20b
 	.ascin	"__TEXT",16
-	.quad	macho				# vaddr
-	.quad	4096				# memsz
-	.quad	0				# file offset
-	.quad	filesz				# file size
-	.long	PROT_EXEC|PROT_READ|PROT_WRITE	# maxprot
-	.long	PROT_EXEC|PROT_READ		# initprot
-	.long	1				# segment section count
-	.long	0				# flags
-210:	.ascin	"__text",16			# section name (.text)
-	.ascin	"__TEXT",16
-	.quad	_start				# vaddr
-	.quad	textsz				# memsz
-	.long	textoff				# offset
-	.long	6				# align 2**3 = 64
-	.long	0				# reloc table offset
-	.long	0				# relocation count
-	.long	MAC_S_ATTR_SOME_INSTRUCTIONS	# section type & attributes
-	.long	0,0,0				# reserved
+	.quad	0				// vaddr
+	.quad	0				// memsz
+	.quad	0				// file offset
+	.quad	0				// file size
+	.long	0				// maxprot
+	.long	0				// initprot
+	.long	0				// segment section count
+	.long	0				// flags
 30:	.long	MAC_LC_SEGMENT_64
 	.long	40f-30b
-	.ascin	"__DATA",16
-	.quad	bss				# vaddr
-	.quad	bsssize				# memsz
-	.quad	0				# offset
-	.quad	0				# file size
-	.long	PROT_EXEC|PROT_READ|PROT_WRITE	# maxprot
-	.long	PROT_READ|PROT_WRITE		# initprot
-	.long	1				# segment section count
-	.long	0				# flags
-310:	.ascin	"__bss",16			# section name (.bss)
-	.ascin	"__DATA",16
-	.quad	bss				# vaddr
-	.quad	bsssize				# memsz
-	.long	0				# offset
-	.long	12				# align 2**12 = 4096
-	.long	0				# reloc table offset
-	.long	0				# relocation count
-	.long	MAC_S_ZEROFILL			# section type & attributes
-	.long	0,0,0				# reserved
+	.ascin	"__RODATA",16
+	.quad	0				// vaddr
+	.quad	0				// memsz
+	.quad	0				// file offset
+	.quad	0				// file size
+	.long	0				// maxprot
+	.long	0				// initprot
+	.long	0				// segment section count
+	.long	0				// flags
 40:	.long	MAC_LC_UUID
 	.long	50f-40b
-	.quad	0x3fb29ee4ac6c87aa		# uuid1
-	.quad	0xdd2c9bb866d9eef8		# uuid2
+	.quad	0x4527148ba7a513ef		// uuid1
+	.quad	0x56fa865940665e8f		// uuid2
 50:	.long	MAC_LC_UNIXTHREAD
-	.long	60f-50b				# cmdsize
-	.long	MAC_THREAD_NEXGEN32E		# flavaflav
-	.long	(520f-510f)/4			# count
-510:	.quad	0				# rax
-	.quad	0				# rbx
-	.quad	0				# rcx
-	.quad	_HOSTXNU			# rdx
-	.quad	0				# rdi
-	.quad	0				# rsi
-	.quad	0				# rbp
-	.quad	0				# rsp
-	.quad	0				# r8
-	.quad	0				# r9
-	.quad	0				# r10
-	.quad	0				# r11
-	.quad	0				# r12
-	.quad	0				# r13
-	.quad	0				# r14
-	.quad	0				# r15
-	.quad	_start				# rip
-	.quad	0				# rflags
-	.quad	0				# cs
-	.quad	0				# fs
-	.quad	0				# gs
+	.long	60f-50b				// cmdsize
+	.long	MAC_THREAD_NEXGEN32E		// flavaflav
+	.long	(520f-510f)/4			// count
+510:	.quad	0				// rax
+	.quad	0				// rbx
+	.quad	0				// rcx
+	.quad	0				// rdx
+	.quad	0				// rdi
+	.quad	0				// rsi
+	.quad	0				// rbp
+	.quad	0				// rsp
+	.quad	0				// r8
+	.quad	0				// r9
+	.quad	0				// r10
+	.quad	0				// r11
+	.quad	0				// r12
+	.quad	0				// r13
+	.quad	0				// r14
+	.quad	0				// r15
+	.quad	XnuEntrypoint			// rip
+	.quad	0				// rflags
+	.quad	0				// cs
+	.quad	0				// fs
+	.quad	0				// gs
 520:
 60:
-	.endobj	macho,globl
-
-	.align	64
-_start:
-
-//	Hack for detecting M1 Rosetta environment.
-//	https://github.com/jart/cosmopolitan/issues/429#issuecomment-1166704377
-	cmp	$-1,%ebx
-	jne	0f
-	cmp	$+1,%edx
-	jne	0f
-	mov	$_HOSTXNU,%dl
-	xor	%ecx,%ecx
-
-0:	mov	%rsp,%rsi
-	jmp	ApeLoader
-	.endfn	_start,globl
-
-__syscall_loader:
-	clc
-	syscall
-	jc	1f
-	ret
-1:	neg	%rax
-	ret
-	.endfn	__syscall_loader,globl

ape/loader-macho.lds

@@ -1,42 +0,0 @@
-/*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
-│vi: set et sts=2 tw=2 fenc=utf-8                                           :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-ENTRY(_start)
-
-SECTIONS {
-  . = 0x200000;
-  .text : {
-    *(.text)
-    *(.rodata .rodata.*)
-    . = ALIGN(4096);
-  }
-  filesz = . - macho;
-  textsz = . - _start;
-  .bss ALIGN(4096) : {
-    bss = .;
-    *(.bss)
-    . = ALIGN(4096);
-  }
-  memsz = . - macho;
-  /DISCARD/ : {
-    *(.*)
-  }
-}
-
-bsssize = SIZEOF(.bss);
-textoff = _start - macho;

ape/loader.h

@@ -1,20 +0,0 @@
-#ifndef COSMOPOLITAN_APE_LOADER_H_
-#define COSMOPOLITAN_APE_LOADER_H_
-
-#define APE_LOADER_BASE  0x200000
-#define APE_LOADER_SIZE  0x200000
-#define APE_LOADER_ENTRY 0x200400
-#define APE_LOADER_BSS   (PAGESIZE * 2)
-#define APE_LOADER_STACK 0x7f0000000000
-#define APE_BLOCK_BASE   0x7e0000000000
-#define APE_BLOCK_SIZE   0x000200000000
-
-struct ApeLoader {
-  int fd;
-  int os;
-  char *prog;
-  char *page;
-  void *systemcall;
-};
-
-#endif /* COSMOPOLITAN_APE_LOADER_H_ */

ape/loader.lds

@@ -1,7 +1,7 @@
 /*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
 │vi: set et sts=2 tw=2 fenc=utf-8                                           :vi│
 ╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@@ -16,28 +16,80 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-ENTRY(_start)
+
+ENTRY(ElfEntrypoint)
+
+PHDRS {
+  text PT_LOAD FLAGS(1) FILEHDR PHDRS; /* PF_X */
+  rodata PT_LOAD FLAGS(4); /* PF_R */
+  stack PT_GNU_STACK FLAGS(6); /* PF_W|PF_R */
+  note PT_NOTE FLAGS(4); /* PF_R */
+}
 
 SECTIONS {
-  . = 0x200000;
+
+  . = SEGMENT_START("text-segment", 0x7f000000);
+  __executable_start = .;
+  . += SIZEOF_HEADERS;
+
+  .macho : {
+    KEEP(*(.macho))
+  } :text
+
+  .note : {
+    KEEP(*(.note))
+  } :text :note
+
   .text : {
-    *(.text)
-    *(.rodata .rodata.*)
-    . = ALIGN(64);
-  }
-  filesz = . - ehdr;
-  textsz = . - _start;
-  .bss ALIGN(4096) : {
-    bss = .;
-    *(.bss)
-    . = ALIGN(4096);
-  }
+    *(.text .text.* .gnu.linkonce.t.*)
+  } :text
+
+  .rodata ALIGN(CONSTANT(COMMONPAGESIZE)) : {
+    *(.rodata .rodata.* .gnu.linkonce.r.*)
+  } :rodata
+
+  .stack : {
+    *(.stack)
+  } :stack
+
   _end = .;
-  memsz = _end - ehdr;
+
+  .stab               0 : { *(.stab) }
+  .stabstr            0 : { *(.stabstr) }
+  .stab.excl          0 : { *(.stab.excl) }
+  .stab.exclstr       0 : { *(.stab.exclstr) }
+  .stab.index         0 : { *(.stab.index) }
+  .stab.indexstr      0 : { *(.stab.indexstr) }
+  .gnu.build.attributes : { *(.gnu.build.attributes .gnu.build.attributes.*) }
+  .debug              0 : { *(.debug) }
+  .line               0 : { *(.line) }
+  .debug_srcinfo      0 : { *(.debug_srcinfo) }
+  .debug_sfnames      0 : { *(.debug_sfnames) }
+  .debug_aranges      0 : { *(.debug_aranges) }
+  .debug_pubnames     0 : { *(.debug_pubnames) }
+  .debug_info         0 : { *(.debug_info .gnu.linkonce.wi.*) }
+  .debug_abbrev       0 : { *(.debug_abbrev) }
+  .debug_line         0 : { *(.debug_line .debug_line.* .debug_line_end) }
+  .debug_frame        0 : { *(.debug_frame) }
+  .debug_str          0 : { *(.debug_str) }
+  .debug_loc          0 : { *(.debug_loc) }
+  .debug_macinfo      0 : { *(.debug_macinfo) }
+  .debug_weaknames    0 : { *(.debug_weaknames) }
+  .debug_funcnames    0 : { *(.debug_funcnames) }
+  .debug_typenames    0 : { *(.debug_typenames) }
+  .debug_varnames     0 : { *(.debug_varnames) }
+  .debug_pubtypes     0 : { *(.debug_pubtypes) }
+  .debug_ranges       0 : { *(.debug_ranges) }
+  .debug_macro        0 : { *(.debug_macro) }
+  .debug_addr         0 : { *(.debug_addr) }
+  .debug_loclists     0 : { *(.debug_loclists) }
+  .debug_rnglists     0 : { *(.debug_rnglists) }
+  .debug_line_str     0 : { *(.debug_line_str) }
+  .debug_extra        0 : { *(.debug_line_str) }
+  .debug_pubtypes     0 : { *(.debug_pubtypes) }
+  .gnu.attributes     0 : { KEEP(*(.gnu.attributes)) }
+
   /DISCARD/ : {
     *(.*)
   }
 }
-
-bsssize = SIZEOF(.bss);
-textoff = _start - ehdr;

ape/sections.internal.h

@@ -3,31 +3,26 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-extern unsigned char _base[];
-extern unsigned char _ehead[];
-extern unsigned char _etext[];
-extern unsigned char _edata[];
-extern unsigned char _ezip[];
-extern unsigned char _end[];
-extern unsigned char _ereal[];
-extern unsigned char _tdata_start[];
-extern unsigned char _tdata_end[];
-extern unsigned char _tbss_start[];
-extern unsigned char _tbss_end[];
-extern unsigned char __privileged_start[];
-extern unsigned char __privileged_addr[];
-extern unsigned char __privileged_size[];
-extern unsigned char __privileged_end[];
-extern unsigned char __test_start[];
-extern unsigned char __ro[];
-extern unsigned char *__relo_start[];
-extern unsigned char *__relo_end[];
-extern uint8_t __zip_start[];
-extern uint8_t __zip_end[];
-extern uint8_t __data_start[];
-extern uint8_t __data_end[];
-extern uint8_t __bss_start[];
-extern uint8_t __bss_end[];
+extern const char __comment_start[] __attribute__((__weak__));
+extern unsigned char __executable_start[] __attribute__((__weak__));
+extern unsigned char __privileged_start[] __attribute__((__weak__));
+extern unsigned char _ehead[] __attribute__((__weak__));
+extern unsigned char _etext[] __attribute__((__weak__));
+extern unsigned char _edata[] __attribute__((__weak__));
+extern unsigned char _ezip[] __attribute__((__weak__));
+extern unsigned char _end[] __attribute__((__weak__));
+extern unsigned char _ereal[] __attribute__((__weak__));
+extern unsigned char _tdata_start[] __attribute__((__weak__));
+extern unsigned char _tdata_end[] __attribute__((__weak__));
+extern unsigned char _tbss_start[] __attribute__((__weak__));
+extern unsigned char _tbss_end[] __attribute__((__weak__));
+extern unsigned char _tls_align[] __attribute__((__weak__));
+extern unsigned char __test_start[] __attribute__((__weak__));
+extern unsigned char __ro[] __attribute__((__weak__));
+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__));
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

ape/start.S

@@ -0,0 +1,72 @@
+/*-*- 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│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/dce.h"
+#include "ape/ape.h"
+#include "libc/macros.internal.h"
+
+#ifdef __aarch64__
+
+_start:	mov	x1,sp
+	mov	x29,0
+	bl	ApeLoader
+	.endfn	_start,globl
+
+#else
+
+XnuEntrypoint:
+	mov	$_HOSTXNU,%dl			// xnu's not unix!
+ElfEntrypoint:
+	mov	%rsp,%rsi			// save real stack
+	call	ApeLoader
+	.endfn	ElfEntrypoint,globl
+	.endfn	XnuEntrypoint,globl
+
+	.section .note,"a",@progbits
+	.balign	4
+openbsd.ident:
+	.long	2f-1f
+	.long	4f-3f
+	.long	1
+1:	.asciz	"OpenBSD"
+2:	.balign	4
+3:	.long	0
+4:	.size	openbsd.ident,.-openbsd.ident
+	.type	openbsd.ident,@object
+	.balign	4
+netbsd.ident:
+	.long	2f-1f
+	.long	4f-3f
+	.long	1
+1:	.asciz	"NetBSD"
+2:	.balign	4
+3:	.long	901000000
+4:	.size	netbsd.ident,.-netbsd.ident
+	.type	netbsd.ident,@object
+	.balign	4
+ape.ident:
+	.long	2f-1f
+	.long	4f-3f
+	.long	1
+1:	.asciz	"APE"
+2:	.balign	4
+3:	.long	APE_VERSION_NOTE
+4:	.size	ape.ident,.-ape.ident
+	.type	ape.ident,@object
+
+#endif

ape/systemcall.S

@@ -0,0 +1,49 @@
+/*-*- 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│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/macros.internal.h"
+
+//	Invokes system call.
+//
+//	This function has eight parameters. The first seven are for
+//	arguments passed along to the system call. The eight is for
+//	the magic number that indicates which system call is called
+//
+//	The return value follows the Linux kernel convention, where
+//	errors are returned as `-errno`. BSD systems are normalized
+//	to follow this convention automatically.
+SystemCall:
+#ifdef __aarch64__
+	mov	x8,x7
+	mov	x9,0
+	adds	x9,x9,0
+	svc	0
+	bcs	1f
+	ret
+1:	neg	x0,x0
+	ret
+#else
+	mov	%rcx,%r10
+	mov	16(%rsp),%eax
+	clc
+	syscall
+	jnc	1f
+	neg	%rax
+1:	ret
+#endif
+	.endfn	SystemCall,globl

bin/aarch64-unknown-cosmo-addr2line

@@ -0,0 +1,19 @@
+#!/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

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

bin/aarch64-unknown-cosmo-ar

@@ -0,0 +1,21 @@
+#!/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

@@ -0,0 +1,19 @@
+#!/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-c++

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

bin/aarch64-unknown-cosmo-cc

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

bin/aarch64-unknown-cosmo-install

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+FIRST=1
+for x; do
+  if [ $FIRST -eq 1 ]; then
+    set --
+    FIRST=0
+  fi
+  if [ x"$x" = x"-s" ]; then
+    continue
+  fi
+  set -- "$@" "$x"
+done
+
+exec install "$@"

bin/aarch64-unknown-cosmo-nm

@@ -0,0 +1,19 @@
+#!/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

@@ -0,0 +1,19 @@
+#!/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

@@ -0,0 +1,19 @@
+#!/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

@@ -0,0 +1,19 @@
+#!/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

@@ -0,0 +1,134 @@
+#!/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 [ "$(id -u)" -eq 0 ]; then
+  SUDO=
+else
+  SUDO=sudo
+fi
+
+echo "Actually Portable Executable (APE) Installer" >&2
+echo "Author:  Justine Tunney <[email protected]>"  >&2
+
+################################################################################
+# INSTALL APE LOADER SYSTEMWIDE
+
+if [ -f o/depend ] && 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.elf to /usr/bin/ape" >&2
+    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
+    $SUDO cp -f o//ape/ape.macho /usr/bin/ape || exit
+    echo "done" >&2
+  fi
+else
+  if ! [ /usr/bin/ape -nt o//ape/ape.elf ]; then
+    echo >&2
+    echo "installing o//ape/ape.elf to /usr/bin/ape" >&2
+    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
+    $SUDO cp -f o//ape/ape.elf /usr/bin/ape || exit
+    echo "done" >&2
+  fi
+fi
+
+################################################################################
+# 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

@@ -0,0 +1,60 @@
+#!/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
+
+# 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-blink-0.9.2 \
+         .ape-blink-1.0.0; do
+  rm -f \
+     ~/$x \
+     /tmp/$x \
+     o/tmp/$x \
+     "${TMPDIR:-/tmp}/$x"
+done

bin/apecopy

@@ -0,0 +1,102 @@
+#!/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

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

bin/cosmoaddr2line

@@ -0,0 +1,31 @@
+#!/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/cosmoc++

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

bin/cosmocc

@@ -0,0 +1,381 @@
+#!/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
+  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

@@ -0,0 +1,119 @@
+#!/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++

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

bin/fatcosmocc

@@ -0,0 +1,650 @@
+#!/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/fatcosmoinstall

@@ -0,0 +1,100 @@
+#!/bin/sh
+
+# the `install -s` strip flag provided by gnu coreutils surprisngly
+# enough understands the portable executable format however it will
+# silently corrupt any actually portable executable it touches, due
+# to how it overwrites the whole mz header and removes the dos stub
+FIRST=1
+for x; do
+  if [ $FIRST -eq 1 ]; then
+    set --
+    FIRST=0
+  fi
+  if [ x"$x" = x"-s" ]; then
+    continue
+  fi
+  set -- "$@" "$x"
+done
+
+# now magically copy multi-architecture build artifacts
+if [ $# -gt 1 ]; then
+
+  # parse `install [$flags]... $src $dst`
+  i=0
+  n=$(( $# - 2 ))
+  dst=
+  src=
+  flags=
+  for x; do
+    if [ x"$x" != x"${x#* }" ]; then
+      # give up if any arguments contain spaces
+      exec install "$@"
+    fi
+    src=$dst
+    dst=$x
+    if [ $i -lt $n ]; then
+      flags="$flags $x"
+    fi
+    i=$(( i + 1 ))
+  done
+
+  arch=aarch64
+
+  # turn:
+  #   install -c -m 644 foo.a /usr/lib/foo.a
+  # into:
+  #   install -c -m 644 foo.a /usr/lib/foo.a
+  #   install -c -m 644 .aarch/foo.a /usr/lib/.aarch/foo.a
+  if [ x"${dst##*/}" = x"${src##*/}" ] &&  # basenames are equal
+     [ x"$dst" != x"${dst%.a}" ]; then     # specifies static archive
+    srcdir=${src%/*}
+    srcbas=${dst##*/}
+    if [ x"$srcdir" = x"$src" ]; then
+      srcdir=
+    elif [ -n "$srcdir" ]; then
+      srcdir="$srcdir/"
+    fi
+    if [ -f "$srcdir.$arch/$srcbas" ]; then
+      dstdir=${dst%/*}
+      dstbas=${dst##*/}
+      if [ x"$dstdir" = x"$dst" ]; then
+        dstdir=
+      elif [ -n "$dstdir" ]; then
+        dstdir="$dstdir/"
+      fi
+      if [ ! -d "$dstdir.$arch" ]; then
+        mkdir -p "$dstdir.$arch" || exit
+      fi
+      install $flags $src $dst || exit
+      exec install $flags \
+           "$srcdir.$arch/$srcbas" \
+           "$dstdir.$arch/$dstbas"
+    fi
+  fi
+
+  # turn:
+  #   install -c -m 644 foo.a /usr/lib
+  # into:
+  #   install -c -m 644 foo.a /usr/lib
+  #   install -c -m 644 .aarch/foo.a /usr/lib/.aarch
+  arch=aarch64
+  if [ x"$src" != x"${src%.a}" ] && [ -d "$dst" ]; then
+    srcdir=${src%/*}
+    srcbas=${dst##*/}
+    if [ x"$srcdir" = x"$src" ]; then
+      srcdir=
+    elif [ -n "$srcdir" ]; then
+      srcdir="$srcdir/"
+    fi
+    if [ -f "$srcdir.$arch/$srcbas" ]; then
+      if [ ! -d "$dst/.$arch" ]; then
+        mkdir -p "$dst/.$arch" || exit
+      fi
+      install $flags $src $dst || exit
+      exec install $flags "$srcdir.$arch/$srcbas" "$dst/.$arch"
+    fi
+  fi
+
+fi
+
+exec install "$@"

bin/unknown-unknown-cosmo-ar

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

bin/unknown-unknown-cosmo-c++

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

bin/unknown-unknown-cosmo-cc

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

bin/unknown-unknown-cosmo-install

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

bin/x86_64-unknown-cosmo-addr2line

@@ -0,0 +1,19 @@
+#!/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

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

bin/x86_64-unknown-cosmo-ar

@@ -0,0 +1,22 @@
+#!/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

@@ -0,0 +1,19 @@
+#!/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++

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

bin/x86_64-unknown-cosmo-cc

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

bin/x86_64-unknown-cosmo-install

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+FIRST=1
+for x; do
+  if [ $FIRST -eq 1 ]; then
+    set --
+    FIRST=0
+  fi
+  if [ x"$x" = x"-s" ]; then
+    continue
+  fi
+  set -- "$@" "$x"
+done
+
+exec install "$@"

bin/x86_64-unknown-cosmo-nm

@@ -0,0 +1,19 @@
+#!/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

@@ -0,0 +1,19 @@
+#!/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

@@ -0,0 +1,19 @@
+#!/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

@@ -0,0 +1,19 @@
+#!/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" "$@"