Release Cosmopolitan v3.0.2

It's recommended that all users, especially Apple Arm, re-run:

    ape/apeinstall.sh

Within the Cosmopolitan monorepo to refresh your APE loader.

.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,12 +17,15 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        mode: ["", tiny, opt, rel]
+        mode: ["", tiny, rel, tinylinux, optlinux]
     steps:
       - uses: actions/checkout@v3
 
-      - name: support ape bins
-        run: sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
+      - name: support ape bins 1
+        run: sudo cp build/bootstrap/ape.elf /usr/bin/ape
+
+      - name: support ape bins 2
+        run: sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
 
       - name: make matrix
         run: V=0 make -j2 MODE=${{ matrix.mode }}

.gitignore

@@ -1,6 +1,7 @@
 # -*- conf -*-
 
 /o
+/.prompt.jtlp
 
 # TODO: Find some way to have Python write to o/
 __pycache__
@@ -11,3 +12,5 @@ __pycache__
 /TAGS
 /bx_enh_dbg.ini
 /tool/emacs/*.elc
+/perf.data
+/perf.data.old

.vscode/c_cpp_properties.json

@@ -15,7 +15,7 @@
 				"alignas(x)",
 				"alignof(x)",
 				"artificial=",
-				"dontdiscard=",
+				"__wur=",
 				"mayalias=",
 				"forceinline=",
 				"forcealign(x)=",
@@ -35,18 +35,17 @@
 				"returnstwice=",
 				"textwindows=",
 				"privileged=",
-				"compatfn=",
-				"noinstrument=",
+				"dontinstrument=",
 				"nodebuginfo=",
 				"interruptfn=",
 				"optimizespeed=",
 				"forcealignargpointer=",
-				"noasan=",
-				"noubsan=",
-				"testonly=",
+				"dontasan=",
+				"dontubsan=",
 				"donothing=",
 				"nosideeffect=",
-				"unreachable=",
+				"unreachable=",,
+				"notpossible=",
 				"thatispacked=",
 				"dontthrow=",
 				"nocallback=",
@@ -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,17 +60,51 @@
 #   build/config.mk
 
 SHELL      = build/bootstrap/cocmd.com
-HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 win10 xnu
 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),)
+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.18.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		\
@@ -81,18 +115,40 @@ 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	\
-	rx:build/bootstrap	\
-	rx:o/third_party/gcc	\
-	/proc/self/status	\
-	rw:/dev/null		\
-	w:o/stack.log		\
-	/etc/hosts		\
-	~/.runit.psk
+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 =
 
@@ -101,54 +157,67 @@ 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/puff/puff.mk		# │
 include libc/elf/elf.mk				# │
 include ape/ape.mk				# │
-include libc/fmt/fmt.mk				#─┘
+include libc/fmt/fmt.mk				# │
+include libc/vga/vga.mk				# │
+include libc/irq/irq.mk				#─┘
 include libc/calls/calls.mk			#─┐
-include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
-include libc/crt/crt.mk				# │  You can issue system calls
+include libc/irq/irq.mk				# ├──SYSTEMS RUNTIME
+include third_party/nsync/nsync.mk		# │  You can issue system calls
+include libc/runtime/runtime.mk			# │
+include libc/dlopen/dlopen.mk			# │
+include third_party/double-conversion/dc.mk	# │
+include libc/crt/crt.mk				# │
 include third_party/dlmalloc/dlmalloc.mk	#─┘
 include libc/mem/mem.mk				#─┐
-include 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 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/getopt/getopt.mk		# │
+include third_party/intel/intel.mk		# │
+include third_party/aarch64/aarch64.mk		# │
 include libc/libc.mk				#─┘
 include libc/sock/sock.mk			#─┐
 include dsp/tty/tty.mk				# ├──ONLINE RUNTIME
 include libc/dns/dns.mk				# │  You can communicate with the network
 include net/http/http.mk			# │
 include third_party/mbedtls/mbedtls.mk		# │
+include third_party/libcxx/libcxx.mk		# │
+include third_party/ggml/ggml.mk		# │
+include third_party/radpajama/radpajama.mk	# │
 include net/https/https.mk			# │
 include third_party/regex/regex.mk		#─┘
 include third_party/tidy/tidy.mk
 include third_party/third_party.mk
+include third_party/nsync/testing/testing.mk
 include libc/testlib/testlib.mk
 include tool/viz/lib/vizlib.mk
 include tool/args/args.mk
@@ -156,9 +225,16 @@ include test/tool/args/test.mk
 include third_party/linenoise/linenoise.mk
 include third_party/maxmind/maxmind.mk
 include net/finger/finger.mk
-include third_party/double-conversion/double-conversion.mk
+include third_party/double-conversion/test/test.mk
 include third_party/lua/lua.mk
+include third_party/tree/tree.mk
+include third_party/zstd/zstd.mk
+include third_party/tr/tr.mk
+include third_party/sed/sed.mk
+include third_party/awk/awk.mk
+include third_party/hiredis/hiredis.mk
 include third_party/make/make.mk
+include third_party/ctags/ctags.mk
 include third_party/finger/finger.mk
 include third_party/argon2/argon2.mk
 include third_party/smallz4/smallz4.mk
@@ -167,14 +243,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
@@ -185,10 +262,10 @@ 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
+include net/turfwar/turfwar.mk
 include test/libc/tinymath/test.mk
 include test/libc/intrin/test.mk
 include test/libc/mem/test.mk
@@ -205,6 +282,7 @@ include test/libc/xed/test.mk
 include test/libc/fmt/test.mk
 include test/libc/dns/test.mk
 include test/libc/time/test.mk
+include test/libc/proc/test.mk
 include test/libc/stdio/test.mk
 include test/libc/release/test.mk
 include test/libc/test.mk
@@ -244,111 +322,121 @@ 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)))
 o/$(MODE)/hdrs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(HDRS) $(INCS),$(file >>$@,$(x)))
 
-TAGS: .UNSANDBOXED = 1
-TAGS:	o/$(MODE)/srcs-old.txt $(SRCS)
+TAGS: private .UNSANDBOXED = 1
+TAGS:	o/$(MODE)/srcs-old.txt $(SRCS) #o/$(MODE)/third_party/ctags/ctags.com
 	@$(RM) $@
-	@$(TAGS) $(TAGSFLAGS) -L $< -o $@
+	@o/$(MODE)/third_party/ctags/ctags.com $(TAGSFLAGS) -L $< -o $@
 
-HTAGS: .UNSANDBOXED = 1
-HTAGS:	o/$(MODE)/hdrs-old.txt $(HDRS)
+HTAGS: private .UNSANDBOXED = 1
+HTAGS:	o/$(MODE)/hdrs-old.txt $(filter-out third_party/libcxx/%,$(HDRS)) #o/$(MODE)/third_party/ctags/ctags.com
 	@$(RM) $@
-	@build/htags -L $< -o $@
+	@build/htags o/$(MODE)/third_party/ctags/ctags.com -L $< -o $@
 
-loc: .UNSANDBOXED = 1
+loc: private .UNSANDBOXED = 1
 loc: o/$(MODE)/tool/build/summy.com
 	find -name \*.h -or -name \*.c -or -name \*.S | \
 	$(XARGS) wc -l | grep total | awk '{print $$1}' | $<
 
-COSMOPOLITAN_OBJECTS =		\
-	NET_HTTP		\
-	LIBC_DNS		\
-	LIBC_SOCK		\
-	LIBC_NT_WS2_32		\
-	LIBC_NT_IPHLPAPI	\
-	LIBC_NT_MSWSOCK		\
-	LIBC_X			\
-	THIRD_PARTY_GETOPT	\
-	LIBC_LOG		\
-	LIBC_TIME		\
-	LIBC_ZIPOS		\
-	THIRD_PARTY_ZLIB	\
-	THIRD_PARTY_MUSL	\
-	LIBC_STDIO		\
-	THIRD_PARTY_GDTOA	\
-	THIRD_PARTY_REGEX	\
-	LIBC_MEM		\
-	THIRD_PARTY_DLMALLOC	\
-	LIBC_RUNTIME		\
-	LIBC_ELF		\
-	LIBC_CALLS		\
-	LIBC_SYSV_CALLS		\
-	LIBC_NT_PSAPI		\
-	LIBC_NT_POWRPROF	\
-	LIBC_NT_PDH		\
-	LIBC_NT_GDI32		\
-	LIBC_NT_COMDLG32	\
-	LIBC_NT_URL		\
-	LIBC_NT_USER32		\
-	LIBC_NT_NTDLL		\
-	LIBC_NT_ADVAPI32	\
-	LIBC_FMT		\
-	THIRD_PARTY_COMPILER_RT	\
-	LIBC_THREAD		\
-	LIBC_TINYMATH		\
-	THIRD_PARTY_XED		\
-	LIBC_STR		\
-	LIBC_SYSV		\
-	LIBC_INTRIN		\
-	LIBC_NT_KERNEL32	\
+# PLEASE: MAINTAIN TOPOLOGICAL ORDER
+# FROM HIGHEST LEVEL TO LOWEST LEVEL
+COSMOPOLITAN_OBJECTS =			\
+	TOOL_ARGS			\
+	NET_HTTP			\
+	LIBC_DNS			\
+	LIBC_SOCK			\
+	LIBC_NT_WS2_32			\
+	LIBC_NT_IPHLPAPI		\
+	LIBC_X				\
+	THIRD_PARTY_GETOPT		\
+	LIBC_LOG			\
+	LIBC_TIME			\
+	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		\
+	LIBC_DLOPEN			\
+	LIBC_RUNTIME			\
+	THIRD_PARTY_NSYNC		\
+	LIBC_ELF			\
+	LIBC_IRQ			\
+	LIBC_CALLS			\
+	LIBC_SYSV_CALLS			\
+	LIBC_VGA			\
+	LIBC_NT_PSAPI			\
+	LIBC_NT_POWRPROF		\
+	LIBC_NT_PDH			\
+	LIBC_NT_GDI32			\
+	LIBC_NT_COMDLG32		\
+	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			\
+	LIBC_STR			\
+	LIBC_SYSV			\
+	LIBC_INTRIN			\
+	LIBC_NT_KERNEL32		\
 	LIBC_NEXGEN32E
 
-COSMOPOLITAN_HEADERS =		\
-	APE			\
-	LIBC			\
-	LIBC_CALLS		\
-	LIBC_DNS		\
-	LIBC_ELF		\
-	LIBC_FMT		\
-	LIBC_INTRIN		\
-	LIBC_LOG		\
-	LIBC_MEM		\
-	LIBC_NEXGEN32E		\
-	LIBC_NT			\
-	LIBC_RUNTIME		\
-	LIBC_SOCK		\
-	LIBC_STDIO		\
-	THIRD_PARTY_XED		\
-	LIBC_STR		\
-	LIBC_SYSV		\
-	LIBC_THREAD		\
-	LIBC_TIME		\
-	LIBC_TINYMATH		\
-	LIBC_X			\
-	LIBC_ZIPOS		\
-	NET_HTTP		\
-	THIRD_PARTY_DLMALLOC	\
-	THIRD_PARTY_GDTOA	\
-	THIRD_PARTY_GETOPT	\
-	THIRD_PARTY_MUSL	\
-	THIRD_PARTY_ZLIB	\
-	THIRD_PARTY_ZLIB_GZ	\
+COSMOPOLITAN_HEADERS =			\
+	APE				\
+	LIBC				\
+	LIBC_CALLS			\
+	LIBC_DNS			\
+	LIBC_ELF			\
+	LIBC_FMT			\
+	LIBC_INTRIN			\
+	LIBC_LOG			\
+	LIBC_MEM			\
+	LIBC_NEXGEN32E			\
+	LIBC_NT				\
+	LIBC_RUNTIME			\
+	LIBC_SOCK			\
+	LIBC_STDIO			\
+	LIBC_PROC			\
+	THIRD_PARTY_NSYNC		\
+	THIRD_PARTY_XED			\
+	LIBC_STR			\
+	LIBC_SYSV			\
+	LIBC_THREAD			\
+	LIBC_TIME			\
+	LIBC_TINYMATH			\
+	LIBC_X				\
+	LIBC_VGA			\
+	NET_HTTP			\
+	TOOL_ARGS			\
+	THIRD_PARTY_DLMALLOC		\
+	THIRD_PARTY_GDTOA		\
+	THIRD_PARTY_GETOPT		\
+	THIRD_PARTY_MUSL		\
 	THIRD_PARTY_REGEX
 
-o/$(MODE)/cosmopolitan.a:	\
+o/$(MODE)/cosmopolitan.a:		\
 		$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS))
 
 o/cosmopolitan.h:							\
@@ -357,8 +445,12 @@ 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:							\
 		o/$(MODE)/third_party/chibicc/chibicc.com.dbg		\
 		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))	\
@@ -367,7 +459,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		\
@@ -377,6 +469,51 @@ $(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: $(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
 #
 # A build rule must exist for all files that make needs to consider in
@@ -401,9 +538,9 @@ $(SRCS):
 $(HDRS):
 $(INCS):
 .DEFAULT:
-	@$(ECHO) >&2
-	@$(ECHO) NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@ >&2
-	@$(ECHO) >&2
+	@$(ECHO)
+	@$(ECHO) NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@
+	@$(ECHO)
 	$(RM) o/$(MODE)/depend
 
 -include o/$(MODE)/depend

README.md

@@ -19,16 +19,415 @@ 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.0.zip
-unzip cosmopolitan-amalgamation-2.0.zip
+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'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
+./hello.com.dbg
+```
+
+You can use the `cosmocc` toolchain to build conventional open source
+projects which use autotools. This strategy normally works:
+
+```sh
+export CC=cosmocc
+export CXX=cosmoc++
+./configure --prefix=/opt/cosmos
+make -j
+make install
+```
+
+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
+./hello.com --strace
+```
+
+Here's how you can get a much more verbose log of function calls:
+
+```sh
+./hello.com --ftrace
+```
+
+If you don't want rich runtime features like the above included, and you
+just want libc, and you want smaller simpler programs. In that case, you
+can consider using `MODE=tiny`, which is preconfigured by the repo in
+[build/config.mk](build/config.mk). Using this mode is much more
+effective at reducing binary footprint than the `-Os` flag alone. You
+can change your build mode by doing the following:
+
+```sh
+export MODE=tiny
+cosmocc --update
+```
+
+We can also make our program slightly smaller by using the system call
+interface directly, which is fine, since Cosmopolitan polyfills these
+interfaces across platforms, including Windows. For example:
+
+```c
+// hello2.c
+#include <unistd.h>
+int main() {
+  write(1, "hello world\n", 12);
+}
+```
+
+Once compiled, your APE binary should be ~36kb in size.
+
+```sh
+export MODE=tiny
+cosmocc -Os -o hello2.com hello2.c
+./hello2.com
+```
+
+But let's say you only care about your binaries running on Linux and you
+don't want to use up all this additional space for platforms like WIN32.
+In that case, you can try `MODE=tinylinux` for example which will create
+executables more on the order of 8kb (similar to Musl Libc).
+
+```sh
+export MODE=tinylinux
+cosmocc --update
+cosmocc -Os -o hello2.com hello2.c
+./hello2.com  # <-- actually an ELF executable
+```
+
+## ARM
+
+Cosmo supports cross-compiling binaries for machines with ARM
+microprocessors. For example:
+
+```sh
+make -j8 m=aarch64 o/aarch64/third_party/ggml/llama.com
+make -j8 m=aarch64-tiny o/aarch64-tiny/third_party/ggml/llama.com
+```
+
+That'll produce ELF executables that run natively on two operating
+systems: Linux Arm64 (e.g. Raspberry Pi) and MacOS Arm64 (i.e. Apple
+Silicon), thus giving you full performance. The catch is you have to
+compile these executables on an x86_64-linux machine. The second catch
+is that MacOS needs a little bit of help understanding the ELF format.
+To solve that, we provide a tiny APE loader you can use on M1 machines.
+
+```sh
+scp ape/ape-m1.c macintosh:
+scp o/aarch64/third_party/ggml/llama.com macintosh:
+ssh macintosh
+xcode-install
+cc -o ape ape-m1.c
+sudo cp ape /usr/local/bin/ape
+```
+
+You can run your ELF AARCH64 executable on Apple Silicon as follows:
+
+```sh
+ape ./llama.com
+```
+
+If you want to run the `MODE=aarch64` unit tests, you need to have
+qemu-aarch64 installed as a binfmt_misc interpreter. It needs to be a
+static binary if you want it to work with Landlock Make's security. You
+can use the build included in our `third_party/qemu/` folder.
+
+```
+doas cp o/third_party/qemu/qemu-aarch64 /usr/bin/qemu-aarch64
+doas sh -c "echo ':qemu-aarch64:M::\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\xb7\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-aarch64:CF' > /proc/sys/fs/binfmt_misc/register"
+make -j8 m=aarch64
+```
+
+Please note that the qemu-aarch64 binfmt_misc interpreter installation
+process is *essential* for being able to use the `aarch64-unknown-cosmo`
+toolchain to build fat APE binaries on your x86-64 machine.
+
+## AMD64 + ARM64 fat APE binaries
+
+If you've setup the qemu binfmt_misc interpreter, then you can can use
+cosmo's toolchains to build fat ape binaries. It works by compiling your
+program twice, so you can have a native build for both architectures in
+the same file. The two programs are merged together by apelink.com which
+also embeds multiple copies of APE loader and multiple symbols tables.
+
+The easiest way to build fat APE is using `fatcosmocc`. This compiler
+works by creating a concomitant `.aarch64/foo.o` for every `foo.o` you
+compile. The only exception is the C preprocessor mode, which actually
+runs x86-64 GCC except with macros like `__x86_64__` undefined.
+
+This toolchain works great for C projects that are written in a portable
+way and don't produce architecture-specific artifacts. One example of a
+large project that can be easily built is GNU coreutils.
+
+```sh
+cd coreutils
+fatcosmocc --update ||exit
+./configure CC=fatcosmocc \
+            AR=fatcosmoar \
+            INSTALL=$(command -v fatcosmoinstall) \
+            --prefix=/opt/cosmos \
+            --disable-nls \
+            --disable-dependency-tracking \
+            --disable-silent-rules
+make -j8
+```
+
+You'll then have a bunch of files like `src/ls` which are fat ape
+binaries. If you want to run them on Windows, then you simply need to
+rename the file so that it has the `.com` suffix. Better yet, consider
+making that a symlink (a.k.a. reparse point). The biggest gotcha with
+`fatcosmocc` though is ensuring builds don't strip binaries. For
+example, Linux's `install -s` command actually understands Windows'
+Portable Executable format well enough to remove the MS-DOS stub, which
+is where the APE shell script is stored. You need to ensure that
+`fatcosmoinstall` is used instead. Especially if your project needs to
+install the libraries built by `fatacosmoar` into `/opt/cosmos`.
+
+## Advanced Fat APE Builds
+
+Once you get seriously involved in creating fat APE builds of software
+you're going to eventually outgrow `fatcosmocc`. One example is Emacs
+which is trickier to build, because it produces architecture-specific
+files, and it also depends on shared files, e.g. zoneinfo. Since we like
+having everything in a neat little single-file executable container that
+doesn't need an "installation wizard", this tutorial will explain how we
+manage to accomplish that.
+
+What you're going to do is, instead of using `fatcosmocc`, you're going
+to use both the `x86_64-unknown-cosmo-cc` and `aarch64-unknown-cosmo-cc`
+toolchains independently, and then run `apelink` and `zip` to manually
+build the final files. But there's a few tricks to learn first.
+
+The first trick is to create a symlink on your system called `/zip`.
+Cosmopolitan Libc normally uses that as a synthetic folder that lets you
+access the assets in your zip executable. But since that's a read-only
+file system, your build system should use the normal one.
+
+```sh
+doas ln -sf /opt/cosmos /zip
+```
+
+Now create a file named `rebuild-fat.sh` which runs the build twice:
+
+```sh
+#!/bin/sh
+set -ex
+export MODE=aarch64
+export COSMOS=/opt/cosmos/aarch64
+rebuild-cosmos.sh aarch64
+export MODE=
+export COSMOS=/opt/cosmos/x86_64
+rebuild-cosmos.sh x86_64
+wall.com 'finished building'
+```
+
+Then create a second file `rebuild-cosmos.sh` which runs your build:
+
+```sh
+#!/bin/bash
+set -ex
+
+ARCH=${1:-x86_64}
+export COSMO=${COSMO:-/opt/cosmo}
+export COSMOS=${COSMOS:-/opt/cosmos/$ARCH}
+export AS=$(command -v $ARCH-unknown-cosmo-as) || exit
+export CC=$(command -v $ARCH-unknown-cosmo-cc) || exit
+export CXX=$(command -v $ARCH-unknown-cosmo-c++) || exit
+export AR=$(command -v $ARCH-unknown-cosmo-ar) || exit
+export STRIP=$(command -v $ARCH-unknown-cosmo-strip) || exit
+export INSTALL=$(command -v $ARCH-unknown-cosmo-install) || exit
+export OBJCOPY=$(command -v $ARCH-unknown-cosmo-objcopy) || exit
+export OBJDUMP=$(command -v $ARCH-unknown-cosmo-objdump) || exit
+export ADDR2LINE=$(command -v $ARCH-unknown-cosmo-addr2line) || exit
+
+$CC --update
+
+export COSMOPOLITAN_DISABLE_ZIPOS=1
+
+cd ~/vendor/zlib
+./configure --prefix=$COSMOS --static
+make clean
+make -j
+make install
+
+cd ~/vendor/ncurses-6.4
+./configure --prefix=$COSMOS --sysconfdir=/zip --datarootdir=/zip/share --exec-prefix=/zip/$ARCH --disable-shared
+make clean
+make -j
+make install
+
+cd ~/vendor/readline-8.2
+./configure --prefix=$COSMOS --sysconfdir=/zip --datarootdir=/zip/share --exec-prefix=/zip/$ARCH --disable-shared
+make uninstall || true
+make clean
+make -j
+make install
+
+# NOTES:
+# 1. You'll need to patch enum { FOO = x } that fails to build into a #define FOO
+# 2. You'll need to patch configure.ac so it DOES NOT define USABLE_FIONREAD to 1
+# 2. You'll need to patch configure.ac so it DOES NOT define INTERRUPT_INPUT to 1
+cd ~/vendor/emacs-28.2
+./configure --prefix=$COSMOS --sysconfdir=/zip --datarootdir=/zip/share --exec-prefix=/zip/$ARCH \
+            --without-x --with-threads --without-gnutls --disable-silent-rules --with-file-notification=no
+make uninstall || true
+make clean
+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.
+
+```sh
+wget https://justine.lol/cosmopolitan/cosmopolitan.tar.gz
+tar xf cosmopolitan.tar.gz  # see releases page
+cd cosmopolitan
+```
+
+This will build the entire repository and run all the tests:
+
+```sh
+build/bootstrap/make.com
+o//examples/hello.com
+find o -name \*.com | xargs ls -rShal | less
+```
+
+If you get an error running make.com then it's probably because you have
+WINE installed to `binfmt_misc`. You can fix that by installing the the
+APE loader as an interpreter. It'll improve build performance too!
+
+```sh
+bin/ape-install
+```
+
+Since the Cosmopolitan repository is very large, you might only want to
+build a particular thing. Cosmopolitan's build config does a good job at
+having minimal deterministic builds. For example, if you wanted to build
+only hello.com then you could do that as follows:
+
+```sh
+build/bootstrap/make.com o//examples/hello.com
+```
+
+Sometimes it's desirable to build a subset of targets, without having to
+list out each individual one. You can do that by asking make to build a
+directory name. For example, if you wanted to build only the targets and
+subtargets of the chibicc package including its tests, you would say:
+
+```sh
+build/bootstrap/make.com o//third_party/chibicc
+o//third_party/chibicc/chibicc.com --help
+```
+
+Cosmopolitan provides a variety of build modes. For example, if you want
+really tiny binaries (as small as 12kb in size) then you'd say:
+
+```sh
+build/bootstrap/make.com m=tiny
+```
+
+Here's some other build modes you can try:
+
+```sh
+build/bootstrap/make.com m=dbg       # asan + ubsan + debug
+build/bootstrap/make.com m=asan      # production memory safety
+build/bootstrap/make.com m=opt       # -march=native optimizations
+build/bootstrap/make.com m=rel       # traditional release binaries
+build/bootstrap/make.com m=optlinux  # optimal linux-only performance
+build/bootstrap/make.com m=fastbuild # build 28% faster w/o debugging
+build/bootstrap/make.com m=tinylinux # tiniest linux-only 4kb binaries
+```
+
+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.2.zip
+unzip cosmopolitan-amalgamation-3.0.2.zip
 printf 'main() { printf("hello world\\n"); }\n' >hello.c
 gcc -g -Os -static -nostdlib -nostdinc -fno-pie -no-pie -mno-red-zone \
-  -fno-omit-frame-pointer -pg -mnop-mcount -mno-tls-direct-seg-refs \
+  -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
 ```
@@ -37,25 +436,44 @@ You now have a portable program.
 
 ```sh
 ./hello.com
-bash -c './hello.com'  # zsh/fish workaround (we patched them in 2021)
+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 to `${TMPDIR:-${HOME:-.}}`
-that maps your program into memory without needing to copy it. It's
-possible to install the APE loader systemwide as follows.
+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
-ape/apeinstall.sh
+bin/ape-install
 
 # System-Wide APE Uninstall
 # for Linux, Darwin, and BSDs
-ape/apeuninstall.sh
+bin/ape-uninstall
 ```
 
 It's also possible to convert APE binaries into the system-local format
@@ -85,7 +503,7 @@ heavyweight features like tracing to your binaries by default. In that
 case, you may want to consider using our build system:
 
 ```sh
-make -j8 MODE=tiny
+make m=tiny
 ```
 
 Which will cause programs such as `hello.com` and `life.com` to shrink
@@ -93,6 +511,39 @@ 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:
+
+```gdb
+set host-charset UTF-8
+set target-charset UTF-8
+set target-wide-charset UTF-8
+set osabi none
+set complaints 0
+set confirm off
+set history save on
+set history filename ~/.gdb_history
+define asm
+  layout asm
+  layout reg
+end
+define src
+  layout src
+  layout reg
+end
+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
@@ -117,7 +568,7 @@ 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
@@ -126,102 +577,10 @@ mv cross9 o/third_party/gcc
 build/bootstrap/make.com
 ```
 
-## Source Builds
+## Discord Chatroom
 
-Cosmopolitan can be compiled from source on any Linux distro. First, you
-need to download or clone the repository.
-
-```sh
-wget https://justine.lol/cosmopolitan/cosmopolitan.tar.gz
-tar xf cosmopolitan.tar.gz  # see releases page
-cd cosmopolitan
-```
-
-This will build the entire repository and run all the tests:
-
-```sh
-build/bootstrap/make.com -j16
-o//examples/hello.com
-find o -name \*.com | xargs ls -rShal | less
-```
-
-If you get an error running make.com then it's probably because you have
-WINE installed to `binfmt_misc`. You can fix that by installing the the
-APE loader as an interpreter. It'll improve build performance too!
-
-```sh
-ape/apeinstall.sh
-```
-
-Since the Cosmopolitan repository is very large, you might only want to
-build a particular thing. Cosmopolitan's build config does a good job at
-having minimal deterministic builds. For example, if you wanted to build
-only hello.com then you could do that as follows:
-
-```sh
-build/bootstrap/make.com -j16 o//examples/hello.com
-```
-
-Sometimes it's desirable to build a subset of targets, without having to
-list out each individual one. You can do that by asking make to build a
-directory name. For example, if you wanted to build only the targets and
-subtargets of the chibicc package including its tests, you would say:
-
-```sh
-build/bootstrap/make.com -j16 o//third_party/chibicc
-o//third_party/chibicc/chibicc.com --help
-```
-
-Cosmopolitan provides a variety of build modes. For example, if you want
-really tiny binaries (as small as 12kb in size) then you'd say:
-
-```sh
-build/bootstrap/make.com -j16 MODE=tiny
-```
-
-Here's some other build modes you can try:
-
-```sh
-build/bootstrap/make.com -j16 MODE=dbg       # asan + ubsan + debug
-build/bootstrap/make.com -j16 MODE=asan      # production memory safety
-build/bootstrap/make.com -j16 MODE=opt       # -march=native optimizations
-build/bootstrap/make.com -j16 MODE=rel       # traditional release binaries
-build/bootstrap/make.com -j16 MODE=optlinux  # optimal linux-only performance
-build/bootstrap/make.com -j16 MODE=tinylinux # tiniest linux-only 4kb binaries
-```
-
-For further details, see [//build/config.mk](build/config.mk).
-
-## GDB
-
-Here's the recommended `~/.gdbinit` config:
-
-```
-set host-charset UTF-8
-set target-charset UTF-8
-set target-wide-charset UTF-8
-set osabi none
-set complaints 0
-set confirm off
-set history save on
-set history filename ~/.gdb_history
-define asm
-  layout asm
-  layout reg
-end
-define src
-  layout src
-  layout reg
-end
-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
-
-```
-gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
-```
+The Cosmopolitan development team collaborates on the Redbean Discord
+server. You're welcome to join us! <https://discord.gg/FwAVVu7eJ4>
 
 ## Support Vector
 
@@ -229,21 +588,27 @@ gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
 | :---            | ---:        | ---:  |
 | AMD             | K8 Venus    | 2005  |
 | Intel           | Core        | 2006  |
-| Windows         | Vista       | 2006  |
 | Linux           | 2.6.18      | 2007  |
+| Windows         | 8 [1]       | 2012  |
 | Mac OS X        | 15.6        | 2018  |
+| OpenBSD         | 7           | 2021  |
 | FreeBSD         | 13          | 2020  |
-| OpenBSD         | 6.4         | 2018  |
 | NetBSD          | 9.2         | 2021  |
 
+[1] See our [vista branch](https://github.com/jart/cosmopolitan/tree/vista)
+    for a community supported version of Cosmopolitan that works on Windows
+    Vista and Windows 7.
+
 ## Special Thanks
 
 Funding for this project is crowdsourced using
 [GitHub Sponsors](https://github.com/sponsors/jart) and
 [Patreon](https://www.patreon.com/jart). Your support is what makes this
 project possible. Thank you! We'd also like to give special thanks to
-the following individuals:
+the following groups and individuals:
 
 - [Joe Drumgoole](https://github.com/jdrumgoole)
+- [Rob Figueiredo](https://github.com/robfig)
+- [Wasmer](https://wasmer.io/)
 
 For publicly sponsoring our work at the highest tier.

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 9
+#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

@@ -180,16 +180,40 @@
 #include "libc/elf/def.h"
 #include "libc/elf/pf2prot.internal.h"
 #include "libc/nt/pedef.internal.h"
-#include "libc/zip.h"
+#include "libc/thread/tls.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);
 }
 
@@ -200,42 +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 */
@@ -245,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)
@@ -272,6 +301,7 @@ SECTIONS {
     KEEP(*(.textwindowsprologue))
     *(.text.windows)
     KEEP(*(.textwindowsepilogue))
+    KEEP(*(.blink))
     *(SORT_BY_ALIGNMENT(.text.modernity))
     *(SORT_BY_ALIGNMENT(.text.modernity.*))
     *(SORT_BY_ALIGNMENT(.text.hot))
@@ -286,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));
@@ -305,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))
@@ -316,48 +345,64 @@ 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) */
-/*END: Read Only Data */
   } :Rom
 
