Fully support old windows 8ib user space virtual memory

Addresses are converted in blocks(asan, automap, stack, ...), with the start and end addresses modified using (address & 0xffffff) | ((address >> 28) << 24).

Following addresses are only specified to frame accuracy with the last 4 hex digits chopped off.
null, loader, image and arena blocks have not been modified.
asan     [0x00007fff, 0x10007fff] ⇒ [0x00007fff, 0x01007fff] Not currently supported.
automap  [0x10008004, 0x1fe7fffb] ⇒ [0x01008004, 0x01e7fffb]
_mmi     [0x1fe7fffc, 0x1ffffffb] ⇒ [0x01e7fffc, 0x01fffffb] Listed as memtrack outside of the memtrack files.
fixedmap [0x30000004, 0x40000003] ⇒ [0x03000004, 0x04000003]
nsync    [0x6fc00004, 0x6fcffffb] ⇒ [0x06c00004, 0x06cffffb]
zipos    [0x6fd00004, 0x6fdffffb] ⇒ [0x06d00004, 0x06dffffb] I don't think this is used currently on the vista branch.
g_fds    [0x6fe00004, 0x6feffffb] ⇒ [0x06e00004, 0x06effffb]
winargs  [0x6ffffffe, 0x6fffffff] ⇒ [0x06fffffe, 0x06ffffff] Not entirely confident on if this is accurate.
stack    [0x70000000, 0x70000003] ⇒ [0x07000000, 0x07000003] Not entirely confident on if this is accurate.

This map is documented in memtrack64-8tib.txt with the original 128tib version renamed to memtrack64-128tib.txt.

Modified windows 8.1 check macro name to match existing windows 10 one.
Modified IsShadowFrame to correctly identify the asan block on old windows. Required as the asan block on 128tib virtual memory systems is larger than 2^43 - 1 and so all blocks were reporting as asan.

.clang-format

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

.gitattributes

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

.github/workflows/build.yml

@@ -4,10 +4,12 @@ on:
   push:
     branches:
       - "master"
+      - "vista"
       - "flake"
   pull_request:
     branches:
       - "master"
+      - "vista"
 
   # run workflow manually from the Actions tab
   workflow_dispatch:
@@ -17,15 +19,12 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        mode: ["", tiny, rel, tinylinux, optlinux]
+        mode: ["", tiny, opt, rel]
     steps:
       - uses: actions/checkout@v3
 
-      - name: support ape bins 1
-        run: sudo cp build/bootstrap/ape.elf /usr/bin/ape
-
-      - name: support ape bins 2
-        run: sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
+      - name: support ape bins
+        run: sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
 
       - name: make matrix
         run: V=0 make -j2 MODE=${{ matrix.mode }}

.gitignore

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

.vscode/c_cpp_properties.json

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

Makefile

@@ -60,51 +60,17 @@
 #   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 aarch64 clean
+.PHONY: all o bins check test depend tags
 
-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.12.zip and unzip it inside the cosmo directory)
-endif
-endif
-endif
-
-# the default build modes is empty string
-# on x86_64 hosts, MODE= is the same as MODE=x86_64
-# on aarch64 hosts, MODE= is changed to MODE=aarch64
-ifeq ($(MODE),)
-ifeq ($(UNAME_M),arm64)
-MODE := aarch64
-endif
-ifeq ($(UNAME_M),aarch64)
-MODE := aarch64
-endif
-endif
-
-# primary build rules
 all:	o
 o:	o/$(MODE)
+
 o/$(MODE):			\
 	o/$(MODE)/ape		\
 	o/$(MODE)/dsp		\
@@ -115,39 +81,19 @@ 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
-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	\
+.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		\
+	/proc/self/status	\
 	/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
 
 PKGS =
@@ -157,64 +103,56 @@ 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 build/online.mk				# │
+include libc/stubs/stubs.mk			#─┘
 include libc/nexgen32e/nexgen32e.mk		#─┐
 include libc/sysv/sysv.mk			# ├──SYSTEM SUPPORT
 include libc/nt/nt.mk				# │  You can do math
 include libc/intrin/intrin.mk			# │  You can use the stack
-include third_party/compiler_rt/compiler_rt.mk	# │  You can manipulate arrays
+include libc/linux/linux.mk			# │  You can manipulate arrays
 include libc/tinymath/tinymath.mk		# │  You can issue raw system calls
+include third_party/compiler_rt/compiler_rt.mk	# │
 include libc/str/str.mk				# │
 include third_party/xed/xed.mk			# │
-include third_party/puff/puff.mk		# │
+include third_party/zlib/zlib.mk		# │
 include libc/elf/elf.mk				# │
 include ape/ape.mk				# │
 include libc/fmt/fmt.mk				# │
 include libc/vga/vga.mk				#─┘
 include libc/calls/calls.mk			#─┐
-include third_party/nsync/nsync.mk		# │
 include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
-include third_party/double-conversion/dc.mk	# │  You can issue system calls
-include libc/crt/crt.mk				# │
+include libc/crt/crt.mk				# │  You can issue system calls
+include third_party/nsync/nsync.mk		# │
 include third_party/dlmalloc/dlmalloc.mk	#─┘
 include libc/mem/mem.mk				#─┐
-include third_party/gdtoa/gdtoa.mk		# ├──DYNAMIC RUNTIME
-include third_party/nsync/mem/mem.mk		# │  You can now use stdio
-include libc/proc/proc.mk			# │  You can now use threads
-include libc/thread/thread.mk			# │  You can now use processes
-include tool/hello/hello.mk			# │  You can finally call malloc()
-include third_party/zlib/zlib.mk		# │
+include libc/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 libc/stdio/stdio.mk			# │
-include libc/time/time.mk			# │
+include third_party/libcxx/libcxx.mk		# │
 include net/net.mk				# │
-include third_party/vqsort/vqsort.mk		# │
 include libc/log/log.mk				# │
-include third_party/getopt/getopt.mk		# │
 include third_party/bzip2/bzip2.mk		# │
 include dsp/core/core.mk			# │
-include third_party/musl/musl.mk		# │
 include libc/x/x.mk				# │
 include third_party/stb/stb.mk			# │
 include dsp/scale/scale.mk			# │
 include dsp/mpeg/mpeg.mk			# │
 include dsp/dsp.mk				# │
 include third_party/zlib/gz/gz.mk		# │
-include third_party/intel/intel.mk		# │
-include third_party/aarch64/aarch64.mk		# │
+include third_party/musl/musl.mk		# │
+include third_party/getopt/getopt.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
@@ -222,16 +160,11 @@ include test/tool/args/test.mk
 include third_party/linenoise/linenoise.mk
 include third_party/maxmind/maxmind.mk
 include net/finger/finger.mk
-include third_party/double-conversion/test/test.mk
+include third_party/double-conversion/double-conversion.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
@@ -240,15 +173,14 @@ 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
@@ -259,10 +191,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
@@ -279,8 +211,8 @@ include test/libc/xed/test.mk
 include test/libc/fmt/test.mk
 include test/libc/dns/test.mk
 include test/libc/time/test.mk
-include test/libc/proc/test.mk
 include test/libc/stdio/test.mk
+include test/libc/zipos/test.mk
 include test/libc/release/test.mk
 include test/libc/test.mk
 include test/net/http/test.mk
@@ -319,119 +251,115 @@ 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)))) $(SRCS)
+o/$(MODE)/srcs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
 	$(file >$@,$(SRCS))
-o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x)))) $(HDRS) $(INCS)
+o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
 	$(file >$@,$(HDRS) $(INCS))
-o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x)))) $(INCS) $(INCS)
+o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x))))
 	$(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: private .UNSANDBOXED = 1
-TAGS:	o/$(MODE)/srcs-old.txt $(SRCS) #o/$(MODE)/third_party/ctags/ctags.com
+TAGS: .UNSANDBOXED = 1
+TAGS:	o/$(MODE)/srcs-old.txt $(SRCS)
 	@$(RM) $@
-	@o/$(MODE)/third_party/ctags/ctags.com $(TAGSFLAGS) -L $< -o $@
+	@$(TAGS) $(TAGSFLAGS) -L $< -o $@
 
-HTAGS: private .UNSANDBOXED = 1
-HTAGS:	o/$(MODE)/hdrs-old.txt $(filter-out third_party/libcxx/%,$(HDRS)) #o/$(MODE)/third_party/ctags/ctags.com
+HTAGS: .UNSANDBOXED = 1
+HTAGS:	o/$(MODE)/hdrs-old.txt $(HDRS)
 	@$(RM) $@
-	@build/htags o/$(MODE)/third_party/ctags/ctags.com -L $< -o $@
+	@build/htags -L $< -o $@
 
-loc: private .UNSANDBOXED = 1
+loc: .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}' | $<
 
-# 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_RUNTIME			\
-	THIRD_PARTY_NSYNC		\
-	LIBC_ELF			\
-	LIBC_CALLS			\
-	LIBC_SYSV_CALLS			\
-	LIBC_VGA			\
-	LIBC_NT_PSAPI			\
-	LIBC_NT_POWRPROF		\
-	LIBC_NT_PDH			\
-	LIBC_NT_GDI32			\
-	LIBC_NT_COMDLG32		\
-	LIBC_NT_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_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		\
+	THIRD_PARTY_NSYNC	\
+	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	\
+	LIBC_NEXGEN32E		\
+	LIBC_VGA
 