-  .data ALIGN(PAGESIZE) : {
+/* initialization image for thread-local storage, this is copied */
+/* out to actual TLS areas at runtime, so just make it read-only */
+  .tdata . : {
+    _tdata_start = .;
+    *(SORT_BY_ALIGNMENT(.tdata))
+    *(SORT_BY_ALIGNMENT(.tdata.*))
+    _tdata_end = .;
+    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_start = .;
+    *(SORT_BY_ALIGNMENT(.tbss))
+    *(SORT_BY_ALIGNMENT(.tbss.*))
+    KEEP(*(.fstls))
+    /* the %fs register is based on this location */
+    _tbss_end = .;
+  } :Tls
+
+  .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)
@@ -367,54 +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 = .);
+    _edata = .;
+    PROVIDE(edata = .);
+    _ezip = .; /* <-- very deprecated */
   } :Ram
 
-  .tdata . : {
-    _tdata_start = .;
-    *(SORT_BY_ALIGNMENT(.tdata))
-    *(SORT_BY_ALIGNMENT(.tdata.*))
-    . = ALIGN(16);
-    _tdata_end = .;
-    . = ALIGN(PAGESIZE);
-  } :Tls
-  . = ALIGN(PAGESIZE);
+  . = ALIGN(CONSTANT(COMMONPAGESIZE));
 
 /*END:   file content that's loaded by o/s */
-/*BEGIN: bss memory void */
-
-  .tbss . : {
-    _tbss_start = .;
-    *(SORT_BY_ALIGNMENT(.tbss))
-    *(SORT_BY_ALIGNMENT(.tbss.*))
-    . = ALIGN(16);
-    /* the %fs register is based on this location */
-    _tbss_end = .;
-  } :Tls
-
 /*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 */
@@ -425,11 +467,15 @@ SECTIONS {
     KEEP(*(SORT_BY_NAME(.sort.bss.*)))
 
     KEEP(*(.bssepilogue))
+
+    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
+
 /*END: NT FORK COPYING */
-    . = ALIGN(FRAMESIZE); /* for brk()/sbrk() allocation */
-    HIDDEN(_end = .);
-    PROVIDE_HIDDEN(end = .);
-  } :Bss
+  } :Ram
+
+  . = ALIGN(CONSTANT(COMMONPAGESIZE));
+  _end = .;
+  PROVIDE(end = .);
 
 /*END: nt addressability guarantee */
 /*END: bsd addressability guarantee */
@@ -457,6 +503,7 @@ SECTIONS {
   .debug_line        0 : { *(.debug_line .debug_line.* .debug_line_end ) }
   .debug_frame       0 : { *(.debug_frame) }
   .debug_str         0 : { *(.debug_str) }
+  .debug_line_str    0 : { *(.debug_line_str) }
   .debug_loc         0 : { *(.debug_loc) }
   .debug_macinfo     0 : { *(.debug_macinfo) }
   .debug_weaknames   0 : { *(.debug_weaknames) }
@@ -465,19 +512,38 @@ SECTIONS {
   .debug_varnames    0 : { *(.debug_varnames) }
   .debug_pubtypes    0 : { *(.debug_pubtypes) }
   .debug_ranges      0 : { *(.debug_ranges) }
+  .debug_rnglists    0 : { *(.debug_rnglists) }
   .debug_macro       0 : { *(.debug_macro) }
   .debug_addr        0 : { *(.debug_addr) }
   .gnu.attributes    0 : { KEEP(*(.gnu.attributes)) }
   .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);
@@ -485,68 +551,58 @@ PFSTUB4(ape_elf_phnum, (ape_phdrs_end - ape_phdrs) / 56);
 PFSTUB4(ape_elf_shnum, 0);
 PFSTUB4(ape_elf_shstrndx, 0);
 
-HIDDEN(_tdata_size = _tdata_end - _tdata_start);
-HIDDEN(_tls_size = _tbss_end - _tdata_start);
-HIDDEN(_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) + SIZEOF(.tdata));
-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));
-HIDDEN(ape_text_memsz = SIZEOF(.text));
-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) + SIZEOF(.tdata));
-HIDDEN(ape_data_memsz = SIZEOF(.data) + SIZEOF(.tdata));
-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 */
@@ -554,25 +610,41 @@ 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);
 