-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		\
+COSMOPOLITAN_HEADERS =		\
+	APE			\
+	LIBC			\
+	LIBC_CALLS		\
+	LIBC_DNS		\
+	LIBC_ELF		\
+	LIBC_FMT		\
+	LIBC_INTRIN		\
+	LIBC_LOG		\
+	LIBC_MEM		\
+	LIBC_NEXGEN32E		\
+	LIBC_NT			\
+	LIBC_RUNTIME		\
+	LIBC_SOCK		\
+	LIBC_STDIO		\
+	THIRD_PARTY_NSYNC	\
+	THIRD_PARTY_XED		\
+	LIBC_STR		\
+	LIBC_SYSV		\
+	LIBC_THREAD		\
+	LIBC_TIME		\
+	LIBC_TINYMATH		\
+	LIBC_X			\
+	LIBC_ZIPOS		\
+	LIBC_VGA		\
+	NET_HTTP		\
+	THIRD_PARTY_DLMALLOC	\
+	THIRD_PARTY_GDTOA	\
+	THIRD_PARTY_GETOPT	\
+	THIRD_PARTY_MUSL	\
+	THIRD_PARTY_ZLIB	\
+	THIRD_PARTY_ZLIB_GZ	\
 	THIRD_PARTY_REGEX
 
-o/$(MODE)/cosmopolitan.a:		\
+o/$(MODE)/cosmopolitan.a:	\
 		$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS))
 
 o/cosmopolitan.h:							\
@@ -440,12 +368,9 @@ 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)))
-	@$(ECHO) '#ifndef __STRICT_ANSI__' >$@
-	@$(ECHO) '#define _COSMO_SOURCE' >>$@
-	@$(ECHO) '#endif' >>$@
-	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >>$@
+	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >$@
 
-o/cosmopolitan.html: private .UNSANDBOXED = 1
+o/cosmopolitan.html: .UNSANDBOXED = 1
 o/cosmopolitan.html:							\
 		o/$(MODE)/third_party/chibicc/chibicc.com.dbg		\
 		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))	\
@@ -454,7 +379,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 $@	\
-		-DCOSMO @$(TMPDIR)/$(subst /,_,$@)
+		@$(TMPDIR)/$(subst /,_,$@)
 
 $(SRCS):					\
 	libc/integral/normalize.inc		\
@@ -464,51 +389,6 @@ $(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
@@ -533,9 +413,9 @@ $(SRCS):
 $(HDRS):
 $(INCS):
 .DEFAULT:
-	@$(ECHO)
-	@$(ECHO) NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@
-	@$(ECHO)
+	@$(ECHO) >&2
+	@$(ECHO) NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@ >&2
+	@$(ECHO) >&2
 	$(RM) o/$(MODE)/depend
 
 -include o/$(MODE)/depend

README.md

@@ -1,7 +1,10 @@
 ![Cosmopolitan Honeybadger](usr/share/img/honeybadger.png)
 
 [![build](https://github.com/jart/cosmopolitan/actions/workflows/build.yml/badge.svg)](https://github.com/jart/cosmopolitan/actions/workflows/build.yml)
-# Cosmopolitan
+# Cosmopolitan (Vista Edition)
+
+**This is a community supported legacy branch of Cosmopolitan 2.0 that's
+intended to preserve compatibility with Windows Vista and Windows 7.**
 
 [Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C
 a build-once run-anywhere language, like Java, except it doesn't need an
@@ -19,415 +22,16 @@ libc](https://justine.lol/cosmopolitan/index.html) website. We also have
 
 ## Getting Started
 
-It's recommended that Cosmopolitan be installed to `/opt/cosmo` and
-`/opt/cosmos` on your computer. The first has the monorepo. The second
-contains your non-monorepo artifacts.
+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
-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.zip
-unzip cosmopolitan-amalgamation-3.0.zip
+wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-2.0.1.zip
+unzip cosmopolitan-amalgamation-2.0.1.zip
 printf 'main() { printf("hello world\\n"); }\n' >hello.c
 gcc -g -Os -static -nostdlib -nostdinc -fno-pie -no-pie -mno-red-zone \
-  -fno-omit-frame-pointer -pg -mnop-mcount -mno-tls-direct-seg-refs -gdwarf-4 \
+  -fno-omit-frame-pointer -pg -mnop-mcount -mno-tls-direct-seg-refs \
   -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
 ```
@@ -436,7 +40,7 @@ You now have a portable program.
 
 ```sh
 ./hello.com
-bash -c './hello.com'  # older zsh/fish workaround (patched in zsh 5.9 and fish 3.3.0)
+bash -c './hello.com'  # zsh/fish workaround (we patched them in 2021)
 ```
 
 If `./hello.com` executed on Linux throws an error about not finding an
@@ -456,24 +60,20 @@ sudo sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/status'
 
 Since we used the `ape-no-modify-self.o` bootloader (rather than
 `ape.o`) your executable will not modify itself when it's run. What
-it'll instead do, is extract a 4kb program (the [APE loader](https://justine.lol/apeloader/))
-to `${TMPDIR:-${HOME:-.}}` that maps your program into memory without
-needing to copy it. The APE loader must be in an executable location
-(e.g. not stored on a `noexec` mount) for it to run. See below for
-alternatives:
-
-It's possible to install the APE loader systemwide as follows.
+it'll instead do, is extract a 4kb program to `${TMPDIR:-${HOME:-.}}`
+that maps your program into memory without needing to copy it. It's
+possible to install the APE loader systemwide as follows.
 
 ```sh
 # System-Wide APE Install
 # for Linux, Darwin, and BSDs
 # 1. Copies APE Loader to /usr/bin/ape
 # 2. Registers w/ binfmt_misc too if Linux
-bin/ape-install
+ape/apeinstall.sh
 
 # System-Wide APE Uninstall
 # for Linux, Darwin, and BSDs
-bin/ape-uninstall
+ape/apeuninstall.sh
 ```
 
 It's also possible to convert APE binaries into the system-local format
@@ -503,7 +103,7 @@ heavyweight features like tracing to your binaries by default. In that
 case, you may want to consider using our build system:
 
 ```sh
-make m=tiny
+make -j8 MODE=tiny
 ```
 
 Which will cause programs such as `hello.com` and `life.com` to shrink
@@ -511,6 +111,105 @@ from 60kb in size to about 16kb. There's also a prebuilt amalgamation
 online <https://justine.lol/cosmopolitan/cosmopolitan-tiny.zip> hosted
 on our download page <https://justine.lol/cosmopolitan/download.html>.
 
+### MacOS
+
+If you're developing on MacOS you can install the GNU compiler
+collection for x86_64-elf via homebrew:
+
+```sh
+brew install x86_64-elf-gcc
+```
+
+Then in the above scripts just replace `gcc` and `objcopy` with
+`x86_64-elf-gcc` and `x86_64-elf-objcopy` to compile your APE binary.
+
+### Windows
+
+If you're developing on Windows then you need to download an
+x86_64-pc-linux-gnu toolchain beforehand. See the [Compiling on
+Windows](https://justine.lol/cosmopolitan/windows-compiling.html)
+tutorial. It's needed because the ELF object format is what makes
+universal binaries possible.
+
+Cosmopolitan officially only builds on Linux. However, one highly
+experimental (and currently broken) thing you could try, is building the
+entire cosmo repository from source using the cross9 toolchain.
+
+```
+mkdir -p o/third_party
+rm -rf o/third_party/gcc
+wget https://justine.lol/linux-compiler-on-windows/cross9.zip
+unzip cross9.zip
+mv cross9 o/third_party/gcc
+build/bootstrap/make.com
+```
+
+## 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 -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:
@@ -538,77 +237,31 @@ src
 You normally run the `.com.dbg` file under gdb. If you need to debug the
 `.com` file itself, then you can load the debug symbols independently as
 
-```sh
+```
 gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
 ```
 
-## Alternative Development Environments
-
-### MacOS
-
-If you're developing on MacOS you can install the GNU compiler
-collection for x86_64-elf via homebrew:
-
-```sh
-brew install x86_64-elf-gcc
-```
-
-Then in the above scripts just replace `gcc` and `objcopy` with
-`x86_64-elf-gcc` and `x86_64-elf-objcopy` to compile your APE binary.
-
-### Windows
-
-If you're developing on Windows then you need to download an
-x86_64-pc-linux-gnu toolchain beforehand. See the [Compiling on
-Windows](https://justine.lol/cosmopolitan/windows-compiling.html)
-tutorial. It's needed because the ELF object format is what makes
-universal binaries possible.
-
-Cosmopolitan officially only builds on Linux. However, one highly
-experimental (and currently broken) thing you could try, is building the
-entire cosmo repository from source using the cross9 toolchain.
-
-```sh
-mkdir -p o/third_party
-rm -rf o/third_party/gcc
-wget https://justine.lol/linux-compiler-on-windows/cross9.zip
-unzip cross9.zip
-mv cross9 o/third_party/gcc
-build/bootstrap/make.com
-```
-
-## Discord Chatroom
-
-The Cosmopolitan development team collaborates on the Redbean Discord
-server. You're welcome to join us! <https://discord.gg/FwAVVu7eJ4>
-
 ## Support Vector
 
 | Platform        | Min Version | Circa |
 | :---            | ---:        | ---:  |
 | 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 groups and individuals:
+the following 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

@@ -1,294 +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│
-╚─────────────────────────────────────────────────────────────────────────────*/
-#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

@@ -1,13 +0,0 @@
-#ifndef COSMOPOLITAN_APE_APE_H_
-#define COSMOPOLITAN_APE_APE_H_
-
-#define APE_VERSION_MAJOR 1
-#define APE_VERSION_MINOR 8
-#define APE_VERSION_STR   APE_VERSION_STR_(APE_VERSION_MAJOR, APE_VERSION_MINOR)
-#define APE_VERSION_NOTE  APE_VERSION_NOTE_(APE_VERSION_MAJOR, APE_VERSION_MINOR)
-
-#define APE_VERSION_STR__(x, y) #x "." #y
-#define APE_VERSION_STR_(x, y)  APE_VERSION_STR__(x, y)
-#define APE_VERSION_NOTE_(x, y) (100000000 * (x) + 1000000 * (y))
-
-#endif /* COSMOPOLITAN_APE_APE_H_ */

ape/ape.internal.h

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

ape/ape.lds

@@ -181,39 +181,16 @@
 #include "libc/elf/pf2prot.internal.h"
 #include "libc/nt/pedef.internal.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
+#include "libc/zip.h"
 
 ENTRY(_start)
 
 PHDRS {
   Head PT_LOAD FLAGS(PF_X|PF_R);
-  Cod PT_LOAD FLAGS(PF_X|PF_R);
-  Rom PT_LOAD FLAGS(PF_R);
-  Tls PT_TLS FLAGS(PF_W|PF_R);
+  Rom PT_LOAD FLAGS(PF_X|PF_R);
   Ram PT_LOAD FLAGS(PF_W|PF_R);
+  Tls PT_TLS FLAGS(PF_W|PF_R);
+  Bss PT_LOAD FLAGS(PF_W|PF_R);
   stack PT_GNU_STACK FLAGS(PF_W|PF_R);
 }
 
@@ -224,49 +201,42 @@ SECTIONS {
 /*BEGIN: linux addressability guarantee */
 /*BEGIN: bsd addressability guarantee */
 
-  .head SEGMENT_START("text-segment", IMAGE_BASE_VIRTUAL) + SKEW : AT(IMAGE_BASE_REAL) {
-    __executable_start = .;
+  .head SEGMENT_START("text-segment", IMAGE_BASE_VIRTUAL) : AT(IMAGE_BASE_REAL) {
+    HIDDEN(_base = .);
 
     /* Real Mode */
     KEEP(*(.head))
     KEEP(*(.apesh))
+    KEEP(*(.head2))
     KEEP(*(.text.head))
 
     /* Executable & Linkable Format */
-    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
-    ape_phdrs = .;
+    . = ALIGN(__SIZEOF_POINTER__);
+    HIDDEN(ape_phdrs = .);
     KEEP(*(.elf.phdrs))
-    ape_phdrs_end = .;
-
-    KEEP(*(.emushprologue))
-    KEEP(*(.emush))
-    KEEP(*(.emushepilogue))
+    HIDDEN(ape_phdrs_end = .);
 
     /* OpenBSD */
-    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
-    ape_note = .;
+    . = ALIGN(__SIZEOF_POINTER__);
+    HIDDEN(ape_note = .);
     KEEP(*(.note.openbsd.ident))
     KEEP(*(.note.netbsd.ident))
-    ape_note_end = .;
+    HIDDEN(ape_note_end = .);
 
     /* Portable Executable */
     KEEP(*(.pe.header))
-    ape_pe_sections = .;
+    HIDDEN(ape_pe_sections = .);
     KEEP(*(.pe.sections))
-    ape_pe_sections_end = .;
+    HIDDEN(ape_pe_sections_end = .);
 
     /* Mach-O */
     KEEP(*(.macho))
-    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
-    ape_macho_end = .;
-
-    /* APE loader */
-    KEEP(*(.ape.loader))
-    . = ALIGN(. != 0 ? CODE_GRANULE : 0);
+    . = ALIGN(__SIZEOF_POINTER__);
+    HIDDEN(ape_macho_end = .);
 
     KEEP(*(.ape.pad.head))
-    . = ALIGN(. != 0 ? (SupportsWindows() || SupportsMetal() ? CONSTANT(COMMONPAGESIZE) : 16) : 0);
-    _ehead = .;
+    . = ALIGN(SupportsWindows() || SupportsMetal() ? PAGESIZE : 16);
+    HIDDEN(_ehead = .);
   } :Head
 
 /*BEGIN: nt addressability guarantee */
@@ -276,10 +246,12 @@ SECTIONS {
     /* Code that needs to be addressable in Real Mode */
     *(.text.real)
     KEEP(*(SORT_BY_NAME(.sort.text.real.*)))
-    _ereal = .;
+    /* Code we want earlier in the binary w/o modifications */
+    KEEP(*(.ape.loader))
+    HIDDEN(_ereal = .);
 /*END: realmode addressability guarantee */
 /*BEGIN: morphable code */
-    . += CODE_GRANULE;
+    . += 1;
 
     /* Normal Code */
     *(.start)
@@ -301,7 +273,6 @@ SECTIONS {
     KEEP(*(.textwindowsprologue))
     *(.text.windows)
     KEEP(*(.textwindowsepilogue))
-    KEEP(*(.blink))
     *(SORT_BY_ALIGNMENT(.text.modernity))
     *(SORT_BY_ALIGNMENT(.text.modernity.*))
     *(SORT_BY_ALIGNMENT(.text.hot))
@@ -309,6 +280,7 @@ SECTIONS {
     KEEP(*(.keep.text))
     *(.text .stub .text.*)
     KEEP(*(SORT_BY_NAME(.sort.text.*)))
+    *(.subrs)
 
     KEEP(*(.ape.pad.test));
     *(.test.unlikely)
@@ -316,20 +288,17 @@ SECTIONS {
 
     /* Privileged code invulnerable to magic */
     KEEP(*(.ape.pad.privileged));
-    . = ALIGN(__privileged_end > __privileged_start ? CONSTANT(COMMONPAGESIZE) : 0);
+    . += . > 0 ? 1 : 0;
 /*END: morphable code */
-    __privileged_start = .;
+    HIDDEN(__privileged_start = .);
+    . += . > 0 ? 1 : 0;
     *(.privileged)
-    __privileged_end = .;
-
-    KEEP(*(.ape.pad.text))
-    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
-/*END: Read Only Data (only needed for initialization) */
-  } :Cod
+    HIDDEN(__privileged_end = .);
+    . += . > 0 ? 1 : 0;
 
 /*BEGIN: Read Only Data */
 
-  .rodata . : {
+    KEEP(*(.ape.pad.rodata));
     KEEP(*(.rodata.pytab.0));
     KEEP(*(.rodata.pytab.1));
     KEEP(*(.rodata.pytab.2));
@@ -338,6 +307,10 @@ 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))
@@ -345,64 +318,48 @@ 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.*)))
-#endif
+
+    . = 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 = .);
 
     /* 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
 
-/* 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 . : {
+  .data ALIGN(PAGESIZE) : {
 /*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 ? CODE_GRANULE : 0;
+    . += . > 0 ? 1 : 0;
 
     KEEP(*(.gotprologue))
     *(.got)
@@ -412,51 +369,53 @@ 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(. != 0 ? __SIZEOF_POINTER__ : 0);
+    . = ALIGN(__SIZEOF_POINTER__);
     KEEP(*(SORT_BY_NAME(.piro.relo.sort.*)))
-    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
+    PROVIDE_HIDDEN(__relo_end = .);
+    . = ALIGN(__SIZEOF_POINTER__);
     KEEP(*(SORT_BY_NAME(.piro.data.sort.*)))
     KEEP(*(.piro.pad.data))
     KEEP(*(.dataepilogue))
-    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
 /*END: NT FORK COPYING */
-    _edata = .;
-    PROVIDE(edata = .);
-    _ezip = .; /* <-- very deprecated */
+    HIDDEN(_edata = .);
+    PROVIDE_HIDDEN(edata = .);
+    KEEP(*(SORT_BY_NAME(.zip.*)))
+    HIDDEN(_ezip = .);
+    . = ALIGN(PAGESIZE);
   } :Ram
 
-  . = ALIGN(CONSTANT(COMMONPAGESIZE));
+  .tdata . : {
+    _tdata_start = .;
+    *(SORT_BY_ALIGNMENT(.tdata))
+    *(SORT_BY_ALIGNMENT(.tdata.*))
+    _tdata_end = .;
+    . = ALIGN(PAGESIZE);
+  } :Tls :Ram
 
 /*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(TLS_ALIGNMENT);
+    /* the %fs register is based on this location */
+    _tbss_end = .;
+  } :Tls
+
 /*END:   file content */
 /*BEGIN: bss memory that's addressable */
 
-  .bss : {
+  .bss ALIGN(64) : {
 /*BEGIN: NT FORK COPYING */
     KEEP(*(.bssprologue))
     KEEP(*(SORT_BY_NAME(.piro.bss.init.*)))
     *(.piro.bss)
     KEEP(*(SORT_BY_NAME(.piro.bss.sort.*)))
-    __piro_end = .;
-    . += . > 0 ? CODE_GRANULE : 0;
+    HIDDEN(__piro_end = .);
+    . += . > 0 ? 1 : 0;
 /*END: Post-Initialization Read-Only */
 
     /* Statically Allocated Empty Space */
@@ -467,15 +426,11 @@ SECTIONS {
     KEEP(*(SORT_BY_NAME(.sort.bss.*)))
 
     KEEP(*(.bssepilogue))
-
-    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
-
 /*END: NT FORK COPYING */
-  } :Ram
-
-  . = ALIGN(CONSTANT(COMMONPAGESIZE));
-  _end = .;
-  PROVIDE(end = .);
+    . = ALIGN(FRAMESIZE); /* for brk()/sbrk() allocation */
+    HIDDEN(_end = .);
+    PROVIDE_HIDDEN(end = .);
+  } :Bss
 
 /*END: nt addressability guarantee */
 /*END: bsd addressability guarantee */
@@ -503,7 +458,6 @@ 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) }
@@ -512,38 +466,19 @@ 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);
@@ -551,58 +486,70 @@ PFSTUB4(ape_elf_phnum, (ape_phdrs_end - ape_phdrs) / 56);
 PFSTUB4(ape_elf_shnum, 0);
 PFSTUB4(ape_elf_shstrndx, 0);
 
-_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(_tls_size = _tbss_end - _tdata_start);
+HIDDEN(_tdata_size = _tdata_end - _tdata_start);
+HIDDEN(_tbss_size = _tbss_end - _tbss_start);
+HIDDEN(_tbss_offset = _tbss_start - _tdata_start);
+HIDDEN(_tls_content = (_tdata_end - _tdata_start) + (_tbss_end - _tbss_start));
 
-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(__privileged_addr = ROUNDDOWN(__privileged_start, PAGESIZE));
+HIDDEN(__privileged_size = (ROUNDUP(__privileged_end, PAGESIZE) -
+                            ROUNDDOWN(__privileged_start, PAGESIZE)));
 
-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_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_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_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_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_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_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_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_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);
+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);
 
 /* 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 */