-#if SupportsMetal()
-HIDDEN(v_ape_realsectors =
-           MIN(0x70000 - IMAGE_BASE_REAL,
-               ROUNDUP(RVA(_edata), 4096)) / 512);
-HIDDEN(v_ape_realpages = v_ape_realsectors / (4096 / 512));
-HIDDEN(v_ape_highsectors =
-           (ROUNDUP(RVA(_edata), 512) / 512) - v_ape_realsectors);
-#endif
+#if defined(APE_IS_SHELL_SCRIPT) && !IsTiny()
 
-/* 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);
+#define IDENTITY(X) X
+
+#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
+
+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);
+
+#endif /* APE_IS_SHELL_SCRIPT */
+
+#if SupportsMetal()
+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
 
 #if SupportsXnu()
 /* Generates deterministic ID. */
@@ -592,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);
@@ -613,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);
@@ -633,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);
@@ -645,7 +710,7 @@ CHURN(ADDR(.bss));
 CHURN(_start);
 CHURN(ape_phdrs);
 #if SupportsMetal()
-CHURN(v_ape_realsectors);
+CHURN(v_ape_allsectors);
 #endif
 #if SupportsXnu()
 CHURN(ape_macho);
@@ -666,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()
@@ -699,17 +765,16 @@ 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");
 
-ASSERT(!(ape_stack_vaddr & (ape_stack_memsz - 1)),
-       "ape_stack_vaddr must have ape_stack_memsz alignment; try using STATIC_STACK_ADDR(0x700000000000 - ape_stack_memsz);");
+ASSERT(ape_stack_vaddr % ape_stack_memsz == 0,
+       "ape_stack_vaddr must have ape_stack_memsz alignment; try using STATIC_STACK_ADDR(0x700000040000 & -ape_stack_memsz);");
+
+ASSERT(ALIGNOF(.tdata) <= TLS_ALIGNMENT && ALIGNOF(.tbss) <= TLS_ALIGNMENT,
+       "_Thread_local _Alignof can't exceed TLS_ALIGNMENT");
+
+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,58 +70,112 @@ 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/calls/struct/timespec.h	\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/elf/pf2prot.internal.h	\
-		libc/macros.internal.h		\
-		libc/nt/pedef.internal.h	\
-		libc/str/str.h			\
-		libc/zip.h
-
 o/ape/idata.inc:				\
 		ape/idata.internal.h		\
 		ape/relocations.h
 
 o/$(MODE)/ape/ape-no-modify-self.o:		\
 		ape/ape.S			\
+		ape/ape.h			\
 		ape/macros.internal.h		\
 		ape/notice.inc			\
 		ape/relocations.h		\
+		ape/ape.internal.h		\
 		libc/dce.h			\
 		libc/elf/def.h			\
+		libc/thread/tls.h		\
 		libc/intrin/asancodes.h		\
 		libc/macho.internal.h		\
 		libc/macros.internal.h		\
 		libc/nexgen32e/uart.internal.h	\
+		libc/calls/metalfile.internal.h	\
 		libc/nexgen32e/vidya.internal.h	\
 		libc/nt/pedef.internal.h	\
 		libc/runtime/e820.internal.h	\
 		libc/runtime/mman.internal.h	\
 		libc/runtime/pc.internal.h	\
-		libc/runtime/symbolic.h		\
 		libc/sysv/consts/prot.h		\
+		ape/blink-linux-aarch64.gz	\
+		ape/blink-xnu-aarch64.gz	\
 		o/$(MODE)/ape/ape.elf
 	@$(COMPILE)				\
 		-AOBJECTIFY.S			\
@@ -104,56 +186,69 @@ 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		\
 		libc/nexgen32e/uart.internal.h	\
+		libc/calls/metalfile.internal.h	\
 		libc/nexgen32e/vidya.internal.h	\
 		libc/nt/pedef.internal.h	\
 		libc/runtime/e820.internal.h	\
 		libc/runtime/mman.internal.h	\
 		libc/runtime/pc.internal.h	\
-		libc/runtime/symbolic.h		\
-		libc/sysv/consts/prot.h
+		libc/sysv/consts/prot.h		\
+		ape/blink-linux-aarch64.gz	\
+		ape/blink-xnu-aarch64.gz
 	@$(COMPILE)				\
 		-AOBJECTIFY.S			\
 		$(OBJECTIFY.S)			\
 		$(OUTPUT_OPTION)		\
 		-DAPE_NO_MODIFY_SELF $<
 
-o/$(MODE)/ape/loader.o: ape/loader.c 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)			\
@@ -163,3 +258,30 @@ o/$(MODE)/ape:	$(APE_CHECKS)			\
 		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,126 +0,0 @@
-#!/bin/sh
-
-if [ $UID -eq 0 ]; then
-  SUDO=
-else
-  SUDO=sudo
-fi
-
-echo "Actually Portable Executable (APE) Installer" >&2
-echo "Author:  Justine Tunney <[email protected]>"  >&2
-
-################################################################################
-# INSTALL APE LOADER SYSTEMWIDE
-
-if [ -f o/depend ]; then
-  # mkdeps.com build was successfully run so assume we can build
-  echo >&2
-  echo "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 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,24 +0,0 @@
-#!/bin/sh
-
-if [ "$UID" = "0" ]; then
-  SUDO=
-else
-  SUDO=sudo
-fi
-
-{
-  echo
-  echo "APE Uninstaller intends to run"
-  echo
-  echo "    $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE'"
-  echo "    $SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape /tmp/.ape"
-  echo
-  echo "You may then use ape/apeinstall.sh to reinstall it"
-  echo
-} >&2
-
-set -ex
-if [ -f /proc/sys/fs/binfmt_misc/APE ]; then
-  $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE' || exit
-fi
-$SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape o/tmp/ape /tmp/.ape /tmp/ape || exit

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,80 +31,84 @@
 //	@see	libc/nt/master.sh
 //	@see	ape/ape.lds
 //	@see	winimp
-.macro	.imp	dll:req fn:req actual:req hint
-	.dll	\dll
-	.section .piro.data.sort.iat.2.\dll\().2.\actual,"aw",@progbits
+.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
 	.align	__SIZEOF_POINTER__
-\fn:	.quad	RVA((\dll\().\actual))
+\fn:	.quad	RVA(("\dll\().\actual"))
 	.size	\fn,.-\fn
 	.globl	\fn
 	.hidden	\fn
 	.previous
-	.section .idata.ro.ilt.\dll\().2.\actual,"a",@progbits
-.Lidata.ilt.\dll\().\actual:
-	.quad	RVA((\dll\().\actual))
-	.type	.Lidata.ilt.\dll\().\actual,@object
-	.size	.Lidata.ilt.\dll\().\actual,.-.Lidata.ilt.\dll\().\actual
+	.section ".idata.ro.ilt.\dll\().2.\actual","a",@progbits
+"idata.ilt.\dll\().\actual":
+	.quad	RVA("\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
+	.section ".idata.ro.hnt.\dll\().2.\actual","a",@progbits
+"\dll\().\actual":
+	.short	0			// hint
 	.asciz	"\actual"
-	.align	2			# documented requirement
-	.globl	\dll\().\actual
-	.hidden	\dll\().\actual
-	.type	\dll\().\actual,@object
-	.size	\dll\().\actual,.-\dll\().\actual
+	.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.
 //	@note	this is an implementation detail of .imp
 .macro	.dll	name:req
-  .section .idata.ro.idt.2.\name,"aG",@progbits,\name,comdat
-	.equ	.Lidata.idt.\name,.
-	.long	RVA(idata.ilt.\name)		# ImportLookupTable
-	.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
+  .section ".idata.ro.idt.2.\name","aG",@progbits,"\name",comdat
+	.equ	".Lidata.idt.\name",.
+	.long	RVA("idata.ilt.\name")		// ImportLookupTable
+	.long	0				// TimeDateStamp
+	.long	0				// ForwarderChain
+	.long	RVA(".Lidata.str.\name")	// DllNameRva
+	.long	RVA("idata.iat.\name")		// ImportAddressTable
+	.type	".Lidata.idt.\name",@object
+	.size	".Lidata.idt.\name",.-".Lidata.idt.\name"
   .previous
-  .section .idata.ro.ilt.\name\().1,"aG",@progbits,\name,comdat
-	.align	__SIZEOF_POINTER__
-	.type	idata.ilt.\name,@object
-idata.ilt.\name:
+  .section ".idata.ro.ilt.\name\().1","aG",@progbits,"\name",comdat
+	.balign	__SIZEOF_POINTER__
+	.type	"idata.ilt.\name",@object
+"idata.ilt.\name":
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section .idata.ro.ilt.\name\().3,"aG",@progbits,\name,comdat
+	*/.section ".idata.ro.ilt.\name\().3","aG",@progbits,"\name",comdat
 	.quad	0
   .previous
-  .section .idata.ro.hnt.\name\().1,"aG",@progbits,\name,comdat
-	.align	__SIZEOF_POINTER__
-	.type	idata.hnt.\name,@object
-	.equ	idata.hnt.\name,.
+  .section ".idata.ro.hnt.\name\().1","aG",@progbits,"\name",comdat
+	.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__
-	.type	idata.iat.\name,@object
-idata.iat.\name:
+  .section ".piro.data.sort.iat.2.\name\().1","awG",@progbits,"\name",comdat
+	.balign	__SIZEOF_POINTER__
+	.type	"idata.iat.\name",@object
+"idata.iat.\name":
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section .piro.data.sort.iat.2.\name\().3,"awG",@progbits,\name,comdat
+	*/.section ".piro.data.sort.iat.2.\name\().3","awG",@progbits,"\name",comdat
 	.quad	0
   .previous
   .section .rodata.str1.1,"aSM",@progbits,1
-.Lidata.str.\name:
+".Lidata.str.\name":
 	.asciz	"\name\().dll"
   .previous
 .endm

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	XNU				# 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	$XNU,%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	XNU				# 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	$XNU,%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 *syscall;
-};
-
-#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/macros.internal.h

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