@@ -610,42 +557,29 @@ ape_text_rva = RVA(ape_text_vaddr);
 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, CONSTANT(COMMONPAGESIZE)) / 64
+            ? ROUNDUP(ape_loader_end - ape_loader, PAGESIZE) / 64
             : 0);
 
-#if defined(APE_IS_SHELL_SCRIPT) && !IsTiny()
-
-#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);
+HIDDEN(v_ape_realsectors =
+           MIN(0x70000 - IMAGE_BASE_REAL,
+               ROUNDUP(RVA(_edata), 4096)) / 512);
+HIDDEN(v_ape_realslacksectors =
+           v_ape_realsectors - MIN(0x70000 - IMAGE_BASE_REAL,
+                                   ROUNDUP(RVA(_edata), 512)) / 512);
+HIDDEN(v_ape_realpages = v_ape_realsectors / (4096 / 512));
+HIDDEN(v_ape_highsectors =
+           (ROUNDUP(RVA(_edata), 512) / 512) - v_ape_realsectors);
 #endif
 
+/* ZIP End of Central Directory header */
+#define ZIPCONST(NAME, VAL) HIDDEN(NAME = DEFINED(__zip_start) ? VAL : 0);
+ZIPCONST(v_zip_cdoffset, __zip_start - IMAGE_BASE_VIRTUAL);
+ZIPCONST(v_zip_cdirsize, __zip_end - __zip_start);
+ASSERT(v_zip_cdirsize % kZipCdirHdrLinkableSize == 0, "bad zip cdir");
+ZIPCONST(v_zip_records, v_zip_cdirsize / kZipCdirHdrLinkableSize);
+ZIPCONST(v_zip_commentsize, _ezip - __zip_end - kZipCdirHdrMinSize);
+
 #if SupportsXnu()
 /* Generates deterministic ID. */
 #define PHI 0x9e3779b9925d4c17
@@ -664,8 +598,19 @@ TSSDESCSTUB2(_tss, _tss, _tss_end ? _tss_end - _tss - 1 : 0);
   KMH(ape_uuid1, X);      \
   XORSHIFT(ape_uuid2, X); \
   KMH(ape_uuid2, X)
-ape_uuid1 = 88172645463325252;
-ape_uuid2 = 88172645463325252;
+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);
 CHURN(ape_elf_entry);
 CHURN(ape_elf_phnum);
 CHURN(ape_elf_phoff);
@@ -674,10 +619,13 @@ 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);
@@ -691,14 +639,7 @@ CHURN(ape_rom_memsz);
 CHURN(ape_rom_offset);
 CHURN(ape_rom_paddr);
 CHURN(ape_rom_rva);
-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_rom_vaddr);
 CHURN(ape_text_align);
 CHURN(ape_text_filesz);
 CHURN(ape_text_memsz);
@@ -710,7 +651,7 @@ CHURN(ADDR(.bss));
 CHURN(_start);
 CHURN(ape_phdrs);
 #if SupportsMetal()
-CHURN(v_ape_allsectors);
+CHURN(v_ape_realsectors);
 #endif
 #if SupportsXnu()
 CHURN(ape_macho);
@@ -731,23 +672,22 @@ CHURN(WinMain);
 #if SupportsWindows() || SupportsMetal()
 #define LINK_WINDOWS (SupportsWindows() && !DEFINED(EfiMain))
 PFSTUB4(ape_pe_offset, ape_pe - ape_mz);
-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;
+HIDDEN(ape_pe_optsz = ape_pe_sections - (ape_pe + 24));
+HIDDEN(ape_pe_shnum = (ape_pe_sections_end - ape_pe_sections) / 40);
+HIDDEN(ape_pe_base = IMAGE_BASE_VIRTUAL);
+HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_iat) : 0);
+HIDDEN(ape_idata_iatsize = LINK_WINDOWS ? ape_idata_iatend - ape_idata_iat : 0);
+HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_idt) : 0);
+HIDDEN(ape_idata_idtsize = LINK_WINDOWS ? ape_idata_idtend - ape_idata_idt : 0);
+HIDDEN(v_ntversion = LINK_WINDOWS ? 6 : 1);
+HIDDEN(v_ntdllchar = LINK_WINDOWS ? 288 : 0);
+HIDDEN(v_ntsubversion = LINK_WINDOWS ? 6 : 5);
+HIDDEN(v_ntsubsystem = (LINK_WINDOWS
+                        ? (DEFINED(GetMessage)
+                           ? kNtImageSubsystemWindowsGui
+                           : kNtImageSubsystemWindowsCui)
+                        : kNtImageSubsystemEfiApplication));
+HIDDEN(ape_pe_entry = LINK_WINDOWS ? WinMain : EfiMain);
 #endif
 
 #if SupportsXnu()
@@ -765,17 +705,21 @@ 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 == 0,
-       "ape_stack_vaddr must have ape_stack_memsz alignment; try using STATIC_STACK_ADDR(0x700000040000 & -ape_stack_memsz);");
+       "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,108 +15,9 @@
 
 PKGS += APE
 