ape/public/ape.lds

@@ -0,0 +1 @@
+#include "ape/ape.lds"

ape/relocations.h

@@ -36,8 +36,8 @@
  */
 #define REAL(x) ((x) - (IMAGE_BASE_VIRTUAL - IMAGE_BASE_REAL))
 
-#if IMAGE_BASE_VIRTUAL % 0x200000 != 0
-#error "IMAGE_BASE_VIRTUAL must be 2mb aligned"
+#if IMAGE_BASE_VIRTUAL % 0x1000 != 0
+#error "IMAGE_BASE_VIRTUAL must be 4kb aligned"
 #endif
 #if IMAGE_BASE_PHYSICAL % 0x1000 != 0
 #error "IMAGE_BASE_PHYSICAL must be 4kb aligned"

ape/sections.internal.h

@@ -0,0 +1,29 @@
+#ifndef COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
+#define COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
+#if !(__ASSEMBLER__ + __LINKER__ + 0)
+COSMOPOLITAN_C_START_
+
+extern const char __comment_start[] __attribute__((__weak__));
+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) */
+#endif /* COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_ */

ape/start.S

@@ -0,0 +1,74 @@
+/*-*- 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
+	and     sp,x1,#-16
+	mov	x29,0
+	bl	ApeLoader
+	.endfn	_start,globl
+
+#else
+
+XnuEntrypoint:
+	mov	$_HOSTXNU,%dl			// xnu's not unix!
+ElfEntrypoint:
+	mov	%rsp,%rsi			// save real stack
+	andq    $-16,%rsp                       // force SSE alignment
+	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,148 @@
+#!/bin/sh
+
+PROG=${0##*/}
+MODE=${MODE:-$m}
+TMPDIR=${TMPDIR:-/tmp}
+COSMO=${COSMO:-/opt/cosmo}
+COSMOS=${COSMOS:-/opt/cosmos}
+
+if [ ! -f ape/loader.c ]; then
+  cd "$COSMO" || exit
+fi
+
+if [ "$(id -u)" -eq 0 ]; then
+  SUDO=
+else
+  SUDO=sudo
+fi
+
+echo "Actually Portable Executable (APE) Installer" >&2
+echo "Author:  Justine Tunney <[email protected]>"  >&2
+
+# special installation process for apple silicon
+if [ "$(uname -s)" = "Darwin" ] && [ "$(uname -m)" = "arm64" ]; then
+  echo "cc -O -o $TMPDIR/ape.$$ ape/ape-m1.c" >&2
+  cc -O -o "$TMPDIR/ape.$$" ape/ape-m1.c || exit
+  if [ ! -d /usr/local/bin ]; then
+    echo "$SUDO mkdir -p /usr/local/bin" >&2
+    $SUDO mkdir -p /usr/local/bin || exit
+  fi
+  echo "$SUDO mv -f $TMPDIR/ape.$$ /usr/local/bin/ape" >&2
+  $SUDO mv -f "$TMPDIR/ape.$$" /usr/local/bin/ape || exit
+  exit
+fi
+
+################################################################################
+# INSTALL APE LOADER SYSTEMWIDE
+
+if [ -f o/depend ] && make -j8 o//ape; then
+  echo "successfully recompiled ape loader" >&2
+elif [ -x o//ape/ape.elf ] && [ -x o//ape/ape.macho ]; then
+  echo "using ape loader you compiled earlier" >&2
+elif [ -d build/bootstrap ]; then
+  # if make isn't being used then it's unlikely the user changed the sources
+  # in that case the prebuilt binaries should be completely up-to-date
+  echo "using prebuilt ape loader from cosmo repo" >&2
+  mkdir -p o//ape || exit
+  cp -af build/bootstrap/ape.elf o//ape/ape.elf || exit
+  cp -af build/bootstrap/ape.macho o//ape/ape.macho || exit
+else
+  echo "no cosmopolitan libc repository here" >&2
+  echo "fetching ape loader from justine.lol"  >&2
+  mkdir -p o//ape || exit
+  if command -v wget >/dev/null 2>&1; then
+    wget -qO o//ape/ape.elf https://justine.lol/ape.elf || exit
+    wget -qO o//ape/ape.macho https://justine.lol/ape.macho || exit
+  else
+    curl -Rso o//ape/ape.elf https://justine.lol/ape.elf || exit
+    curl -Rso o//ape/ape.macho https://justine.lol/ape.macho || exit
+  fi
+  chmod +x o//ape/ape.elf || exit
+  chmod +x o//ape/ape.macho || exit
+fi
+
+if [ "$(uname -s)" = "Darwin" ]; then
+  if ! [ /usr/bin/ape -nt o//ape/ape.macho ]; then
+    echo >&2
+    echo "installing o//ape/ape.macho to /usr/bin/ape" >&2
+    echo "$SUDO cp -f o//ape/ape.macho /usr/bin/ape" >&2
+    $SUDO cp -f o//ape/ape.macho /usr/bin/ape || exit
+    echo "done" >&2
+  fi
+else
+  if ! [ /usr/bin/ape -nt o//ape/ape.elf ]; then
+    echo >&2
+    echo "installing o//ape/ape.elf to /usr/bin/ape" >&2
+    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
+    $SUDO cp -f o//ape/ape.elf /usr/bin/ape || exit
+    echo "done" >&2
+  fi
+fi
+
+################################################################################
+# REGISTER APE LOADER WITH BINFMT_MISC TOO (LINUX-ONLY)
+
+if [ x"$(uname -s)" = xLinux ]; then
+
+  if [ -e /proc/sys/fs/binfmt_misc/APE ]; then
+    echo >&2
+    echo it looks like APE is already registered with binfmt_misc >&2
+    echo To reinstall please run ape/apeuninstall.sh first >&2
+    echo please check that it is mapped to ape not /bin/sh >&2
+    echo cat /proc/sys/fs/binfmt_misc/APE >&2
+    cat /proc/sys/fs/binfmt_misc/APE >&2
+    exit
+  fi
+
+  if ! [ -e /proc/sys/fs/binfmt_misc ]; then
+    echo >&2
+    echo loading binfmt_misc into your kernel >&2
+    echo you may need to edit configs to persist across reboot >&2
+    echo $SUDO modprobe binfmt_misc >&2
+    $SUDO modprobe binfmt_misc || exit
+    echo done >&2
+  fi
+
+  if ! [ -e /proc/sys/fs/binfmt_misc/register ]; then
+    echo >&2
+    echo mounting binfmt_misc into your kernel >&2
+    echo you may need to edit configs to persist across reboot >&2
+    echo $SUDO mount -t binfmt_misc none /proc/sys/fs/binfmt_misc >&2
+    $SUDO mount -t binfmt_misc none /proc/sys/fs/binfmt_misc || exit
+    echo done >&2
+  fi
+
+  echo >&2
+  echo registering APE with binfmt_misc >&2
+  echo you may need to edit configs to persist across reboot >&2
+  echo '$SUDO sh -c "echo '"'"':APE:M::MZqFpD::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
+  $SUDO sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
+  echo '$SUDO sh -c "echo '"'"':APE-jart:M::jartsr::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
+  $SUDO sh -c "echo ':APE-jart:M::jartsr::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
+  echo done >&2
+
+  if [ x"$(cat /proc/sys/fs/binfmt_misc/status)" = xdisabled ]; then
+    echo >&2
+    echo enabling binfmt_misc >&2
+    echo you may need to edit configs to persist across reboot >&2
+    echo $SUDO sh -c 'echo 1 >/proc/sys/fs/binfmt_misc/status' >&2
+    $SUDO sh -c 'echo 1 >/proc/sys/fs/binfmt_misc/status' || exit
+    echo done >&2
+  fi
+
+fi
+
+################################################################################
+
+{
+  echo
+  echo "------------------------------------------------------------------"
+  echo
+  echo "APE INSTALL COMPLETE"
+  echo
+  echo "If you decide to uninstall APE later on"
+  echo "you may do so using ape/apeuninstall.sh"
+  echo
+  echo "Enjoy your APE loader (>'.')>"
+  echo
+} >&2

bin/ape-uninstall

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

bin/apecopy

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

bin/fatcosmoar

@@ -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" "$@"

build/config.mk

@@ -4,20 +4,67 @@
 # Default Mode
 #
 #   - `make`
+#   - Optimized
 #   - Backtraces
 #   - Syscall tracing
 #   - Function tracing
-#   - Reasonably small
-#   - Reasonably optimized
-#   - Reasonably debuggable
+#
 ifeq ($(MODE),)
-CONFIG_CCFLAGS +=		\
-	$(BACKTRACES)		\
-	$(FTRACE)		\
-	-DSYSDEBUG		\
-	-O2
-TARGET_ARCH ?=			\
-	-msse3
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g
+CONFIG_CCFLAGS += -O2 $(BACKTRACES)
+CONFIG_CPPFLAGS += -DSYSDEBUG
+TARGET_ARCH ?= -msse3
+endif
+ifeq ($(MODE), x86_64)
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g
+CONFIG_CCFLAGS += -O2 $(BACKTRACES)
+CONFIG_CPPFLAGS += -DSYSDEBUG
+endif
+ifeq ($(MODE), aarch64)
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g
+CONFIG_CCFLAGS += -O2 $(BACKTRACES)
+CONFIG_CPPFLAGS += -DSYSDEBUG
+endif
+
+# Zero Optimization Mode
+#
+#   - Goes 2x slower
+#   - Supports --strace
+#   - Unsupports --ftrace
+#   - Better GDB debugging
+#
+ifeq ($(MODE), zero)
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g
+OVERRIDE_CFLAGS += -O0
+OVERRIDE_CXXFLAGS += -O0
+CONFIG_CPPFLAGS += -DSYSDEBUG
+endif
+ifeq ($(MODE), aarch64-zero)
+CONFIG_OFLAGS ?= -g
+OVERRIDE_CFLAGS += -O0 -fdce
+OVERRIDE_CXXFLAGS += -O0 -fdce
+CONFIG_CPPFLAGS += -DSYSDEBUG
+endif
+
+# Fast Build Mode
+#
+#   - `make MODE=fastbuild`
+#   - No debugging
+#   - Syscall tracing
+#   - Function tracing
+#   - Some optimizations
+#   - Limited Backtraces
+#
+ifeq ($(MODE), fastbuild)
+ENABLE_FTRACE = 1
+CONFIG_CCFLAGS += $(BACKTRACES) -O
+CONFIG_CPPFLAGS += -DSYSDEBUG -DDWARFLESS
+CONFIG_LDFLAGS += -S
+TARGET_ARCH ?= -msse3
 endif
 
 # Optimized Mode
@@ -31,22 +78,17 @@ endif
 #   - No memory corruption detection
 #   - assert() / CHECK_xx() may leak code into binary for debuggability
 #   - GCC 8+ hoists check fails into .text.cold, thus minimizing impact
+#
 ifeq ($(MODE), opt)
-CONFIG_CPPFLAGS +=		\
-	-DNDEBUG		\
-	-msse2avx		\
-	-Wa,-msse2avx
-CONFIG_CCFLAGS +=		\
-	$(BACKTRACES)		\
-	$(FTRACE)		\
-	-DSYSDEBUG		\
-	-O3			\
-	-fmerge-all-constants
-TARGET_ARCH ?=			\
-	-march=native
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
+CONFIG_CCFLAGS += $(BACKTRACES) -O3 -fmerge-all-constants
+TARGET_ARCH ?= -march=native
 endif
 
 # Optimized Linux Mode
+# The Fastest Mode of All
 #
 #   - `make MODE=optlinux`
 #   - Turns on red zone
@@ -54,18 +96,13 @@ endif
 #   - Turns off function tracing
 #   - Turns off support for older cpu models
 #   - Turns off support for other operating systems
+#
 ifeq ($(MODE), optlinux)
-CONFIG_CPPFLAGS +=		\
-	-DNDEBUG		\
-	-msse2avx		\
-	-Wa,-msse2avx		\
-	-DSUPPORT_VECTOR=1
-CONFIG_CCFLAGS +=		\
-	-O3 -fmerge-all-constants
-DEFAULT_COPTS +=		\
-	-mred-zone
-TARGET_ARCH ?=			\
-	-march=native
+CONFIG_OFLAGS ?= -g
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS += -O3 -fmerge-all-constants
+CONFIG_COPTS += -mred-zone
+TARGET_ARCH ?= -march=native
 endif
 
 # Release Mode
@@ -76,21 +113,18 @@ endif
 #   - More optimized
 #   - Reasonably small
 #   - Numeric backtraces
+#   - No DWARF data bloat
 #   - Toilsome debuggability
 #   - assert() statements removed
 #   - DCHECK_xx() statements removed
 #   - No memory corruption detection
 #   - CHECK_xx() won't leak strings into binary
+#
 ifeq ($(MODE), rel)
-CONFIG_CPPFLAGS +=		\
-	-DNDEBUG
-CONFIG_CCFLAGS +=		\
-	$(BACKTRACES)		\
-	-O2
-TARGET_ARCH ?=			\
-	-msse3
-PYFLAGS +=			\
-	-O1
+CONFIG_CPPFLAGS += -DNDEBUG -DDWARFLESS
+CONFIG_CCFLAGS += $(BACKTRACES) -O2
+TARGET_ARCH ?= -msse3
+PYFLAGS += -O1
 endif
 
 # Asan Mode
@@ -103,14 +137,15 @@ endif
 #   - Backtraces
 #   - Debuggability
 #   - Larger binaries
+#
 ifeq ($(MODE), asan)
-CONFIG_CCFLAGS +=		\
-	$(BACKTRACES)		\
-	-O2
-CONFIG_COPTS +=			\
-	-fsanitize=address
-TARGET_ARCH ?=			\
-	-msse3
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g
+CONFIG_CPPFLAGS += -D__SANITIZE_ADDRESS__
+CONFIG_CCFLAGS += $(BACKTRACES) -O2 -DSYSDEBUG
+CONFIG_COPTS += -fsanitize=address
+TARGET_ARCH ?= -msse3
+QUOTA ?= -C64 -L300
 endif
 
 # Debug Mode
@@ -118,26 +153,46 @@ endif
 #   - `make MODE=dbg`
 #   - Backtraces
 #   - Enables asan
-#   - Enables ubsan (TODO)
+#   - Enables ubsan
 #   - Stack canaries
-#   - No optimization (TODO)
+#   - No optimization
 #   - Enormous binaries
+#
 ifeq ($(MODE), dbg)
-CONFIG_CPPFLAGS +=		\
-	-DMODE_DBG
-CONFIG_CCFLAGS +=		\
-	$(BACKTRACES)		\
-	$(FTRACE)		\
-	-DSYSDEBUG		\
-	-O2			\
-	-fno-inline
-CONFIG_COPTS +=			\
-	-fsanitize=address	\
-	-fsanitize=undefined
-TARGET_ARCH ?=			\
-	-msse3
-OVERRIDE_CCFLAGS +=		\
-	-fno-pie
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_ADDRESS__ -D__SANITIZE_UNDEFINED__
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline
+CONFIG_COPTS += -fsanitize=address -fsanitize=undefined
+TARGET_ARCH ?= -msse3
+OVERRIDE_CCFLAGS += -fno-pie
+QUOTA ?= -C64 -L300
+endif
+ifeq ($(MODE), aarch64-dbg)
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline -fdce
+CONFIG_COPTS += -fsanitize=undefined
+QUOTA ?= -C64 -L300
+endif
+
+# System Five Mode
+#
+#   - `make MODE=sysv`
+#   - Optimized
+#   - Backtraces
+#   - Debuggable
+#   - Syscall tracing
+#   - Function tracing
+#   - No Windows bloat!
+#
+ifeq ($(MODE), sysv)
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g
+CONFIG_CCFLAGS += $(BACKTRACES) -O2
+CONFIG_CPPFLAGS += -DSYSDEBUG -DSUPPORT_VECTOR=121
+TARGET_ARCH ?= -msse3
 endif
 
 # Tiny Mode
@@ -151,6 +206,7 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
+#
 ifeq ($(MODE), tiny)
 CONFIG_CPPFLAGS +=			\
 	-DTINY				\
@@ -163,15 +219,35 @@ CONFIG_CCFLAGS +=			\
 	-fno-align-labels		\
 	-fno-align-loops		\
 	-fschedule-insns2		\
-	-fomit-frame-pointer		\
 	-momit-leaf-frame-pointer	\
-	-foptimize-sibling-calls
+	-foptimize-sibling-calls	\
+	-DDWARFLESS
 TARGET_ARCH ?=				\
 	-msse3
 PYFLAGS +=				\
 	-O2				\
 	-B
 endif
+ifeq ($(MODE), aarch64-tiny)
+# TODO(jart): -mcmodel=tiny
+CONFIG_CPPFLAGS +=			\
+	-DTINY				\
+	-DNDEBUG			\
+	-DTRUSTWORTHY
+CONFIG_CCFLAGS +=			\
+	-Os				\
+	-fno-align-functions		\
+	-fno-align-jumps		\
+	-fno-align-labels		\
+	-fno-align-loops		\
+	-fschedule-insns2		\
+	-momit-leaf-frame-pointer	\
+	-foptimize-sibling-calls	\
+	-DDWARFLESS
+PYFLAGS +=				\
+	-O2				\
+	-B
+endif
 
 # Linux-Only Tiny Mode
 #
@@ -185,14 +261,14 @@ endif
 #   - No portability
 #   - No algorithmics
 #   - YOLO
+#
 ifeq ($(MODE), tinylinux)
 CONFIG_CPPFLAGS +=			\
 	-DTINY				\
 	-DNDEBUG			\
 	-DTRUSTWORTHY			\
-	-DSUPPORT_VECTOR=1
-DEFAULT_COPTS +=			\
-	-mred-zone
+	-DSUPPORT_VECTOR=1		\
+	-DDWARFLESS
 CONFIG_CCFLAGS +=			\
 	-Os				\
 	-fno-align-functions		\
@@ -216,14 +292,14 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
+#
 ifeq ($(MODE), tinylinuxbsd)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=113
-DEFAULT_COPTS +=		\
-	-mred-zone
+	-DSUPPORT_VECTOR=113	\
+	-DDWARFLESS
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -246,14 +322,14 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
+#
 ifeq ($(MODE), tinysysv)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=121
-DEFAULT_COPTS +=		\
-	-mred-zone
+	-DSUPPORT_VECTOR=121	\
+	-DDWARFLESS
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -276,12 +352,14 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
+#
 ifeq ($(MODE), tinynowin)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=251
+	-DSUPPORT_VECTOR=251	\
+	-DDWARFLESS
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -292,10 +370,40 @@ TARGET_ARCH ?=			\
 	-msse3
 endif
 
-# LLVM Mode
-ifeq ($(MODE), llvm)
+# no x87 instructions mode
+#
+#     export MODE=nox87
+#     make -j8 toolchain
+#     cosmocc -o /tmp/hello.com hello.c
+#
+# lets you shave ~23kb off blink
+#
+#     git clone https://github.com/jart/blink
+#     cd blink
+#     ./configure --disable-x87
+#     make -j8
+#     o//blink/blink /tmp/hello.com
+#
+ifeq ($(MODE), nox87)
+ENABLE_FTRACE = 1
+CONFIG_COPTS += -mlong-double-64
+CONFIG_CCFLAGS += $(BACKTRACES) -O2
+CONFIG_CPPFLAGS += -DSYSDEBUG -DNOX87
 TARGET_ARCH ?= -msse3
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -DSYSDEBUG -O2
+endif
+
+# LLVM Mode
+#
+# We aim to support:
+#
+#     make -j8 m=llvm o/llvm/libc
+#
+# The rest of the monorepo may not work with llvm.
+#
+ifeq ($(MODE), llvm)
+.STRICT = 0
+TARGET_ARCH ?= -msse3
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O2
 AS = clang
 CC = clang
 CXX = clang++
@@ -333,12 +441,65 @@ endif
 # such as MSVC or XCode. You can run your binary objects through a tool
 # like objconv to convert them to COFF or MachO. Then use ANSI mode to
 # rollup one header file that'll enable linkage with minimal issues.
-
 ifeq ($(MODE), ansi)
-
 CONFIG_CFLAGS += -std=c11
 #CONFIG_CPPFLAGS += -ansi
 CONFIG_CXXFLAGS += -std=c++11
 TARGET_ARCH ?= -msse3
+endif
 
+ifneq ($(ENABLE_FTRACE),)
+CONFIG_CPPFLAGS += -DFTRACE
+FTRACE_CCFLAGS = -fno-inline-functions-called-once
+OVERRIDE_CFLAGS += $(FTRACE_CCFLAGS)
+OVERRIDE_CXXFLAGS += $(FTRACE_CCFLAGS)
+# function prologue nops for --ftrace
+ifeq ($(ARCH), x86_64)
+# this flag causes gcc to generate functions like this
+#
+#       nop nop nop nop nop nop nop nop nop
+#     func:
+#       nop nop
+#       ...
+#
+# which tool/build/fixupobj.c improves at build time like this
+#
+#       nop nop nop nop nop nop nop nop nop
+#     func:
+#       xchg %ax,%ax
+#       ...
+#
+# which --ftrace morphs at runtime like this
+#
+#       ud2                # 2 bytes
+#       call ftrace_hook   # 5 bytes
+#       jmp +2             # 2 bytes
+#     func:
+#       jmp -7             # 2 bytes
+#       ...
+#
+CONFIG_CCFLAGS += -fpatchable-function-entry=18,16
+endif
+ifeq ($(ARCH), aarch64)
+# this flag causes gcc to generate functions like this
+#
+#       nop nop nop nop nop nop
+#     func:
+#       nop
+#       ...
+#
+# which --ftrace morphs at runtime like this
+#
+#       brk #31337
+#       stp x29,x30,[sp,#-16]!
+#       mov x29,sp
+#       bl  ftrace_hook
+#       ldp x29,x30,[sp],#16
+#       b   +1
+#     func:
+#       b   -5
+#       ...
+#
+CONFIG_CCFLAGS += -fpatchable-function-entry=7,6
+endif
 endif

build/definitions.mk

@@ -33,72 +33,100 @@
 #
 # VARIABLES
 #
-#     CCFLAGS      gcc frontend flags (.i, .c, .cc, .f, .S, .lds, etc.)
+#   Our configuration variables, ordered by increasing preference:
+#
+#     CCFLAGS      frontend flags (.i, .c, .cc, .f, .S, .lds, etc.)
+#     OFLAGS       objectify flags (precludes -S and -E)
 #     CPPFLAGS     preprocessor flags (.h, .c, .cc, .S, .inc, .lds, etc.)
+#     TARGET_ARCH  microarchitecture flags (e.g. -march=native)
+#     COPTS        c/c++ flags (.c, .cc)
 #     CFLAGS       c flags (.c only)
 #     CXXFLAGS     c++ flags (.cc only)
-#     COPTS        c/c++ flags (.c, .cc)
 #     LDFLAGS      linker flags (don't use -Wl, frontend prefix)
 #     ASFLAGS      assembler flags (don't use -Wa, frontend prefix)
-#     TARGET_ARCH  microarchitecture flags (e.g. -march=native)
+#
+#   For each FOO above, there exists (by increasing preference)
+#
+#     DEFAULT_FOO  see build/definitions.mk
+#     CONFIG_FOO   see build/config.mk
+#     FOO          set ~/.cosmo.mk and target-specific
+#     OVERRIDE_FOO set ~/.cosmo.mk and target-specific (use rarely)
+#
 
 LC_ALL = C
 SOURCE_DATE_EPOCH = 0
 
-TAGS ?= /usr/bin/ctags  # emacs source builds or something breaks it
 ARFLAGS = rcsD
 ZFLAGS ?=
 XARGS ?= xargs -P4 -rs8000
 DOT ?= dot
 CLANG = clang
-FC = gfortran  #/opt/cross9f/bin/x86_64-linux-musl-gfortran
 TMPDIR = o/tmp
 
 AR = build/bootstrap/ar.com
 CP = build/bootstrap/cp.com
 RM = build/bootstrap/rm.com -f
+GZIP = build/bootstrap/gzip.com
 ECHO = build/bootstrap/echo.com
+CHMOD = build/bootstrap/chmod.com
 TOUCH = build/bootstrap/touch.com
 PKG = build/bootstrap/package.com
 MKDEPS = build/bootstrap/mkdeps.com
 ZIPOBJ = build/bootstrap/zipobj.com
+ZIPCOPY = build/bootstrap/zipcopy.com
+PECHECK = build/bootstrap/pecheck.com
 FIXUPOBJ = build/bootstrap/fixupobj.com
 MKDIR = build/bootstrap/mkdir.com -p
 COMPILE = build/bootstrap/compile.com -V9 -P4096 $(QUOTA)
-SYMTAB = $(TMPDIR)/$(subst /,_,$@).symtab
 
 COMMA := ,
 PWD := $(shell build/bootstrap/pwd.com)
-IMAGE_BASE_VIRTUAL ?= 0x400000
 
-IGNORE := $(shell $(ECHO) -2 ♥cosmo)
-IGNORE := $(shell $(MKDIR) o/tmp)
+IGNORE := $(shell $(MKDIR) $(TMPDIR))
 
-ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-pc-linux-gnu-as.exe)","")
-AS = o/third_party/gcc/bin/x86_64-pc-linux-gnu-as.exe
-CC = o/third_party/gcc/bin/x86_64-pc-linux-gnu-gcc.exe
-CXX = o/third_party/gcc/bin/x86_64-pc-linux-gnu-g++.exe
-CXXFILT = o/third_party/gcc/bin/x86_64-pc-linux-gnu-c++filt.exe
-LD = o/third_party/gcc/bin/x86_64-pc-linux-gnu-ld.bfd.exe
-NM = o/third_party/gcc/bin/x86_64-pc-linux-gnu-nm.exe
-GCC = o/third_party/gcc/bin/x86_64-pc-linux-gnu-gcc.exe
-STRIP = o/third_party/gcc/bin/x86_64-pc-linux-gnu-strip.exe
-OBJCOPY = o/third_party/gcc/bin/x86_64-pc-linux-gnu-objcopy.exe
-OBJDUMP = o/third_party/gcc/bin/x86_64-pc-linux-gnu-objdump.exe
-ADDR2LINE = $(PWD)/o/third_party/gcc/bin/x86_64-pc-linux-gnu-addr2line.exe
+ifneq ($(findstring aarch64,$(MODE)),)
+ARCH = aarch64
+HOSTS ?= pi silicon
+else
+ARCH = x86_64
+HOSTS ?= freebsd rhel7 xnu win10 openbsd netbsd
+endif
+
+ifeq ($(PREFIX),)
+ifeq ($(USE_SYSTEM_TOOLCHAIN),)
+ifeq ($(ARCH),x86_64)
+ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-linux-cosmo-*)","")
+PREFIX = o/third_party/gcc/bin/x86_64-linux-cosmo-
 else
 IGNORE := $(shell build/bootstrap/unbundle.com)
-AS = o/third_party/gcc/bin/x86_64-linux-musl-as
-CC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
-CXX = o/third_party/gcc/bin/x86_64-linux-musl-g++
-CXXFILT = o/third_party/gcc/bin/x86_64-linux-musl-c++filt
-LD = o/third_party/gcc/bin/x86_64-linux-musl-ld.bfd
-NM = o/third_party/gcc/bin/x86_64-linux-musl-nm
-GCC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
-STRIP = o/third_party/gcc/bin/x86_64-linux-musl-strip
-OBJCOPY = o/third_party/gcc/bin/x86_64-linux-musl-objcopy
-OBJDUMP = o/third_party/gcc/bin/x86_64-linux-musl-objdump
-ADDR2LINE = $(PWD)/o/third_party/gcc/bin/x86_64-linux-musl-addr2line
+PREFIX = o/third_party/gcc/bin/x86_64-linux-musl-
+endif
+endif # ($(ARCH),x86_64))
+ifeq ($(ARCH),aarch64)
+ifneq ("$(wildcard o/third_party/gcc/bin/aarch64-linux-cosmo-*)","")
+PREFIX = o/third_party/gcc/bin/aarch64-linux-cosmo-
+else
+IGNORE := $(shell build/bootstrap/unbundle.com)
+PREFIX = o/third_party/gcc/bin/aarch64-linux-musl-
+endif
+endif # ($(ARCH),aarch64)
+endif # ($(USE_SYSTEM_TOOLCHAIN),)
+endif # ($(PREFIX),)
+
+AS = $(PREFIX)as
+CC = $(PREFIX)gcc
+CXX = $(PREFIX)g++
+CXXFILT = $(PREFIX)c++filt
+LD = $(PREFIX)ld.bfd
+NM = $(PREFIX)nm
+GCC = $(PREFIX)gcc
+STRIP = $(PREFIX)strip
+OBJCOPY = $(PREFIX)objcopy
+OBJDUMP = $(PREFIX)objdump
+ifneq ($(wildcard $(PWD)/$(PREFIX)addr2line),)
+ADDR2LINE = $(PWD)/$(PREFIX)addr2line
+else
+ADDR2LINE = $(PREFIX)addr2line
 endif
 
 export ADDR2LINE
@@ -108,23 +136,29 @@ export MODE
 export SOURCE_DATE_EPOCH
 export TMPDIR
 
-FTRACE =								\
-	-pg
+ifeq ($(LANDLOCKMAKE_VERSION),)
+TMPSAFE = $(join $(TMPDIR),$(subst /,_,$@)).tmp
+else
+TMPSAFE = $(TMPDIR)/
+endif
 
 BACKTRACES =								\
-	-fno-schedule-insns2						\
-	-fno-omit-frame-pointer						\
 	-fno-optimize-sibling-calls					\
 	-mno-omit-leaf-frame-pointer
 
+ifneq ($(ARCH), aarch64)
+BACKTRACES += -fno-schedule-insns2
+endif
+
 SANITIZER =								\
 	-fsanitize=address
 
 NO_MAGIC =								\
-	-mno-fentry							\
+	-ffreestanding							\
 	-fno-stack-protector						\
 	-fwrapv								\
-	-fno-sanitize=all
+	-fno-sanitize=all						\
+	-fpatchable-function-entry=0,0
 
 OLD_CODE =								\
 	-fno-strict-aliasing						\
@@ -135,37 +169,58 @@ TRADITIONAL =								\
 	-Wno-return-type						\
 	-Wno-pointer-sign
 
-DEFAULT_CCFLAGS =							\
+DEFAULT_CCFLAGS +=							\
 	-Wall								\
 	-Werror								\
-	-fdebug-prefix-map='$(PWD)'=					\
+	-fno-omit-frame-pointer						\
 	-frecord-gcc-switches
 
-DEFAULT_OFLAGS =							\
-	-g								\
-	-gdescribe-dies
-
-DEFAULT_COPTS =								\
-	-mno-red-zone							\
+DEFAULT_COPTS ?=							\
 	-fno-math-errno							\
-	-fno-trapping-math						\
-	-fno-fp-int-builtin-inexact					\
 	-fno-ident							\
 	-fno-common							\
 	-fno-gnu-unique							\
 	-fstrict-aliasing						\
 	-fstrict-overflow						\
 	-fno-semantic-interposition					\
+	-fno-dwarf2-cfi-asm						\
+	-fno-unwind-tables						\
+	-fno-asynchronous-unwind-tables
+
+ifeq ($(ARCH), x86_64)
+# Microsoft says "[a]ny memory below the stack beyond the red zone
+# [note: Windows defines the x64 red zone size as 0] is considered
+# volatile and may be modified by the operating system at any time."
+# https://devblogs.microsoft.com/oldnewthing/20190111-00/?p=100685
+DEFAULT_COPTS +=							\
+	-mno-red-zone							\
 	-mno-tls-direct-seg-refs
+endif
+
+ifeq ($(ARCH), aarch64)
+#
+# - Apple says in "Writing ARM64 code for Apple platforms" that we're
+#   not allowed to use the x18 register.
+#
+# - Cosmopolitan Libc uses x28 for thread-local storage because Apple
+#   forbids us from using tpidr_el0 too.
+#
+# - Cosmopolitan currently lacks an implementation of the runtime
+#   libraries needed by the -moutline-atomics flag
+#
+DEFAULT_COPTS +=							\
+	-ffixed-x18							\
+	-ffixed-x28							\
+	-mno-outline-atomics
+endif
 
 MATHEMATICAL =								\
 	-O3								\
 	-fwrapv
 
-DEFAULT_CPPFLAGS =							\
-	-DCOSMO								\
+DEFAULT_CPPFLAGS +=							\
+	-D_COSMO_SOURCE							\
 	-DMODE='"$(MODE)"'						\
-	-DIMAGE_BASE_VIRTUAL=$(IMAGE_BASE_VIRTUAL)			\
 	-nostdinc							\
 	-iquote .
 
@@ -176,7 +231,6 @@ DEFAULT_CXXFLAGS =							\
 	-fno-rtti							\
 	-fno-exceptions							\
 	-fuse-cxa-atexit						\
-	-fno-threadsafe-statics						\
 	-Wno-int-in-bool-context					\
 	-Wno-narrowing							\
 	-Wno-literal-suffix
@@ -184,28 +238,33 @@ DEFAULT_CXXFLAGS =							\
 DEFAULT_ASFLAGS =							\
 	-W								\
 	-I.								\
-	--noexecstack							\
-	--nocompress-debug-sections
+	--noexecstack
 
 DEFAULT_LDFLAGS =							\
 	-static								\
 	-nostdlib							\
-	-melf_x86_64							\
+	-znorelro							\
 	--gc-sections							\
 	--build-id=none							\
-	--no-dynamic-linker						\
-	-zmax-page-size=0x1000 #--cref [email protected]
+	--no-dynamic-linker
 
-ZIPOBJ_FLAGS =								\
-	 -b$(IMAGE_BASE_VIRTUAL)
+# # generate linker report files
+# DEFAULT_LDFLAGS += --cref [email protected]
 
-PYFLAGS =								\
-	 -b$(IMAGE_BASE_VIRTUAL)
+ifeq ($(ARCH), aarch64)
+DEFAULT_LDFLAGS +=							\
+	-zmax-page-size=0x4000						\
+	-zcommon-page-size=0x4000					\
+	-znorelro
+else
+DEFAULT_LDFLAGS +=							\
+	-zmax-page-size=0x4000						\
+	-zcommon-page-size=0x1000
+endif
 
 ASONLYFLAGS =								\
 	-c								\
-	-g								\
-	--debug-prefix-map='$(PWD)'=
+	-g
 
 DEFAULT_LDLIBS =
 
@@ -279,40 +338,31 @@ LD.libs =								\
 	$(CONFIG_LIBS)							\
 	$(LIBS)
 
-COMPILE.c.flags = $(cc.flags) $(cpp.flags) $(copt.flags) $(c.flags)
-COMPILE.cxx.flags = $(cc.flags) $(cpp.flags) $(copt.flags) $(cxx.flags)
-COMPILE.f.flags = $(cc.flags) $(copt.flags) $(f.flags)
-COMPILE.F.flags = $(cc.flags) $(cpp.flags) $(copt.flags) $(f.flags)
+COMPILE.c.flags = $(cc.flags) $(copt.flags) $(cpp.flags) $(c.flags)
+COMPILE.cxx.flags = $(cc.flags) $(copt.flags) $(cpp.flags) $(cxx.flags)
 COMPILE.i.flags = $(cc.flags) $(copt.flags) $(c.flags)
 COMPILE.ii.flags = $(cc.flags) $(copt.flags) $(cxx.flags)
 LINK.flags = $(DEFAULT_LDFLAGS) $(CONFIG_LDFLAGS) $(LDFLAGS)
-OBJECTIFY.c.flags = $(OBJECTIFY.S.flags) $(copt.flags) $(c.flags)
-OBJECTIFY.cxx.flags = $(OBJECTIFY.S.flags) $(copt.flags) $(cxx.flags)
+OBJECTIFY.c.flags = $(cc.flags) $(o.flags) $(S.flags) $(cpp.flags) $(copt.flags) $(c.flags)
+OBJECTIFY.cxx.flags = $(cc.flags) $(o.flags) $(S.flags) $(cpp.flags) $(copt.flags) $(cxx.flags)
 OBJECTIFY.s.flags = $(ASONLYFLAGS) $(s.flags)
-OBJECTIFY.S.flags = $(copt.flags) $(cc.flags) $(o.flags) $(cpp.flags) $(S.flags)
-OBJECTIFY.f.flags = $(copt.flags) $(cc.flags) $(o.flags) $(copt.flags) $(S.flags) $(f.flags)
-OBJECTIFY.F.flags = $(OBJECTIFY.f.flags) $(cpp.flags)
+OBJECTIFY.S.flags = $(cc.flags) $(o.flags) $(S.flags) $(cpp.flags)
 PREPROCESS.flags = -E $(copt.flags) $(cc.flags) $(cpp.flags)
 PREPROCESS.lds.flags = -D__LINKER__ $(filter-out -g%,$(PREPROCESS.flags)) -P -xc
 
 COMPILE.c = $(CC) -S $(COMPILE.c.flags)
 COMPILE.cxx = $(CXX) -S $(COMPILE.cxx.flags)
 COMPILE.i = $(CC) -S $(COMPILE.i.flags)
-COMPILE.f = $(FC) -S $(COMPILE.f.flags)
-COMPILE.F = $(FC) -S $(COMPILE.F.flags)
 OBJECTIFY.s = $(AS) $(OBJECTIFY.s.flags)
 OBJECTIFY.S = $(CC) $(OBJECTIFY.S.flags) -c
-OBJECTIFY.f = $(FC) $(OBJECTIFY.f.flags) -c
-OBJECTIFY.F = $(FC) $(OBJECTIFY.F.flags) -c
 OBJECTIFY.c = $(CC) $(OBJECTIFY.c.flags) -c
 OBJECTIFY.cxx = $(CXX) $(OBJECTIFY.cxx.flags) -c
 PREPROCESS = $(CC) $(PREPROCESS.flags)
 PREPROCESS.lds = $(CC) $(PREPROCESS.lds.flags)
 LINK = $(LD) $(LINK.flags)
 ELF = o/libc/elf/elf.lds
-ELFLINK = $(COMPILE) -ALINK.elf $(LINK) $(LINKARGS) $(OUTPUT_OPTION)
+ELFLINK = $(COMPILE) -ALINK.elf $(LINK) $(LINKARGS) $(OUTPUT_OPTION) && $(COMPILE) -AFIXUP.ape -T$@ $(FIXUPOBJ) $@
 LINKARGS = $(patsubst %.lds,-T %.lds,$(call uniqr,$(LD.libs) $(filter-out %.pkg,$^)))
-LOLSAN = build/lolsan -b $(IMAGE_BASE_VIRTUAL)
 
 # The compiler won't generate %xmm code for sources extensioned .greg.c,
 # which is needed for C modules wanting to run at the executive level or
@@ -327,74 +377,9 @@ OBJECTIFY.greg.c =							\
 	-fno-optimize-sibling-calls					\
 	-fno-sanitize=all						\
 	-ffreestanding							\
-	-mno-fentry							\
 	-fwrapv								\
 	-c
 
-OBJECTIFY.ansi.c = $(CC) $(OBJECTIFY.c.flags) -ansi -Wextra -Werror -pedantic-errors -c
-OBJECTIFY.c99.c = $(CC) $(OBJECTIFY.c.flags) -std=c99 -Wextra -Werror -pedantic-errors -c
-OBJECTIFY.c11.c = $(CC) $(OBJECTIFY.c.flags) -std=c11 -Wextra -Werror -pedantic-errors -c
-OBJECTIFY.c2x.c = $(CC) $(OBJECTIFY.c.flags) -std=c2x -Wextra -Werror -pedantic-errors -c
-
-OBJECTIFY.real.c =							\
-	$(GCC)								\
-	-x-no-pg							\
-	$(OBJECTIFY.c.flags)						\
-	-wrapper build/realify.sh					\
-	-D__REAL_MODE__							\
-	-ffixed-r8							\
-	-ffixed-r9							\
-	-ffixed-r10							\
-	-ffixed-r11							\
-	-ffixed-r12							\
-	-ffixed-r13							\
-	-ffixed-r14							\
-	-ffixed-r15							\
-	-mno-red-zone							\
-	-fcall-used-rbx							\
-	-fno-jump-tables						\
-	-fno-shrink-wrap						\
-	-fno-schedule-insns2						\
-	-flive-range-shrinkage						\
-	-fno-omit-frame-pointer						\
-	-momit-leaf-frame-pointer					\
-	-mpreferred-stack-boundary=3					\
-	-fno-delete-null-pointer-checks					\
-	-c
-
-OBJECTIFY.ncabi.c =							\
-	$(GCC)								\
-	$(OBJECTIFY.c.flags)						\
-	-mno-sse							\
-	-mfpmath=387							\
-	-mno-fentry							\
-	-fno-stack-protector						\
-	-fno-instrument-functions					\
-	-fno-optimize-sibling-calls					\
-	-fno-sanitize=all						\
-	-fcall-saved-rcx						\
-	-fcall-saved-rdx						\
-	-fcall-saved-rdi						\
-	-fcall-saved-rsi						\
-	-fcall-saved-r8							\
-	-fcall-saved-r9							\
-	-fcall-saved-r10						\
-	-fcall-saved-r11						\
-	-c								\
-	-xc
-
-OBJECTIFY.initabi.c =							\
-	$(GCC)								\
-	$(OBJECTIFY.c.flags)						\
-	-mno-fentry							\
-	-fno-stack-protector						\
-	-fno-instrument-functions					\
-	-fno-optimize-sibling-calls					\
-	-fno-sanitize=all						\
-	-fcall-saved-rdi						\
-	-fcall-saved-rsi						\
-	-c
-
 TAGSFLAGS =								\
 	-e								\
 	-a								\

build/functions.mk

@@ -12,5 +12,9 @@
 
 tail = $(wordlist 2,$(words $1),$1)
 reverse = $(if $1,$(call reverse,$(call tail,$1)) $(firstword $1))
-uniq = $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1)))
 uniqr = $(if $1,$(call uniqr,$(filter-out $(firstword $1),$1)) $(firstword $1))