-APE_FILES := $(wildcard ape/*.*)
-APE_HDRS = $(filter %.h,$(APE_FILES))
-APE_INCS = $(filter %.inc,$(APE_FILES))
-
-ifeq ($(ARCH), aarch64)
-
-APE = o/$(MODE)/ape/aarch64.lds
-
-APELINK =					\
-	$(COMPILE)				\
-	-ALINK.ape				\
-	$(LINK)					\
-	$(LINKARGS)				\
-	$(OUTPUT_OPTION) &&			\
-	$(COMPILE)				\
-	-AFIXUP.ape				\
-	-wT$@					\
-	$(FIXUPOBJ)				\
-	$@
-
-APE_SRCS = ape/ape.S ape/start.S ape/launch.S ape/systemcall.S
-APE_OBJS = o/$(MODE)/ape/ape.o
-APE_NO_MODIFY_SELF = $(APE)
-APE_COPY_SELF = $(APE)
-
-.PHONY: o/$(MODE)/ape
-o/$(MODE)/ape: $(APE)
-
-o/$(MODE)/ape/aarch64.lds:			\
-	ape/aarch64.lds				\
-	libc/zip.internal.h			\
-	libc/intrin/bits.h			\
-	libc/thread/tls.h			\
-	libc/calls/struct/timespec.h		\
-	libc/macros.internal.h			\
-	libc/str/str.h
-
-APE_LOADER_LDFLAGS =				\
-	-pie					\
-	-static					\
-	-nostdlib				\
-	--no-dynamic-linker			\
-	-z norelro				\
-	-z common-page-size=0x4000		\
-	-z max-page-size=0x4000
-
-APE_LOADER_FLAGS =				\
-	-DNDEBUG				\
-	-iquote.				\
-	-Wall					\
-	-Wextra					\
-	-fpie					\
-	-Os					\
-	-ffreestanding				\
-	-mgeneral-regs-only			\
-	-fno-asynchronous-unwind-tables		\
-	-fno-stack-protector			\
-	-fno-ident				\
-	-fno-gnu-unique				\
-	-c					\
-	 $(OUTPUT_OPTION)			\
-	$<
-
-o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
-	$(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -g $< $@
-
-o/$(MODE)/ape/ape.elf.dbg:			\
-		o/$(MODE)/ape/start.o		\
-		o/$(MODE)/ape/loader.o		\
-		o/$(MODE)/ape/launch.o		\
-		o/$(MODE)/ape/systemcall.o
-	@$(COMPILE) -ALINK.elf $(LD) $(APE_LOADER_LDFLAGS) -o $@ $(patsubst %.lds,-T %.lds,$^)
-
-o/$(MODE)/ape/loader.o: ape/loader.c ape/ape.h
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=1 -g $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/start.o: ape/start.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/ape/launch.o: ape/launch.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/ape/systemcall.o: ape/systemcall.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-
-.PHONY: o/$(MODE)/ape
-o/$(MODE)/ape: o/$(MODE)/ape/ape.elf
-
-else
-
 APE =	o/$(MODE)/ape/ape.o			\
 	o/$(MODE)/ape/ape.lds
 
-APELINK =					\
-	$(COMPILE)				\
-	-ALINK.ape				\
-	$(LINK)					\
-	$(LINKARGS)				\
-	$(OUTPUT_OPTION) &&			\
-	$(COMPILE)				\
-	-AFIXUP.ape				\
-	-wT$@					\
-	$(FIXUPOBJ)				\
-	$@
-
 APE_NO_MODIFY_SELF =				\
 	o/$(MODE)/ape/ape.lds			\
 	o/$(MODE)/ape/ape-no-modify-self.o
@@ -125,57 +26,92 @@ APE_COPY_SELF =					\
 	o/$(MODE)/ape/ape.lds			\
 	o/$(MODE)/ape/ape-copy-self.o
 
+APELINK =					\
+	$(COMPILE)				\
+	-ALINK.ape				\
+	$(LINK)					\
+	$(LINKARGS)				\
+	$(OUTPUT_OPTION)
+
 APE_LOADER_FLAGS =				\
 	-DNDEBUG				\
 	-iquote.				\
 	-Wall					\
 	-Wextra					\
-	-Werror					\
-	-pedantic-errors			\
 	-fpie					\
 	-Os					\
 	-ffreestanding				\
 	-mgeneral-regs-only			\
-	-fno-stack-protector			\
+	-mno-red-zone				\
 	-fno-ident				\
 	-fno-gnu-unique				\
 	-c					\
 	 $(OUTPUT_OPTION)			\
 	$<
 
+APE_FILES := $(wildcard ape/*.*)
+APE_HDRS = $(filter %.h,$(APE_FILES))
+APE_INCS = $(filter %.inc,$(APE_FILES))
 APE_SRCS_C = ape/loader.c
 APE_SRCS_S = $(filter %.S,$(APE_FILES))
 APE_SRCS = $(APE_SRCS_C) $(APE_SRCS_S)
 APE_OBJS = $(APE_SRCS_S:%.S=o/$(MODE)/%.o)
 APE_CHECKS = $(APE_HDRS:%=o/%.ok)
 
+o/$(MODE)/ape/ape.lds:				\
+		ape/ape.lds			\
+		ape/macros.internal.h		\
+		ape/relocations.h		\
+		libc/intrin/bits.h		\
+		libc/thread/tls.h		\
+		libc/calls/struct/timespec.h	\
+		libc/dce.h			\
+		libc/elf/def.h			\
+		libc/elf/pf2prot.internal.h	\
+		libc/macros.internal.h		\
+		libc/nt/pedef.internal.h	\
+		libc/str/str.h			\
+		libc/zip.h
+
+o/$(MODE)/ape/public/ape.lds: OVERRIDE_CPPFLAGS += -UCOSMO
+o/$(MODE)/ape/public/ape.lds:			\
+		ape/public/ape.lds		\
+		ape/ape.lds			\
+		ape/macros.internal.h		\
+		ape/relocations.h		\
+		libc/intrin/bits.h		\
+		libc/thread/tls.h		\
+		libc/calls/struct/timespec.h	\
+		libc/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			\
@@ -186,102 +122,63 @@ 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/sysv/consts/prot.h		\
-		ape/blink-linux-aarch64.gz	\
-		ape/blink-xnu-aarch64.gz
+		libc/runtime/symbolic.h		\
+		libc/sysv/consts/prot.h
 	@$(COMPILE)				\
 		-AOBJECTIFY.S			\
 		$(OBJECTIFY.S)			\
 		$(OUTPUT_OPTION)		\
 		-DAPE_NO_MODIFY_SELF $<
 
-o/$(MODE)/ape/loader.o: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=121 -g $(APE_LOADER_FLAGS)
+o/$(MODE)/ape/loader.o: ape/loader.c ape/loader.h
+	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b01111001 -g $(APE_LOADER_FLAGS)
 o/$(MODE)/ape/loader-gcc.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=121 -S -g0 $(APE_LOADER_FLAGS)
+	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b01111001 -S -g0 $(APE_LOADER_FLAGS)
 o/$(MODE)/ape/loader-clang.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=121 -S -g0 $(APE_LOADER_FLAGS)
+	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=0b01111001 -S -g0 $(APE_LOADER_FLAGS)
 
-o/$(MODE)/ape/loader-xnu.o: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=8 -g $(APE_LOADER_FLAGS)
+o/$(MODE)/ape/loader-xnu.o: ape/loader.c ape/loader.h
+	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b00001000 -g $(APE_LOADER_FLAGS)
 o/$(MODE)/ape/loader-xnu-gcc.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
+	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b00001000 -S -g0 $(APE_LOADER_FLAGS)
 o/$(MODE)/ape/loader-xnu-clang.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
+	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=0b00001000 -S -g0 $(APE_LOADER_FLAGS)
 
 o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
-	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy.com -f -o $@ $<
-
-o/$(MODE)/ape/ape.macho: o/$(MODE)/ape/ape.elf.dbg
-	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy.com -fm -o $@ $<
-
-APE_LOADER_LDFLAGS =				\
-	-static					\
-	-nostdlib				\
-	--no-dynamic-linker			\
-	-z separate-code			\
-	-z common-page-size=0x1000		\
-	-z max-page-size=0x10000
+o/$(MODE)/ape/ape.macho: o/$(MODE)/ape/ape.macho.dbg
 
 o/$(MODE)/ape/ape.elf.dbg:			\
-		o/$(MODE)/ape/loader-macho.o	\
-		o/$(MODE)/ape/start.o		\
 		o/$(MODE)/ape/loader.o		\
-		o/$(MODE)/ape/launch.o		\
-		o/$(MODE)/ape/systemcall.o	\
+		o/$(MODE)/ape/loader-elf.o	\
 		ape/loader.lds
-	@$(COMPILE) -ALINK.elf $(LD) $(APE_LOADER_LDFLAGS) -o $@ $(patsubst %.lds,-T %.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
 
 .PHONY: o/$(MODE)/ape
 o/$(MODE)/ape:	$(APE_CHECKS)			\
 		o/$(MODE)/ape/ape.o		\
 		o/$(MODE)/ape/ape.lds		\
+		o/$(MODE)/ape/public/ape.lds	\
 		o/$(MODE)/ape/ape.elf		\
 		o/$(MODE)/ape/ape.macho		\
 		o/$(MODE)/ape/ape-copy-self.o	\
 		o/$(MODE)/ape/ape-no-modify-self.o
-
-endif
-
-# these assembly files are safe to build on aarch64
-o/$(MODE)/ape/ape.o: ape/ape.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-
-o/$(MODE)/ape/ape.o:				\
-		ape/blink-linux-aarch64.gz	\
-		ape/blink-xnu-aarch64.gz
-
-o/$(MODE)/ape/ape.lds:				\
-		ape/ape.lds			\
-		ape/macros.internal.h		\
-		ape/relocations.h		\
-		ape/ape.internal.h		\
-		libc/intrin/bits.h		\
-		libc/thread/tls.h		\
-		libc/calls/struct/timespec.h	\
-		libc/thread/thread.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/elf/pf2prot.internal.h	\
-		libc/macros.internal.h		\
-		libc/nt/pedef.internal.h	\
-		libc/str/str.h			\
-		libc/zip.internal.h

ape/apeinstall.sh

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

ape/apeinstall.sh

@@ -0,0 +1,126 @@
+#!/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/apeuninstall.sh

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

ape/apeuninstall.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+
+if [ "$UID" = "0" ]; then
+  SUDO=
+else
+  SUDO=sudo
+fi
+
+{
+  echo
+  echo "APE Uninstaller intends to run"
+  echo
+  echo "    $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE'"
+  echo "    $SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape /tmp/.ape"
+  echo
+  echo "You may then use ape/apeinstall.sh to reinstall it"
+  echo
+} >&2
+
+set -ex
+if [ -f /proc/sys/fs/binfmt_misc/APE ]; then
+  $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE' || exit
+fi
+$SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape o/tmp/ape /tmp/.ape /tmp/ape || exit

ape/config.h

@@ -0,0 +1,10 @@
+#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,84 +31,80 @@
 //	@see	libc/nt/master.sh
 //	@see	ape/ape.lds
 //	@see	winimp
-.macro	.imp	dll:req fn:req actual:req
-#ifdef __x86_64__
-	.dll	"\dll"
-	.section ".piro.data.sort.iat.2.\dll\().2.\actual","aw",@progbits
+.macro	.imp	dll:req fn:req actual:req hint
+	.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
-"idata.ilt.\dll\().\actual":
-	.quad	RVA("\dll\().\actual")
-	.type	"idata.ilt.\dll\().\actual",@object
-	.size	"idata.ilt.\dll\().\actual",.-"idata.ilt.\dll\().\actual"
+	.section .idata.ro.ilt.\dll\().2.\actual,"a",@progbits
+.Lidata.ilt.\dll\().\actual:
+	.quad	RVA((\dll\().\actual))
+	.type	.Lidata.ilt.\dll\().\actual,@object
+	.size	.Lidata.ilt.\dll\().\actual,.-.Lidata.ilt.\dll\().\actual
 	.previous
-	.section ".idata.ro.hnt.\dll\().2.\actual","a",@progbits
-"\dll\().\actual":
-	.short	0			// hint
+	.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
 	.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
-	.balign	__SIZEOF_POINTER__
-	.type	"idata.ilt.\name",@object
-"idata.ilt.\name":
+  .section .idata.ro.ilt.\name\().1,"aG",@progbits,\name,comdat
+	.align	__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
-	.balign	__SIZEOF_POINTER__
-	.type	"idata.hnt.\name",@object
-	.equ	"idata.hnt.\name",.
+  .section .idata.ro.hnt.\name\().1,"aG",@progbits,\name,comdat
+	.align	__SIZEOF_POINTER__
+	.type	idata.hnt.\name,@object
+	.equ	idata.hnt.\name,.
   .previous
-  .section ".piro.data.sort.iat.2.\name\().1","awG",@progbits,"\name",comdat
-	.balign	__SIZEOF_POINTER__
-	.type	"idata.iat.\name",@object
-"idata.iat.\name":
+  .section .piro.data.sort.iat.2.\name\().1,"awG",@progbits,\name,comdat
+	.align	__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

@@ -1,92 +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 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

@@ -0,0 +1,249 @@
+/*-*- 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,75 +21,118 @@
 #include "libc/dce.h"
 #include "libc/macros.internal.h"
 
-//	Apple Mach-O Executable Headers
-//	Fixups are applied by objbincopy.com
-//	There must exist a MAC_LC_SEGMENT_64 for every PT_LOAD
+//	APE Loader Executable Structure for XNU
 
-	.section .macho,"a",@progbits
-	.balign	64
-	.long	0xFEEDFACE+1
+	.align	4096
+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|MAC_SPLIT_SEGS	// flags
-	.long	0				// reserved
+	.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	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	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
+	.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
 30:	.long	MAC_LC_SEGMENT_64
 	.long	40f-30b
-	.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
+	.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	0x4527148ba7a513ef		// uuid1
-	.quad	0x56fa865940665e8f		// uuid2
+	.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	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
+	.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,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

@@ -0,0 +1,42 @@
+/*-*- 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

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

ape/loader.lds

@@ -1,7 +1,7 @@
 /*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
 │vi: set et sts=2 tw=2 fenc=utf-8                                           :vi│
 ╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@@ -16,80 +16,28 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-
-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 */
-}
+ENTRY(_start)
 
 SECTIONS {
-
-  . = SEGMENT_START("text-segment", 0x7f000000);
-  __executable_start = .;
-  . += SIZEOF_HEADERS;
-
-  .macho : {
-    KEEP(*(.macho))
-  } :text
-
-  .note : {
-    KEEP(*(.note))
-  } :text :note
-
+  . = 0x200000;
   .text : {
-    *(.text .text.* .gnu.linkonce.t.*)
-  } :text
-
-  .rodata ALIGN(CONSTANT(COMMONPAGESIZE)) : {
-    *(.rodata .rodata.* .gnu.linkonce.r.*)
-  } :rodata
-
-  .stack : {
-    *(.stack)
-  } :stack
-
+    *(.text)
+    *(.rodata .rodata.*)
+    . = ALIGN(64);
+  }
+  filesz = . - ehdr;
+  textsz = . - _start;
+  .bss ALIGN(4096) : {
+    bss = .;
+    *(.bss)
+    . = ALIGN(4096);
+  }
   _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) }
-  .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)) }
-
+  memsz = _end - ehdr;
   /DISCARD/ : {
     *(.*)
   }
 }
+
+bsssize = SIZEOF(.bss);
+textoff = _start - ehdr;

ape/macros.internal.h

@@ -180,20 +180,6 @@
  .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__)
 
@@ -271,22 +257,5 @@
                        (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/sections.internal.h

@@ -1,29 +0,0 @@
-#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

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

ape/systemcall.S

@@ -1,49 +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 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

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

bin/aarch64-unknown-cosmo-apecopy

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

bin/aarch64-unknown-cosmo-ar

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

bin/aarch64-unknown-cosmo-as

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

bin/aarch64-unknown-cosmo-c++

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

bin/aarch64-unknown-cosmo-cc

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

bin/aarch64-unknown-cosmo-install

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

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

bin/aarch64-unknown-cosmo-objcopy

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

bin/aarch64-unknown-cosmo-objdump

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

bin/aarch64-unknown-cosmo-strip

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

bin/ape-install

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

bin/ape-uninstall

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

bin/apecopy

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

bin/apelink

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

bin/cosmoaddr2line

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

bin/cosmoc++

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

bin/cosmocc

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

bin/fatcosmoar

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

bin/fatcosmoc++

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

bin/fatcosmocc

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

bin/fatcosmoinstall

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

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

bin/unknown-unknown-cosmo-c++

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

bin/unknown-unknown-cosmo-cc

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

bin/unknown-unknown-cosmo-install

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

bin/x86_64-unknown-cosmo-addr2line

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

bin/x86_64-unknown-cosmo-apecopy

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

bin/x86_64-unknown-cosmo-ar

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

bin/x86_64-unknown-cosmo-as

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

bin/x86_64-unknown-cosmo-c++

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

bin/x86_64-unknown-cosmo-cc

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

bin/x86_64-unknown-cosmo-install

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

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

bin/x86_64-unknown-cosmo-objcopy

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

bin/x86_64-unknown-cosmo-objdump

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

bin/x86_64-unknown-cosmo-strip

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

build/config.mk

@@ -6,49 +6,16 @@
 #   - `make`
 #   - Optimized
 #   - Backtraces
+#   - Debuggable
 #   - Syscall tracing
 #   - Function tracing
+#   - Reasonably small
 #
 ifeq ($(MODE),)
-ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
-CONFIG_CCFLAGS += -O2 $(BACKTRACES)
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2
 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
 #
@@ -58,11 +25,12 @@ endif
 #   - Function tracing
 #   - Some optimizations
 #   - Limited Backtraces
+#   - Compiles 28% faster
 #
-ifeq ($(MODE), fastbuild)
-ENABLE_FTRACE = 1
-CONFIG_CCFLAGS += $(BACKTRACES) -O
-CONFIG_CPPFLAGS += -DSYSDEBUG -DDWARFLESS
+ifeq ($(MODE),fastbuild)
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O
+CONFIG_CPPFLAGS += -DSYSDEBUG
+CONFIG_OFLAGS += -g0
 CONFIG_LDFLAGS += -S
 TARGET_ARCH ?= -msse3
 endif
@@ -80,15 +48,12 @@ endif
 #   - GCC 8+ hoists check fails into .text.cold, thus minimizing impact
 #
 ifeq ($(MODE), opt)
-ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
-CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
-CONFIG_CCFLAGS += $(BACKTRACES) -O3 -fmerge-all-constants
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -msse2avx -Wa,-msse2avx
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O3 -fmerge-all-constants
 TARGET_ARCH ?= -march=native
 endif
 
 # Optimized Linux Mode
-# The Fastest Mode of All
 #
 #   - `make MODE=optlinux`
 #   - Turns on red zone
@@ -98,10 +63,9 @@ endif
 #   - Turns off support for other operating systems
 #
 ifeq ($(MODE), optlinux)
-CONFIG_OFLAGS ?= -g
-CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
+CONFIG_CPPFLAGS += -DNDEBUG -msse2avx -Wa,-msse2avx -DSUPPORT_VECTOR=1
 CONFIG_CCFLAGS += -O3 -fmerge-all-constants
-CONFIG_COPTS += -mred-zone
+DEFAULT_COPTS += -mred-zone
 TARGET_ARCH ?= -march=native
 endif
 
@@ -113,7 +77,6 @@ endif
 #   - More optimized
 #   - Reasonably small
 #   - Numeric backtraces
-#   - No DWARF data bloat
 #   - Toilsome debuggability
 #   - assert() statements removed
 #   - DCHECK_xx() statements removed
@@ -121,7 +84,7 @@ endif
 #   - CHECK_xx() won't leak strings into binary
 #
 ifeq ($(MODE), rel)
-CONFIG_CPPFLAGS += -DNDEBUG -DDWARFLESS
+CONFIG_CPPFLAGS += -DNDEBUG
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
 TARGET_ARCH ?= -msse3
 PYFLAGS += -O1
@@ -139,13 +102,9 @@ endif
 #   - Larger binaries
 #
 ifeq ($(MODE), asan)
-ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
-CONFIG_CPPFLAGS += -D__SANITIZE_ADDRESS__
-CONFIG_CCFLAGS += $(BACKTRACES) -O2 -DSYSDEBUG
+CONFIG_CCFLAGS += $(BACKTRACES) -O2
 CONFIG_COPTS += -fsanitize=address
 TARGET_ARCH ?= -msse3
-QUOTA ?= -C64 -L300
 endif
 
 # Debug Mode
@@ -153,46 +112,17 @@ endif
 #   - `make MODE=dbg`
 #   - Backtraces
 #   - Enables asan
-#   - Enables ubsan
+#   - Enables ubsan (TODO)
 #   - Stack canaries
-#   - No optimization
+#   - No optimization (TODO)
 #   - Enormous binaries
 #
 ifeq ($(MODE), dbg)
-ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
-CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_ADDRESS__ -D__SANITIZE_UNDEFINED__
-CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline
+CONFIG_CPPFLAGS += -DMODE_DBG
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -DSYSDEBUG -O -fno-inline
 CONFIG_COPTS += -fsanitize=address -fsanitize=undefined
 TARGET_ARCH ?= -msse3
 OVERRIDE_CCFLAGS += -fno-pie
-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
@@ -219,35 +149,15 @@ CONFIG_CCFLAGS +=			\
 	-fno-align-labels		\
 	-fno-align-loops		\
 	-fschedule-insns2		\
+	-fomit-frame-pointer		\
 	-momit-leaf-frame-pointer	\
-	-foptimize-sibling-calls	\
-	-DDWARFLESS
+	-foptimize-sibling-calls
 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
 #
@@ -267,8 +177,9 @@ CONFIG_CPPFLAGS +=			\
 	-DTINY				\
 	-DNDEBUG			\
 	-DTRUSTWORTHY			\
-	-DSUPPORT_VECTOR=1		\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=1
+DEFAULT_COPTS +=			\
+	-mred-zone
 CONFIG_CCFLAGS +=			\
 	-Os				\
 	-fno-align-functions		\
@@ -298,8 +209,9 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=113	\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=113
+DEFAULT_COPTS +=		\
+	-mred-zone
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -328,8 +240,9 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=121	\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=121
+DEFAULT_COPTS +=		\
+	-mred-zone
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -358,8 +271,7 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=251	\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=251
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -370,40 +282,10 @@ TARGET_ARCH ?=			\
 	-msse3
 endif
 
-# 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
-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
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -DSYSDEBUG -O2
 AS = clang
 CC = clang
 CXX = clang++
@@ -441,65 +323,12 @@ 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,100 +33,71 @@
 #
 # VARIABLES
 #
-#   Our configuration variables, ordered by increasing preference:
-#
-#     CCFLAGS      frontend flags (.i, .c, .cc, .f, .S, .lds, etc.)
-#     OFLAGS       objectify flags (precludes -S and -E)
+#     CCFLAGS      gcc frontend flags (.i, .c, .cc, .f, .S, .lds, etc.)
 #     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)
-#
-#   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)
-#
+#     TARGET_ARCH  microarchitecture flags (e.g. -march=native)
 
 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)
 
 COMMA := ,
 PWD := $(shell build/bootstrap/pwd.com)