+
+# polyfill uniq native (landlock make 1.4)
+ifneq ($(call uniq,c b c a),c b a)
+uniq = $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1)))
+endif

build/htags

@@ -43,6 +43,9 @@
 #     '(progn
 #        (add-hook 'c-mode-common-hook 'jart-c-mode-common-hook)))
 
+TAGS="$1"
+shift
+
 # ctags doesn't understand atomics, e.g.
 #   extern char **environ;
 set -- --regex-c='/_Atomic(\([^)]*\))/\1/b' "$@"
@@ -63,7 +66,7 @@ set -- --regex-c='/^extern [^(]*(\*const \([^)]*\))(/\1/b' "$@"
 #   struct WorstSoftwareEver;
 set -- --regex-c='/^struct.*;$/uehocruehcroue/b' "$@"
 
-exec ${TAGS:-ctags}                                               \
+exec $TAGS                                                        \
      -e                                                           \
      --langmap=c:.c.h                                             \
      --exclude=libc/nt/struct/imagefileheader.internal.h          \

build/objdump

@@ -0,0 +1,29 @@
+#!/bin/sh
+COSMO=${COSMO:-/opt/cosmo}
+
+if [ -n "$OBJDUMP" ]; then
+  exec "$OBJDUMP" "$@"
+fi
+
+find_objdump() {
+  if [ -x o/third_party/gcc/bin/$1-linux-cosmo-objdump ]; then
+    OBJDUMP=o/third_party/gcc/bin/$1-linux-cosmo-objdump
+  elif [ -x o/third_party/gcc/bin/$1-linux-musl-objdump ]; then
+    OBJDUMP=o/third_party/gcc/bin/$1-linux-musl-objdump
+  elif [ -x "$COSMO/o/third_party/gcc/bin/$1-linux-cosmo-objdump" ]; then
+    OBJDUMP="$COSMO/o/third_party/gcc/bin/$1-linux-cosmo-objdump"
+  elif [ -x "$COSMO/o/third_party/gcc/bin/$1-linux-musl-objdump" ]; then
+    OBJDUMP="$COSMO/o/third_party/gcc/bin/$1-linux-musl-objdump"
+  else
+    echo "error: toolchain not found (try running 'cosmocc --update' or 'make' in the cosmo monorepo)" >&2
+    exit 1
+  fi
+}
+
+if printf '%s\n' "$*" | grep aarch64 >/dev/null 2>&1; then
+  find_objdump aarch64
+  exec "$OBJDUMP" "$@"
+else
+  find_objdump x86_64
+  exec "$OBJDUMP" "$@"
+fi