+IMAGE_BASE_VIRTUAL ?= 0x400000
 
-IGNORE := $(shell $(MKDIR) $(TMPDIR))
+IGNORE := $(shell $(ECHO) -2 ♥cosmo)
+IGNORE := $(shell $(MKDIR) o/tmp)
 
-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-
+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
 else
 IGNORE := $(shell build/bootstrap/unbundle.com)
-PREFIX = o/third_party/gcc/bin/x86_64-linux-musl-
-endif
-endif # ($(ARCH),x86_64))
-ifeq ($(ARCH),aarch64)
-ifneq ("$(wildcard o/third_party/gcc/bin/aarch64-linux-cosmo-*)","")
-PREFIX = o/third_party/gcc/bin/aarch64-linux-cosmo-
-else
-IGNORE := $(shell build/bootstrap/unbundle.com)
-PREFIX = o/third_party/gcc/bin/aarch64-linux-musl-
-endif
-endif # ($(ARCH),aarch64)
-endif # ($(USE_SYSTEM_TOOLCHAIN),)
-endif # ($(PREFIX),)
-
-AS = $(PREFIX)as
-CC = $(PREFIX)gcc
-CXX = $(PREFIX)g++
-CXXFILT = $(PREFIX)c++filt
-LD = $(PREFIX)ld.bfd
-NM = $(PREFIX)nm
-GCC = $(PREFIX)gcc
-STRIP = $(PREFIX)strip
-OBJCOPY = $(PREFIX)objcopy
-OBJDUMP = $(PREFIX)objdump
-ifneq ($(wildcard $(PWD)/$(PREFIX)addr2line),)
-ADDR2LINE = $(PWD)/$(PREFIX)addr2line
-else
-ADDR2LINE = $(PREFIX)addr2line
+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
 endif
 
 export ADDR2LINE
@@ -137,28 +108,28 @@ export SOURCE_DATE_EPOCH
 export TMPDIR
 
 ifeq ($(LANDLOCKMAKE_VERSION),)
-TMPSAFE = $(join $(TMPDIR),$(subst /,_,$@)).tmp
+TMPSAFE = $(TMPDIR)/$(subst /,_,$@).tmp
 else
 TMPSAFE = $(TMPDIR)/
 endif
 
+FTRACE =								\
+	-pg
+
 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 =								\
-	-ffreestanding							\
+	-mno-fentry							\
 	-fno-stack-protector						\
 	-fwrapv								\
-	-fno-sanitize=all						\
-	-fpatchable-function-entry=0,0
+	-fno-sanitize=all
 
 OLD_CODE =								\
 	-fno-strict-aliasing						\
@@ -169,58 +140,37 @@ TRADITIONAL =								\
 	-Wno-return-type						\
 	-Wno-pointer-sign
 
-DEFAULT_CCFLAGS +=							\
+DEFAULT_CCFLAGS =							\
 	-Wall								\
 	-Werror								\
-	-fno-omit-frame-pointer						\
+	-fdebug-prefix-map='$(PWD)'=					\
 	-frecord-gcc-switches
 
-DEFAULT_COPTS ?=							\
+DEFAULT_OFLAGS =							\
+	-g								\
+	-gdescribe-dies
+
+DEFAULT_COPTS =								\
+	-mno-red-zone							\
 	-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 +=							\
-	-D_COSMO_SOURCE							\
+DEFAULT_CPPFLAGS =							\
+	-DCOSMO								\
 	-DMODE='"$(MODE)"'						\
+	-DIMAGE_BASE_VIRTUAL=$(IMAGE_BASE_VIRTUAL)			\
 	-nostdinc							\
 	-iquote .
 
@@ -231,6 +181,7 @@ DEFAULT_CXXFLAGS =							\
 	-fno-rtti							\
 	-fno-exceptions							\
 	-fuse-cxa-atexit						\
+	-fno-threadsafe-statics						\
 	-Wno-int-in-bool-context					\
 	-Wno-narrowing							\
 	-Wno-literal-suffix
@@ -238,33 +189,28 @@ DEFAULT_CXXFLAGS =							\
 DEFAULT_ASFLAGS =							\
 	-W								\
 	-I.								\
-	--noexecstack
+	--noexecstack							\
+	--nocompress-debug-sections
 
 DEFAULT_LDFLAGS =							\
 	-static								\
 	-nostdlib							\
-	-znorelro							\
+	-melf_x86_64							\
 	--gc-sections							\
 	--build-id=none							\
-	--no-dynamic-linker
+	--no-dynamic-linker						\
+	-zmax-page-size=0x1000 #--cref [email protected]
 
-# # generate linker report files
-# DEFAULT_LDFLAGS += --cref [email protected]
+ZIPOBJ_FLAGS =								\
+	 -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
+PYFLAGS =								\
+	 -b$(IMAGE_BASE_VIRTUAL)
 
 ASONLYFLAGS =								\
 	-c								\
-	-g
+	-g								\
+	--debug-prefix-map='$(PWD)'=
 
 DEFAULT_LDLIBS =
 
@@ -338,31 +284,40 @@ LD.libs =								\
 	$(CONFIG_LIBS)							\
 	$(LIBS)
 
-COMPILE.c.flags = $(cc.flags) $(copt.flags) $(cpp.flags) $(c.flags)
-COMPILE.cxx.flags = $(cc.flags) $(copt.flags) $(cpp.flags) $(cxx.flags)
+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.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 = $(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.c.flags = $(OBJECTIFY.S.flags) $(copt.flags) $(c.flags)
+OBJECTIFY.cxx.flags = $(OBJECTIFY.S.flags) $(copt.flags) $(cxx.flags)
 OBJECTIFY.s.flags = $(ASONLYFLAGS) $(s.flags)
-OBJECTIFY.S.flags = $(cc.flags) $(o.flags) $(S.flags) $(cpp.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)
 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) && $(COMPILE) -AFIXUP.ape -T$@ $(FIXUPOBJ) $@
+ELFLINK = $(COMPILE) -ALINK.elf $(LINK) $(LINKARGS) $(OUTPUT_OPTION)
 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
@@ -377,9 +332,74 @@ 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/htags

@@ -43,9 +43,6 @@
 #     '(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' "$@"
@@ -66,7 +63,7 @@ set -- --regex-c='/^extern [^(]*(\*const \([^)]*\))(/\1/b' "$@"
 #   struct WorstSoftwareEver;
 set -- --regex-c='/^struct.*;$/uehocruehcroue/b' "$@"
 
-exec $TAGS                                                        \
+exec ${TAGS:-ctags}                                               \
      -e                                                           \
      --langmap=c:.c.h                                             \
      --exclude=libc/nt/struct/imagefileheader.internal.h          \

build/objdump

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

build/online.mk

@@ -23,12 +23,9 @@
 #   - tool/build/runitd.c
 
 .PRECIOUS: o/$(MODE)/%.com.ok
-o/$(MODE)/%.com.ok: private .PLEDGE = stdio rpath wpath cpath proc fattr inet
+o/$(MODE)/%.com.ok: .PLEDGE = stdio rpath wpath cpath proc fattr inet
 o/$(MODE)/%.com.ok:				\
 		o/$(MODE)/tool/build/runit.com	\
 		o/$(MODE)/tool/build/runitd.com	\
 		o/$(MODE)/%.com
 	@$(COMPILE) -wATEST -tT$@ $^ $(HOSTS)
-
-.PHONY:
-o/tiny/tool/build/runit.com:

build/rules.mk

@@ -16,15 +16,40 @@
 
 MAKEFLAGS += --no-builtin-rules
 
-MAKE_ZIPCOPY = $(COMPILE) -AZIPCOPY -wT$@ $(ZIPCOPY) $< $@
-ifneq ($(ARCH), aarch64)
-MAKE_OBJCOPY = $(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -S -O binary $< $@ && $(MAKE_ZIPCOPY)
-else
-MAKE_OBJCOPY = $(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -S $< $@ && $(MAKE_ZIPCOPY)
-endif
+o/%.o: %.s                         ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/%.o: o/%.s                       ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/%.s: %.S                         ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/%.s: o/%.S                       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/%.o: %.S                         ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/%.o: o/%.S                       ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/%.lds: %.lds                     ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
+o/%.inc: %.h                       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) -D__ASSEMBLER__ -P $<
+o/%.greg.o: %.greg.c               ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
 
-o/$(MODE)/%: o/$(MODE)/%.dbg
-	@$(MAKE_OBJCOPY)
+o/$(MODE)/%: o/$(MODE)/%.dbg       ; @$(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -S -O binary $< $@
+o/$(MODE)/%.o: %.s                 ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.s       ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.f                 ; @$(COMPILE) -AOBJECTIFY.f $(OBJECTIFY.f) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.F                 ; @$(COMPILE) -AOBJECTIFY.F $(OBJECTIFY.F) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.h: %.c                 ; @$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
+o/$(MODE)/%.h: o/$(MODE)/%.c       ; @$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
+o/$(MODE)/%.o: %.S                 ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.S       ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.cc                ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.lds: %.lds             ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.greg.c            ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.greg.o: %.greg.c       ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.initabi.o: %.initabi.c ; @$(COMPILE) -AOBJECTIFY.init $(OBJECTIFY.initabi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ncabi.o: %.ncabi.c     ; @$(COMPILE) -AOBJECTIFY.nc $(OBJECTIFY.ncabi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.real.o: %.c            ; @$(COMPILE) -AOBJECTIFY.real $(OBJECTIFY.real.c) $(OUTPUT_OPTION) $<
+
+o/%.o: %.cc
+	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
+
+o/%.o: o/%.cc
+	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
 
 o/$(MODE)/%.o: %.c
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
@@ -34,33 +59,8 @@ o/$(MODE)/%.o: o/$(MODE)/%.c
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
 	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
 
-o/$(MODE)/%.h: %.c
-	@$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
-
-o/$(MODE)/%.o: %.cc
+o/$(MODE)/%.o: o/$(MODE)/%.cc
 	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-
-o/$(MODE)/%.lds: %.lds
-	@$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
-
-ifneq ($(ARCH), aarch64)
-o/$(MODE)/%.o: %.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: o/$(MODE)/%.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
-else
-o/$(MODE)/%.o: %.S libc/empty.s
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.s) $(OUTPUT_OPTION) libc/empty.s
-o/$(MODE)/%.o: o/$(MODE)/%.S libc/empty.s
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.s) $(OUTPUT_OPTION) libc/empty.s
-endif
-
-o/$(MODE)/%.o: %.greg.c
-	@$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-o/$(MODE)/%.greg.o: %.greg.c
-	@$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
 	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
 
 o/%.a:
@@ -87,6 +87,10 @@ o/$(MODE)/%.lua: %.lua o/$(MODE)/third_party/lua/luac.com
 o/$(MODE)/%.lua.runs: %.lua o/$(MODE)/tool/net/redbean.com
 	@$(COMPILE) -wALUA -tT$@ o/$(MODE)/tool/net/redbean.com $(LUAFLAGS) -i $<
 
+o/$(MODE)/%: o/$(MODE)/%.com o/$(MODE)/tool/build/cp.com o/$(MODE)/tool/build/assimilate.com
+	@$(COMPILE) -wACP -T$@ o/$(MODE)/tool/build/cp.com $< $@
+	@$(COMPILE) -wAASSIMILATE -T$@ o/$(MODE)/tool/build/assimilate.com $@
+
 ################################################################################
 # LOCAL UNIT TESTS
 #
@@ -159,15 +163,15 @@ o/$(MODE)%/.zip.o: %
 # and it would be too costly in terms of make latency to have every
 # header file depend on $(HDRS) and $(INCS).
 
-o/%.h.ok: private .UNSANDBOXED = 1
+o/%.h.ok: .UNSANDBOXED = 1
 o/%.h.ok: %.h
 	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
 
-o/$(MODE)/%.h.ok: private .UNSANDBOXED = 1
+o/$(MODE)/%.h.ok: .UNSANDBOXED = 1
 o/$(MODE)/%.h.ok: %.h
 	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
 
-o/$(MODE)/%.hh.ok: private .UNSANDBOXED = 1
+o/$(MODE)/%.hh.ok: .UNSANDBOXED = 1
 o/$(MODE)/%.hh.ok: %.hh
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
@@ -175,13 +179,17 @@ o/%.okk: .UNSANDBOXED = 1
 o/%.okk: %
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
-o/$(MODE)/%.okk: private .UNSANDBOXED = 1
+o/$(MODE)/%.okk: .UNSANDBOXED = 1
 o/$(MODE)/%.okk: %
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
 ################################################################################
 # EXECUTABLE HELPERS
 
+MAKE_OBJCOPY =					\
+	$(COMPILE) -AOBJCOPY -T$@		\
+	$(OBJCOPY) -S -O binary $< $@
+
 MAKE_SYMTAB_CREATE =				\
 	$(COMPILE) -wASYMTAB			\
 	o/$(MODE)/tool/build/symtab.com		\
@@ -199,20 +207,19 @@ MAKE_SYMTAB_ZIP =				\
 ################################################################################
 # EMACS ASSEMBLY GENERATION
 
-o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-gcc.asm: .UNSANDBOXED = 1
 o/$(MODE)/%-gcc.asm: %.c
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
 
-o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-gcc.asm: .UNSANDBOXED = 1
 o/$(MODE)/%-gcc.asm: %.cc
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
 
-o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-clang.asm: .UNSANDBOXED = 1
 o/$(MODE)/%-clang.asm: %.c
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
 
-# TODO(jart): Make intrinsics support Clang.
 o/$(MODE)/%-clang.asm: CC = $(CLANG)
-o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-clang.asm: .UNSANDBOXED = 1
 o/$(MODE)/%-clang.asm: %.cc
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<

build/run

@@ -1,9 +0,0 @@
-#!/bin/sh
-if printf '%s\n' "$*" | grep aarch64 >/dev/null 2>&1; then
-  if [ ! -f o/third_party/qemu/qemu-aarch64 ]; then
-    make -j8 o/third_party/qemu/qemu-aarch64
-  fi
-  exec o/third_party/qemu/qemu-aarch64 "$@"
-else
-  exec "$@"
-fi