Tell _frozen_importlib to consider bytecode first (#248)

It turns out we needed a file length field.

.clang-format

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

.gitattributes

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

.github/workflows/build.yml

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

.gitignore

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

.travis.yml

@@ -0,0 +1,6 @@
+virt: lxd
+os: linux
+language: c
+script: make -j4 V=0
+notifications:
+  email: false

.vscode/c_cpp_properties.json

@@ -15,7 +15,7 @@
 				"alignas(x)",
 				"alignof(x)",
 				"artificial=",
-				"dontdiscard=",
+				"nodiscard=",
 				"mayalias=",
 				"forceinline=",
 				"forcealign(x)=",
@@ -36,19 +36,19 @@
 				"textwindows=",
 				"privileged=",
 				"compatfn=",
-				"dontinstrument=",
+				"noinstrument=",
 				"nodebuginfo=",
 				"interruptfn=",
 				"optimizespeed=",
 				"forcealignargpointer=",
-				"dontasan=",
-				"dontubsan=",
+				"noasan=",
+				"noubsan=",
+				"testonly=",
 				"donothing=",
 				"nosideeffect=",
-				"unreachable=",,
-				"notpossible=",
+				"unreachable=",
 				"thatispacked=",
-				"dontthrow=",
+				"nothrow=",
 				"nocallback=",
 				"relegated=",
 				"hidden=",
@@ -78,6 +78,7 @@
 				"-Wa,-W",
 				"-Wa,-I.",
 				"-Wa,--noexecstack",
+				"-Wa,--nocompress-debug-sections",
 				"-Og",
 				"-g",
 				"-gdescribe-dies",

Makefile

@@ -37,7 +37,7 @@
 #
 #   # basic debugging
 #   make -j8 -O MODE=dbg o/dbg/examples/crashreport.com
-#   o/examples/crashreport.com
+#   o/dbg/examples/crashreport.com
 #   less examples/crashreport.c
 #
 #   # extremely tiny binaries
@@ -59,25 +59,18 @@
 #
 #   build/config.mk
 
-SHELL      = build/bootstrap/cocmd.com
-MAKEFLAGS += --no-builtin-rules
+SHELL         = /bin/sh
+HOSTS        ?= freebsd openbsd netbsd rhel7 rhel5 xnu win7 win10
+SANITY       := $(shell build/sanitycheck $$PPID)
+GNUMAKEFLAGS += --output-sync
 
 .SUFFIXES:
 .DELETE_ON_ERROR:
 .FEATURES: output-sync
-.PHONY: all o bins check test depend tags aarch64 clean
-
-ifneq ($(m),)
-ifeq ($(MODE),)
-MODE := $(m)
-endif
-endif
+.PHONY: all o bins check test depend tags
 
 all:	o
-o:	o/$(MODE)
-
-o/$(MODE):			\
-	o/$(MODE)/ape		\
+o:	o/$(MODE)/ape		\
 	o/$(MODE)/dsp		\
 	o/$(MODE)/net		\
 	o/$(MODE)/libc		\
@@ -86,33 +79,6 @@ o/$(MODE):			\
 	o/$(MODE)/examples	\
 	o/$(MODE)/third_party
 
-ifneq ($(LANDLOCKMAKE_VERSION),)
-ifeq ($(wildcard /usr/bin/ape),)
-$(warning please run ape/apeinstall.sh if you intend to use landlock make)
-$(shell sleep .5)
-endif
-ifeq ($(USE_SYSTEM_TOOLCHAIN),)
-.STRICT = 1
-endif
-endif
-
-.PLEDGE = stdio rpath wpath cpath fattr proc
-.UNVEIL =			\
-	libc/integral		\
-	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	\
-	/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
-
 PKGS =
 
 -include ~/.cosmo.mk
@@ -120,135 +86,99 @@ 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/bits/bits.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 third_party/double-conversion/dc.mk	# │
 include libc/elf/elf.mk				# │
 include ape/ape.mk				# │
-include libc/fmt/fmt.mk				# │
-include libc/vga/vga.mk				#─┘
+include libc/fmt/fmt.mk				#─┘
 include libc/calls/calls.mk			#─┐
 include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
 include libc/crt/crt.mk				# │  You can issue system calls
-include tool/hello/hello.mk			# │
-include third_party/nsync/nsync.mk		# │
+include libc/rand/rand.mk			# │
+include libc/unicode/unicode.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/thread/thread.mk			# │  You can finally call malloc()
-include libc/zipos/zipos.mk			# │
-include libc/stdio/stdio.mk			# │
+include libc/ohmyplus/ohmyplus.mk		# ├──DYNAMIC RUNTIME
+include libc/zipos/zipos.mk			# │  You can now use stdio
+include third_party/gdtoa/gdtoa.mk		# │  You can finally call malloc()
 include libc/time/time.mk			# │
+include libc/alg/alg.mk				# │
+include libc/stdio/stdio.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
-include test/tool/args/test.mk
 include third_party/linenoise/linenoise.mk
-include third_party/maxmind/maxmind.mk
-include net/finger/finger.mk
-include third_party/double-conversion/test/test.mk
 include third_party/lua/lua.mk
-include third_party/zstd/zstd.mk
-include third_party/tr/tr.mk
-include third_party/sed/sed.mk
-include third_party/awk/awk.mk
-include third_party/hiredis/hiredis.mk
-include third_party/make/make.mk
-include third_party/ctags/ctags.mk
-include third_party/finger/finger.mk
-include third_party/argon2/argon2.mk
-include third_party/smallz4/smallz4.mk
 include third_party/sqlite3/sqlite3.mk
 include third_party/mbedtls/test/test.mk
 include third_party/quickjs/quickjs.mk
 include third_party/lz4cli/lz4cli.mk
-include third_party/zip/zip.mk
-include third_party/xxhash/xxhash.mk
-include third_party/unzip/unzip.mk
+include third_party/infozip/infozip.mk
+include third_party/python/python.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 tool/ape/ape.mk
-include third_party/qemu/qemu.mk
 include examples/examples.mk
-include examples/pyapp/pyapp.mk
-include examples/pylife/pylife.mk
 include tool/decode/lib/decodelib.mk
 include tool/decode/decode.mk
-include tool/lambda/lib/lib.mk
-include tool/lambda/lambda.mk
-include tool/plinko/lib/lib.mk
-include tool/plinko/plinko.mk
-include test/tool/plinko/test.mk
+include tool/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/alg/test.mk
 include test/libc/tinymath/test.mk
 include test/libc/intrin/test.mk
 include test/libc/mem/test.mk
 include test/libc/nexgen32e/test.mk
 include test/libc/runtime/test.mk
-include test/libc/thread/test.mk
 include test/libc/sock/test.mk
+include test/libc/bits/test.mk
 include test/libc/str/test.mk
-include test/libc/log/test.mk
-include test/libc/str/test.mk
+include test/libc/unicode/test.mk
 include test/libc/calls/test.mk
 include test/libc/x/test.mk
 include test/libc/xed/test.mk
 include test/libc/fmt/test.mk
 include test/libc/dns/test.mk
+include test/libc/rand/test.mk
 include test/libc/time/test.mk
 include test/libc/stdio/test.mk
-include test/libc/zipos/test.mk
 include test/libc/release/test.mk
 include test/libc/test.mk
 include test/net/http/test.mk
 include test/net/https/test.mk
-include test/net/finger/test.mk
 include test/net/test.mk
 include test/tool/build/lib/test.mk
 include test/tool/build/test.mk
@@ -275,146 +205,136 @@ CHECKS	 = $(foreach x,$(PKGS),$($(x)_CHECKS))
 
 bins:	$(BINS)
 check:	$(CHECKS)
-test:	$(TESTS)
+test:	$(TESTS) all
 depend:	o/$(MODE)/depend
 tags:	TAGS HTAGS
 
 o/$(MODE)/.x:
-	@$(COMPILE) -AMKDIR -tT$@ $(MKDIR) $(@D)
+	@mkdir -p $(@D) && touch $@
 
-o/$(MODE)/srcs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x)))) $(SRCS)
-	$(file >$@,$(SRCS))
-o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x)))) $(HDRS) $(INCS)
-	$(file >$@,$(HDRS) $(INCS))
-o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x)))) $(INCS) $(INCS)
-	$(file >$@,$(INCS))
-o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt o/$(MODE)/incs.txt $(SRCS) $(HDRS) $(INCS)
-	$(COMPILE) -AMKDEPS -L320 $(MKDEPS) -o $@ -r o/$(MODE)/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt @o/$(MODE)/incs.txt
-
-o/$(MODE)/srcs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
+ifneq ($(findstring 4.,,$(MAKE_VERSION)),$(MAKE_VERSION))
+o/$(MODE)/srcs.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))))
+o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(HDRS) $(INCS),$(file >>$@,$(x)))
+o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x))))
+	$(file >$@) $(foreach x,$(INCS) $(INCS),$(file >>$@,$(x)))
+else
+o/$(MODE)/srcs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
+	$(MAKE) MODE=rel -j8 -pn bopit 2>/dev/null | sed -ne '/^SRCS/ {s/.*:= //;s/  */\n/g;p;q}' >$@
+o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
+	$(MAKE) MODE=rel -j8 -pn bopit 2>/dev/null | sed -ne '/^HDRS/ {s/.*:= //;s/  */\n/g;p;q}' >$@
+o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x))))
+	$(MAKE) MODE=rel -j8 -pn bopit 2>/dev/null | sed -ne '/^INCS/ {s/.*:= //;s/  */\n/g;p;q}' >$@
+endif
 
-TAGS: private .UNSANDBOXED = 1
-TAGS:	o/$(MODE)/srcs-old.txt $(SRCS) #o/$(MODE)/third_party/ctags/ctags.com
-	@$(RM) $@
-	@o/$(MODE)/third_party/ctags/ctags.com $(TAGSFLAGS) -L $< -o $@
+o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt o/$(MODE)/incs.txt $(SRCS) $(HDRS) $(INCS)
+	@$(COMPILE) -AMKDEPS $(MKDEPS) -o $@ -r o/$(MODE)/ o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt o/$(MODE)/incs.txt
 
-HTAGS: private .UNSANDBOXED = 1
-HTAGS:	o/$(MODE)/hdrs-old.txt $(filter-out third_party/libcxx/%,$(HDRS)) #o/$(MODE)/third_party/ctags/ctags.com
-	@$(RM) $@
-	@build/htags o/$(MODE)/third_party/ctags/ctags.com -L $< -o $@
+TAGS:	o/$(MODE)/srcs.txt $(SRCS)
+	@rm -f $@
+	@$(COMPILE) -ATAGS -T$@ $(TAGS) $(TAGSFLAGS) -L $< -o $@
+
+HTAGS:	o/$(MODE)/hdrs.txt $(HDRS)
+	@rm -f $@
+	@$(COMPILE) -ATAGS -T$@ build/htags -L $< -o $@
 
-loc: private .UNSANDBOXED = 1
 loc: o/$(MODE)/tool/build/summy.com
 	find -name \*.h -or -name \*.c -or -name \*.S | \
 	$(XARGS) wc -l | grep total | awk '{print $$1}' | $<
 
-# PLEASE: MAINTAIN TOPOLOGICAL ORDER
-# FROM HIGHEST LEVEL TO LOWEST LEVEL
-COSMOPOLITAN_OBJECTS =			\
-	TOOL_ARGS			\
-	NET_HTTP			\
-	LIBC_DNS			\
-	LIBC_SOCK			\
-	LIBC_NT_WS2_32			\
-	LIBC_NT_IPHLPAPI		\
-	LIBC_NT_MSWSOCK			\
-	LIBC_X				\
-	THIRD_PARTY_GETOPT		\
-	LIBC_LOG			\
-	LIBC_TIME			\
-	LIBC_ZIPOS			\
-	THIRD_PARTY_MUSL		\
-	LIBC_STDIO			\
-	THIRD_PARTY_GDTOA		\
-	THIRD_PARTY_REGEX		\
-	LIBC_THREAD			\
-	THIRD_PARTY_NSYNC_MEM		\
-	LIBC_MEM			\
-	THIRD_PARTY_DLMALLOC		\
-	LIBC_RUNTIME			\
-	THIRD_PARTY_NSYNC		\
-	LIBC_ELF			\
-	LIBC_CALLS			\
-	LIBC_SYSV_CALLS			\
-	LIBC_VGA			\
-	LIBC_NT_PSAPI			\
-	LIBC_NT_POWRPROF		\
-	LIBC_NT_PDH			\
-	LIBC_NT_GDI32			\
-	LIBC_NT_COMDLG32		\
-	LIBC_NT_USER32			\
-	LIBC_NT_NTDLL			\
-	LIBC_NT_ADVAPI32		\
-	LIBC_NT_SYNCHRONIZATION		\
-	LIBC_FMT			\
-	THIRD_PARTY_PUFF		\
-	THIRD_PARTY_COMPILER_RT		\
-	LIBC_TINYMATH			\
-	THIRD_PARTY_XED			\
-	LIBC_STR			\
-	LIBC_SYSV			\
-	LIBC_INTRIN			\
-	LIBC_NT_KERNEL32		\
+COSMOPOLITAN_OBJECTS =		\
+	LIBC_DNS		\
+	LIBC_SOCK		\
+	LIBC_NT_WS2_32		\
+	LIBC_NT_IPHLPAPI	\
+	LIBC_NT_MSWSOCK		\
+	LIBC_OHMYPLUS		\
+	LIBC_X			\
+	THIRD_PARTY_GETOPT	\
+	LIBC_LOG		\
+	LIBC_UNICODE		\
+	LIBC_TIME		\
+	LIBC_ZIPOS		\
+	THIRD_PARTY_ZLIB	\
+	THIRD_PARTY_MUSL	\
+	LIBC_STDIO		\
+	THIRD_PARTY_GDTOA	\
+	THIRD_PARTY_REGEX	\
+	LIBC_ALG		\
+	LIBC_MEM		\
+	THIRD_PARTY_DLMALLOC	\
+	LIBC_BITS		\
+	LIBC_RUNTIME		\
+	LIBC_ELF		\
+	LIBC_CALLS		\
+	LIBC_RAND		\
+	LIBC_SYSV_CALLS		\
+	LIBC_NT_KERNELBASE	\
+	LIBC_NT_SHELL32		\
+	LIBC_NT_GDI32		\
+	LIBC_NT_COMDLG32	\
+	LIBC_NT_NETAPI32	\
+	LIBC_NT_URL		\
+	LIBC_NT_USER32		\
+	LIBC_NT_NTDLL		\
+	LIBC_NT_ADVAPI32	\
+	LIBC_FMT		\
+	THIRD_PARTY_COMPILER_RT	\
+	LIBC_TINYMATH		\
+	LIBC_STR		\
+	LIBC_SYSV		\
+	LIBC_INTRIN		\
+	LIBC_NT_KERNEL32	\
 	LIBC_NEXGEN32E
 
-COSMOPOLITAN_HEADERS =			\
-	APE				\
-	LIBC				\
-	LIBC_CALLS			\
-	LIBC_DNS			\
-	LIBC_ELF			\
-	LIBC_FMT			\
-	LIBC_INTRIN			\
-	LIBC_LOG			\
-	LIBC_MEM			\
-	LIBC_NEXGEN32E			\
-	LIBC_NT				\
-	LIBC_RUNTIME			\
-	LIBC_SOCK			\
-	LIBC_STDIO			\
-	THIRD_PARTY_NSYNC		\
-	THIRD_PARTY_XED			\
-	LIBC_STR			\
-	LIBC_SYSV			\
-	LIBC_THREAD			\
-	LIBC_TIME			\
-	LIBC_TINYMATH			\
-	LIBC_X				\
-	LIBC_ZIPOS			\
-	LIBC_VGA			\
-	NET_HTTP			\
-	TOOL_ARGS			\
-	THIRD_PARTY_DLMALLOC		\
-	THIRD_PARTY_GDTOA		\
-	THIRD_PARTY_GETOPT		\
-	THIRD_PARTY_MUSL		\
+COSMOPOLITAN_HEADERS =		\
+	LIBC			\
+	LIBC_ALG		\
+	LIBC_BITS		\
+	LIBC_CALLS		\
+	LIBC_DNS		\
+	LIBC_ELF		\
+	LIBC_FMT		\
+	LIBC_INTRIN		\
+	LIBC_LOG		\
+	LIBC_MEM		\
+	LIBC_NEXGEN32E		\
+	LIBC_NT			\
+	LIBC_OHMYPLUS		\
+	LIBC_RAND		\
+	LIBC_RUNTIME		\
+	LIBC_SOCK		\
+	LIBC_STDIO		\
+	LIBC_STR		\
+	LIBC_SYSV		\
+	LIBC_TIME		\
+	LIBC_TINYMATH		\
+	LIBC_UNICODE		\
+	LIBC_X			\
+	LIBC_ZIPOS		\
+	THIRD_PARTY_DLMALLOC	\
+	THIRD_PARTY_GDTOA	\
+	THIRD_PARTY_GETOPT	\
+	THIRD_PARTY_MUSL	\
+	THIRD_PARTY_ZLIB	\
 	THIRD_PARTY_REGEX
 
-o/$(MODE)/cosmopolitan.a:		\
-		$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS))
+o/$(MODE)/cosmopolitan.a.txt:
+	printf "%s\n" $(call reverse,$(call uniq,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)))))
+o/$(MODE)/cosmopolitan.a: $(filter-out o/libc/stubs/exit11.o,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS)))
+o/cosmopolitan.h:				\
+		o/$(MODE)/tool/build/rollup.com	\
+		libc/integral/normalize.inc	\
+		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS))
+	@$(COMPILE) -AROLLUP -T$@ $^ >$@
 
-o/cosmopolitan.h:							\
-		o/$(MODE)/tool/build/rollup.com				\
-		libc/integral/normalize.inc				\
-		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS))	\
-		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_INCS))
-	$(file >$(TMPDIR)/$(subst /,_,$@),libc/integral/normalize.inc $(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS)))
-	@$(ECHO) '#define COSMO' >$@
-	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >>$@
-
-o/cosmopolitan.html: private .UNSANDBOXED = 1
 o/cosmopolitan.html:							\
 		o/$(MODE)/third_party/chibicc/chibicc.com.dbg		\
-		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))	\
-		$(SRCS)							\
-		$(HDRS)
-	$(file >$(TMPDIR)/$(subst /,_,$@),$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS))))
+		$(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 /,_,$@)
+		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))
 
 $(SRCS):					\
 	libc/integral/normalize.inc		\
@@ -424,35 +344,6 @@ $(SRCS):					\
 	libc/integral/lp64arg.inc		\
 	libc/integral/lp64.inc
 
-.PHONY: toolchain
-ifeq ($(ARCH), x86_64)
-toolchain:	o/cosmopolitan.h				\
-		o/$(MODE)/ape/public/ape.lds			\
-		o/$(MODE)/libc/crt/crt.o			\
-		o/$(MODE)/ape/ape.o				\
-		o/$(MODE)/ape/ape-copy-self.o			\
-		o/$(MODE)/ape/ape-no-modify-self.o		\
-		o/$(MODE)/cosmopolitan.a			\
-		o/$(MODE)/third_party/libcxx/libcxx.a		\
-		o/$(MODE)/tool/build/fixupobj.com		\
-		o/$(MODE)/tool/build/zipcopy.com
-else
-toolchain:	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/fixupobj.com		\
-		o/$(MODE)/tool/build/zipcopy.com
-endif
-
-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
@@ -477,9 +368,9 @@ $(SRCS):
 $(HDRS):
 $(INCS):
 .DEFAULT:
-	@$(ECHO)
-	@$(ECHO) NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@
-	@$(ECHO)
-	$(RM) o/$(MODE)/depend
+	@echo >&2
+	@echo NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@ >&2
+	@echo >&2
+	rm -f o/$(MODE)/depend
 
 -include o/$(MODE)/depend

README.md

@@ -1,6 +1,5 @@
 ![Cosmopolitan Honeybadger](usr/share/img/honeybadger.png)
 
-[![build](https://github.com/jart/cosmopolitan/actions/workflows/build.yml/badge.svg)](https://github.com/jart/cosmopolitan/actions/workflows/build.yml)
 # Cosmopolitan
 
 [Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C
@@ -19,367 +18,31 @@ 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
-cd /opt/cosmo
-make -j8 toolchain
-ape/apeinstall.sh  # optional
-mkdir -p /opt/cosmos/bin
-export PATH="/opt/cosmos/bin:$PATH"
-echo 'PATH="/opt/cosmos/bin:$PATH"' >>~/.profile
-sudo ln -sf /opt/cosmo/tool/scripts/cosmocc /opt/cosmos/bin/cosmocc
-sudo ln -sf /opt/cosmo/tool/scripts/cosmoc++ /opt/cosmos/bin/cosmoc++
-```
-
-You've now successfully installed your very own cosmos. Now let's build
-an example program, which demonstrates the crash reporting feature:
-
-```c
-// hello.c
-#include <stdio.h>
-#include <cosmo.h>
-
-int main() {
-  ShowCrashReports();
-  printf("hello world\n");
-  __builtin_trap();
-}
-```
-
-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 want to cut out the bloat and instead make your executables as
-tiny as possible, then the monorepo supports numerous build modes. You
-can select one of the predefined ones by looking at
-[build/config.mk](build/config.mk). One of the most popular modes is
-`MODE=tiny`. It can be used with the `cosmocc` toolchain as follows:
-
-```sh
-cd /opt/cosmo
-make -j8 MODE=tiny toolchain
-```
-
-Now that we have our toolchain, let's write a program that links less
-surface area than the program above. The executable that this program
-produces will run on platforms like Linux, Windows, MacOS, etc., even
-though it's directly using POSIX APIs, which Cosmopolitan polyfills.
-
-```c
-// hello2.c
-#include <unistd.h>
-int main() {
-  write(1, "hello world\n", 12);
-}
-```
-
-Now let's compile our tiny actually portable executable, which should be
-on the order of 20kb in size.
-
-```sh
-export MODE=tiny
-cosmocc -Os -o hello2.com hello2.c
-./hello2.com
-```
-
-Let's say you only care about Linux and would rather have simpler tinier
-binaries, similar to what Musl Libc would produce. In that case, try
-using the `MODE=tinylinux` build mode, which can produce binaries more
-on the order of 4kb.
-
-```sh
-export MODE=tinylinux
-(cd /opt/cosmo; make -j8 toolchain)
-cosmocc -Os -o hello2.com hello2.c
-./hello2.com  # <-- actually an ELF executable
-```
-
-## ARM
-
-Cosmo supports cross-compiling binaries for machines with ARM
-microprocessors. There are two options available for doing this.
-
-The first option is to embed the [blink virtual
-machine](https://github.com/jart/blink) by adding the following to the
-top of your main.c file:
-
-```c
-__static_yoink("blink_linux_aarch64");  // for raspberry pi
-__static_yoink("blink_xnu_aarch64");    // is apple silicon
-```
-
-The benefit is you'll have single file executables that'll run on both
-x86_64 and arm64 platforms. The tradeoff is Blink's JIT is slower than
-running natively, but tends to go fast enough, unless you're doing
-scientific computing (e.g. running LLMs with
-`o//third_party/ggml/llama.com`).
-
-Therefore, the second option is to cross compile aarch64 executables,
-by using build modes like the following:
-
-```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
-```
-
-## 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
-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 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-2.2.zip
-unzip cosmopolitan-amalgamation-2.2.zip
+wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-1.0.zip
+unzip cosmopolitan-amalgamation-1.0.zip
 printf 'main() { printf("hello world\\n"); }\n' >hello.c
 gcc -g -Os -static -nostdlib -nostdinc -fno-pie -no-pie -mno-red-zone \
-  -fno-omit-frame-pointer -pg -mnop-mcount -mno-tls-direct-seg-refs -gdwarf-4 \
-  -o hello.com.dbg hello.c -fuse-ld=bfd -Wl,-T,ape.lds -Wl,--gc-sections \
-  -Wl,-z,common-page-size=0x1000 -Wl,-z,max-page-size=0x1000 \
-  -include cosmopolitan.h crt.o ape-no-modify-self.o cosmopolitan.a
+  -fno-omit-frame-pointer -pg -mnop-mcount \
+  -o hello.com.dbg hello.c -fuse-ld=bfd -Wl,-T,ape.lds \
+  -include cosmopolitan.h crt.o ape.o cosmopolitan.a
 objcopy -S -O binary hello.com.dbg hello.com
 ```
 
-You now have a portable program.
+You now have a portable program. Please note that your APE binary will
+assimilate itself as a conventional resident of your platform after the
+first run, so it can be fast and efficient for subsequent executions.
 
 ```sh
 ./hello.com
-bash -c './hello.com'  # zsh/fish workaround (we patched them in 2021)
+bash -c './hello.com'  # zsh/fish workaround (we upstreamed patches)
 ```
 
-If `./hello.com` executed on Linux throws an error about not finding an
-interpreter, it should be fixed by running the following command (although
-note that it may not survive a system restart):
-
-```sh
-sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
-```
-
-If the same command produces puzzling errors on WSL or WINE when using
-Redbean 2.x, they may be fixed by disabling binfmt_misc:
-
-```sh
-sudo sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/status'
-```
-
-Since we used the `ape-no-modify-self.o` bootloader (rather than
-`ape.o`) your executable will not modify itself when it's run. What
-it'll instead do, is extract a 4kb program (the [APE loader](https://justine.lol/apeloader/))
-to `${TMPDIR:-${HOME:-.}}` that maps your program into memory without
-needing to copy it. The APE loader must be in an executable location
-(e.g. not stored on a `noexec` mount) for it to run. See below for
-alternatives:
-
-It's possible to install the APE loader systemwide as follows.
-
-```sh
-# System-Wide APE Install
-# for Linux, Darwin, and BSDs
-# 1. Copies APE Loader to /usr/bin/ape
-# 2. Registers w/ binfmt_misc too if Linux
-ape/apeinstall.sh
-
-# System-Wide APE Uninstall
-# for Linux, Darwin, and BSDs
-ape/apeuninstall.sh
-```
-
-It's also possible to convert APE binaries into the system-local format
-by using the `--assimilate` flag. Please note that if binfmt_misc is in
-play, you'll need to unregister it temporarily before doing this, since
-the assimilate feature is part of the shell script header.
-
-```sh
-$ file hello.com
-hello.com: DOS/MBR boot sector
-./hello.com --assimilate
-$ file hello.com
-hello.com: ELF 64-bit LSB executable
-```
-
-Now that you're up and running with Cosmopolitan Libc and APE, here's
-some of the most important troubleshooting tools APE offers that you
-should know, in case you encounter any issues:
-
-```sh
-./hello.com --strace   # log system calls to stderr
-./hello.com --ftrace   # log function calls to stderr
-```
-
-Do you love tiny binaries? If so, you may not be happy with Cosmo adding
-heavyweight features like tracing to your binaries by default. In that
-case, you may want to consider using our build system:
-
-```sh
-make m=tiny
-```
-
-Which will cause programs such as `hello.com` and `life.com` to shrink
-from 60kb in size to about 16kb. There's also a prebuilt amalgamation
-online <https://justine.lol/cosmopolitan/cosmopolitan-tiny.zip> hosted
-on our download page <https://justine.lol/cosmopolitan/download.html>.
-
-## GDB
-
-Here's the recommended `~/.gdbinit` config:
-
-```gdb
-set host-charset UTF-8
-set target-charset UTF-8
-set target-wide-charset UTF-8
-set osabi none
-set complaints 0
-set confirm off
-set history save on
-set history filename ~/.gdb_history
-define asm
-  layout asm
-  layout reg
-end
-define src
-  layout src
-  layout reg
-end
-src
-```
-
-You normally run the `.com.dbg` file under gdb. If you need to debug the
-`.com` file itself, then you can load the debug symbols independently as
-
-```sh
-gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
-```
-
-## Alternative Development Environments
+So if you intend to copy the binary to Windows or Mac then please do
+that before you run it, not after.
 
 ### MacOS
 
@@ -401,51 +64,32 @@ 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.
+## Source Builds
+
+Cosmopolitan can be compiled from source on any Linux distro. GNU make
+needs to be installed beforehand. This is a freestanding hermetic
+repository that bootstraps using a vendored static gcc9 executable.
+No further dependencies are required.
 
 ```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
+wget https://justine.lol/cosmopolitan/cosmopolitan-1.0.tar.gz
+tar xf cosmopolitan-1.0.tar.gz  # see releases page
+cd cosmopolitan
+make -j16
+o//examples/hello.com
+find o -name \*.com | xargs ls -rShal | less
 ```
 
-## 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  |
-| Linux           | 2.6.18      | 2007  |
-| Windows         | 8 [1]       | 2012  |
-| Mac OS X        | 15.6        | 2018  |
-| OpenBSD         | 7           | 2021  |
-| FreeBSD         | 13          | 2020  |
-| 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:
-
-- [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.
+| New Technology  | Vista       | 2006  |
+| GNU/Systemd     | 2.6.18      | 2007  |
+| XNU's Not UNIX! | 15.6        | 2018  |
+| FreeBSD         | 12          | 2018  |
+| OpenBSD         | 6.4         | 2018  |
+| NetBSD          | 9.1         | 2020  |
+| GNU Make        | 3.80        | 2010  |

ape/aarch64.lds

@@ -1,290 +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", IMAGE_BASE_VIRTUAL);
-  __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.*)
-    *(.head)
-  }
-}
-
-ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : APE_STACKSIZE;
-ape_stack_memsz2 = ape_stack_memsz * 2;
-_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-m1.c

@@ -1,944 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ 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 <dispatch/dispatch.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <libkern/OSCacheControl.h>
-#include <limits.h>
-#include <pthread.h>
-#include <signal.h>
-#include <stdarg.h>
-#include <stdint.h>
-#include <sys/mman.h>
-#include <sys/random.h>
-#include <sys/uio.h>
-#include <time.h>
-#include <unistd.h>
-
-#define pagesz         16384
-#define SYSLIB_MAGIC   ('s' | 'l' << 8 | 'i' << 16 | 'b' << 24)
-#define SYSLIB_VERSION 1
-
-struct Syslib {
-  int magic;
-  int version;
-  long (*fork)(void);
-  long (*pipe)(int[2]);
-  long (*clock_gettime)(int, struct timespec *);
-  long (*nanosleep)(const struct timespec *, struct timespec *);
-  long (*mmap)(void *, size_t, int, int, int, off_t);
-  int (*pthread_jit_write_protect_supported_np)(void);
-  void (*pthread_jit_write_protect_np)(int);
-  void (*sys_icache_invalidate)(void *, size_t);
-  int (*pthread_create)(pthread_t *, const pthread_attr_t *, void *(*)(void *),
-                        void *);
-  void (*pthread_exit)(void *);
-  int (*pthread_kill)(pthread_t, int);
-  int (*pthread_sigmask)(int, const sigset_t *restrict, sigset_t *restrict);
-  int (*pthread_setname_np)(const char *);
-  dispatch_semaphore_t (*dispatch_semaphore_create)(long);
-  long (*dispatch_semaphore_signal)(dispatch_semaphore_t);
-  long (*dispatch_semaphore_wait)(dispatch_semaphore_t, dispatch_time_t);
-  dispatch_time_t (*dispatch_walltime)(const struct timespec *, int64_t);
-};
-
-#define ELFCLASS32  1
-#define ELFDATA2LSB 1
-#define EM_AARCH64  183
-#define ET_EXEC     2
-#define ET_DYN      3
-#define PT_LOAD     1
-#define PT_DYNAMIC  2
-#define PT_INTERP   3
-#define EI_CLASS    4
-#define EI_DATA     5
-#define PF_X        1
-#define PF_W        2
-#define PF_R        4
-#define AT_PHDR     3
-#define AT_PHENT    4
-#define AT_PHNUM    5
-#define AT_PAGESZ   6
-#define AT_BASE     7
-#define AT_ENTRY    9
-#define AT_UID      11
-#define AT_EUID     12
-#define AT_GID      13
-#define AT_EGID     14
-#define AT_HWCAP    16
-#define AT_HWCAP2   16
-#define AT_SECURE   23
-#define AT_RANDOM   25
-#define AT_EXECFN   31
-
-#define STACK_SIZE  (8ul * 1024 * 1024)
-#define STACK_ALIGN (sizeof(long) * 2)
-#define AUXV_BYTES  (sizeof(long) * 2 * 15)
-
-// from the xnu codebase
-#define _COMM_PAGE_START_ADDRESS      0x0000000FFFFFC000ul
-#define _COMM_PAGE_APRR_SUPPORT       (_COMM_PAGE_START_ADDRESS + 0x10C)
-#define _COMM_PAGE_APRR_WRITE_ENABLE  (_COMM_PAGE_START_ADDRESS + 0x110)
-#define _COMM_PAGE_APRR_WRITE_DISABLE (_COMM_PAGE_START_ADDRESS + 0x118)
-
-#define MIN(X, Y) ((Y) > (X) ? (X) : (Y))
-#define MAX(X, Y) ((Y) < (X) ? (X) : (Y))
-
-#define READ32(S)                                                      \
-  ((unsigned)(255 & (S)[3]) << 030 | (unsigned)(255 & (S)[2]) << 020 | \
-   (unsigned)(255 & (S)[1]) << 010 | (unsigned)(255 & (S)[0]) << 000)
-
-#define READ64(S)                         \
-  ((unsigned long)(255 & (S)[7]) << 070 | \
-   (unsigned long)(255 & (S)[6]) << 060 | \
-   (unsigned long)(255 & (S)[5]) << 050 | \
-   (unsigned long)(255 & (S)[4]) << 040 | \
-   (unsigned long)(255 & (S)[3]) << 030 | \
-   (unsigned long)(255 & (S)[2]) << 020 | \
-   (unsigned long)(255 & (S)[1]) << 010 | \
-   (unsigned long)(255 & (S)[0]) << 000)
-
-struct ElfEhdr {
-  unsigned char e_ident[16];
-  unsigned short e_type;
-  unsigned short e_machine;
-  unsigned e_version;
-  unsigned long e_entry;
-  unsigned long e_phoff;
-  unsigned long e_shoff;
-  unsigned e_flags;
-  unsigned short e_ehsize;
-  unsigned short e_phentsize;
-  unsigned short e_phnum;
-  unsigned short e_shentsize;
-  unsigned short e_shnum;
-  unsigned short e_shstrndx;
-};
-
-struct ElfPhdr {
-  unsigned p_type;
-  unsigned p_flags;
-  unsigned long p_offset;
-  unsigned long p_vaddr;
-  unsigned long p_paddr;
-  unsigned long p_filesz;
-  unsigned long p_memsz;
-  unsigned long p_align;
-};
-
-union ElfEhdrBuf {
-  struct ElfEhdr ehdr;
-  char buf[8192];
-};
-
-union ElfPhdrBuf {
-  struct ElfPhdr phdr;
-  char buf[4096];
-};
-
-struct PathSearcher {
-  unsigned long namelen;
-  const char *name;
-  const char *syspath;
-  char path[1024];
-};
-
-struct ApeLoader {
-  union ElfEhdrBuf ehdr;
-  struct PathSearcher ps;
-  // this memory shall be discarded by the guest
-  //////////////////////////////////////////////
-  // this memory shall be known to guest program
-  union {
-    char argblock[ARG_MAX];
-    long numblock[ARG_MAX / sizeof(long)];
-  };
-  union ElfPhdrBuf phdr;
-  struct Syslib lib;
-  char rando[16];
-};
-
-static int ToLower(int c) {
-  return 'A' <= c && c <= 'Z' ? c + ('a' - 'A') : c;
-}
-
-static unsigned long StrLen(const char *s) {
-  unsigned long n = 0;
-  while (*s++) ++n;
-  return n;
-}
-
-static int StrCmp(const char *l, const char *r) {
-  unsigned long i = 0;
-  while (l[i] == r[i] && r[i]) ++i;
-  return (l[i] & 255) - (r[i] & 255);
-}
-
-static const char *BaseName(const char *s) {
-  int c;
-  const char *b = "";
-  if (s) {
-    while ((c = *s++)) {
-      if (c == '/') {
-        b = s;
-      }
-    }
-  }
-  return b;
-}
-
-static void Bzero(void *a, unsigned long n) {
-  long z;
-  char *p, *e;
-  p = (char *)a;
-  e = p + n;
-  z = 0;
-  while (p + sizeof(z) <= e) {
-    __builtin_memcpy(p, &z, sizeof(z));
-    p += sizeof(z);
-  }
-  while (p < e) {
-    *p++ = 0;
-  }
-}
-
-static const char *MemChr(const char *s, unsigned char c, unsigned long n) {
-  for (; n; --n, ++s) {
-    if ((*s & 255) == c) {
-      return s;
-    }
-  }
-  return 0;
-}
-
-static void *MemMove(void *a, const void *b, unsigned long n) {
-  long w;
-  char *d;
-  const char *s;
-  unsigned long i;
-  d = (char *)a;
-  s = (const char *)b;
-  if (d > s) {
-    while (n >= sizeof(w)) {
-      n -= sizeof(w);
-      __builtin_memcpy(&w, s + n, sizeof(n));
-      __builtin_memcpy(d + n, &w, sizeof(n));
-    }
-    while (n--) {
-      d[n] = s[n];
-    }
-  } else {
-    i = 0;
-    while (i + sizeof(w) <= n) {
-      __builtin_memcpy(&w, s + i, sizeof(i));
-      __builtin_memcpy(d + i, &w, sizeof(i));
-      i += sizeof(w);
-    }
-    for (; i < n; ++i) {
-      d[i] = s[i];
-    }
-  }
-  return d;
-}
-
-static char *GetEnv(char **p, const char *s) {
-  unsigned long i, j;
-  if (p) {
-    for (i = 0; p[i]; ++i) {
-      for (j = 0;; ++j) {
-        if (!s[j]) {
-          if (p[i][j] == '=') {
-            return p[i] + j + 1;
-          }
-          break;
-        }
-        if (s[j] != p[i][j]) {
-          break;
-        }
-      }
-    }
-  }
-  return 0;
-}
-
-static char *Utoa(char p[21], unsigned long x) {
-  char t;
-  unsigned long i, a, b;
-  i = 0;
-  do {
-    p[i++] = x % 10 + '0';
-    x = x / 10;
-  } while (x > 0);
-  p[i] = '\0';
-  if (i) {
-    for (a = 0, b = i - 1; a < b; ++a, --b) {
-      t = p[a];
-      p[a] = p[b];
-      p[b] = t;
-    }
-  }
-  return p + i;
-}
-
-static char *Itoa(char p[21], long x) {
-  if (x < 0) *p++ = '-', x = -(unsigned long)x;
-  return Utoa(p, x);
-}
-
-static void Emit(const char *s) {
-  write(2, s, StrLen(s));
-}
-
-static long Print(int fd, const char *s, ...) {
-  int c;
-  unsigned n;
-  char b[512];
-  __builtin_va_list va;
-  __builtin_va_start(va, s);
-  for (n = 0; s; s = __builtin_va_arg(va, const char *)) {
-    while ((c = *s++)) {
-      if (n < sizeof(b)) {
-        b[n++] = c;
-      }
-    }
-  }
-  __builtin_va_end(va);
-  return write(fd, b, n);
-}
-
-static void Perror(const char *thing, long rc, const char *reason) {
-  char ibuf[21];
-  ibuf[0] = 0;
-  if (rc) Itoa(ibuf, -rc);
-  Print(2, "ape error: ", thing, ": ", reason, rc ? " failed w/ errno " : "",
-        ibuf, "\n", 0l);
-}
-
-__attribute__((__noreturn__)) static void Pexit(const char *c, int failed,
-                                                const char *s) {
-  Perror(c, failed, s);
-  _exit(127);
-}
-
-static char EndsWithIgnoreCase(const char *p, unsigned long n, const char *s) {
-  unsigned long i, m;
-  if (n >= (m = StrLen(s))) {
-    for (i = n - m; i < n; ++i) {
-      if (ToLower(p[i]) != *s++) {
-        return 0;
-      }
-    }
-    return 1;
-  } else {
-    return 0;
-  }
-}
-
-static char IsComPath(struct PathSearcher *ps) {
-  return EndsWithIgnoreCase(ps->name, ps->namelen, ".com") ||
-         EndsWithIgnoreCase(ps->name, ps->namelen, ".exe") ||
-         EndsWithIgnoreCase(ps->name, ps->namelen, ".com.dbg");
-}
-
-static char AccessCommand(struct PathSearcher *ps, const char *suffix,
-                          unsigned long pathlen) {
-  unsigned long suffixlen;
-  suffixlen = StrLen(suffix);
-  if (pathlen + 1 + ps->namelen + suffixlen + 1 > sizeof(ps->path)) return 0;
-  if (pathlen && ps->path[pathlen - 1] != '/') ps->path[pathlen++] = '/';
-  MemMove(ps->path + pathlen, ps->name, ps->namelen);
-  MemMove(ps->path + pathlen + ps->namelen, suffix, suffixlen + 1);
-  return !access(ps->path, X_OK);
-}
-
-static char SearchPath(struct PathSearcher *ps, const char *suffix) {
-  const char *p;
-  unsigned long i;
-  for (p = ps->syspath;;) {
-    for (i = 0; p[i] && p[i] != ':'; ++i) {
-      if (i < sizeof(ps->path)) {
-        ps->path[i] = p[i];
-      }
-    }
-    if (AccessCommand(ps, suffix, i)) {
-      return 1;
-    } else if (p[i] == ':') {
-      p += i + 1;
-    } else {
-      return 0;
-    }
-  }
-}
-
-static char FindCommand(struct PathSearcher *ps, const char *suffix) {
-  if (MemChr(ps->name, '/', ps->namelen)) {
-    ps->path[0] = 0;
-    return AccessCommand(ps, suffix, 0);
-  }
-  return SearchPath(ps, suffix);
-}
-
-static char *Commandv(struct PathSearcher *ps, const char *name,
-                      const char *syspath) {
-  ps->syspath = syspath ? syspath : "/bin:/usr/local/bin:/usr/bin";
-  if (!(ps->namelen = StrLen((ps->name = name)))) return 0;
-  if (ps->namelen + 1 > sizeof(ps->path)) return 0;
-  if (FindCommand(ps, "") || (!IsComPath(ps) && FindCommand(ps, ".com"))) {
-    return ps->path;
-  } else {
-    return 0;
-  }
-}
-
-static void pthread_jit_write_protect_np_workaround(int enabled) {
-  int count_start = 8192;
-  volatile int count = count_start;
-  unsigned long *addr, *other, val, val2, reread = -1;
-  addr = (unsigned long *)(!enabled ? _COMM_PAGE_APRR_WRITE_ENABLE
-                                    : _COMM_PAGE_APRR_WRITE_DISABLE);
-  other = (unsigned long *)(enabled ? _COMM_PAGE_APRR_WRITE_ENABLE
-                                    : _COMM_PAGE_APRR_WRITE_DISABLE);
-  switch (*(volatile unsigned char *)_COMM_PAGE_APRR_SUPPORT) {
-    case 1:
-      do {
-        val = *addr;
-        reread = -1;
-        asm volatile("msr\tS3_4_c15_c2_7,%0\n"
-                     "isb\tsy\n"
-                     : /* no outputs */
-                     : "r"(val)
-                     : "memory");
-        val2 = *addr;
-        asm volatile("mrs\t%0,S3_4_c15_c2_7\n"
-                     : "=r"(reread)
-                     : /* no inputs */
-                     : "memory");
-        if (val2 == reread) {
-          return;
-        }
-        usleep(10);
-      } while (count-- > 0);
-      break;
-    case 3:
-      do {
-        val = *addr;
-        reread = -1;
-        asm volatile("msr\tS3_6_c15_c1_5,%0\n"
-                     "isb\tsy\n"
-                     : /* no outputs */
-                     : "r"(val)
-                     : "memory");
-        val2 = *addr;
-        asm volatile("mrs\t%0,S3_6_c15_c1_5\n"
-                     : "=r"(reread)
-                     : /* no inputs */
-                     : "memory");
-        if (val2 == reread) {
-          return;
-        }
-        usleep(10);
-      } while (count-- > 0);
-      break;
-    default:
-      pthread_jit_write_protect_np(enabled);
-      return;
-  }
-  Pexit("ape", 0, "failed to set jit write protection");
-}
-
-__attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
-                                                long *sp, struct ElfEhdr *e,
-                                                struct ElfPhdr *p,
-                                                struct Syslib *lib) {
-  long rc;
-  int prot;
-  int flags;
-  int found_entry;
-  unsigned long dynbase;
-  unsigned long virtmin, virtmax;
-  unsigned long a, b, c, d, i, j;
-
-  /* validate elf */
-  found_entry = 0;
-  virtmin = virtmax = 0;
-  for (i = 0; i < e->e_phnum; ++i) {
-    if (p[i].p_type != PT_LOAD) {
-      continue;
-    }
-    if (p[i].p_filesz > p[i].p_memsz) {
-      Pexit(exe, 0, "ELF p_filesz exceeds p_memsz");
-    }
-    if ((p[i].p_flags & (PF_W | PF_X)) == (PF_W | PF_X)) {
-      Pexit(exe, 0, "Apple Silicon doesn't allow RWX memory");
-    }
-    if ((p[i].p_vaddr & (pagesz - 1)) != (p[i].p_offset & (pagesz - 1))) {
-      Pexit(exe, 0, "ELF p_vaddr incongruent w/ p_offset modulo 16384");
-    }
-    if (p[i].p_vaddr + p[i].p_memsz < p[i].p_vaddr ||
-        p[i].p_vaddr + p[i].p_memsz + (pagesz - 1) < p[i].p_vaddr) {
-      Pexit(exe, 0, "ELF p_vaddr + p_memsz overflow");
-    }
-    if (p[i].p_offset + p[i].p_filesz < p[i].p_offset ||
-        p[i].p_offset + p[i].p_filesz + (pagesz - 1) < p[i].p_offset) {
-      Pexit(exe, 0, "ELF p_offset + p_filesz overflow");
-    }
-    a = p[i].p_vaddr & -pagesz;
-    b = (p[i].p_vaddr + p[i].p_memsz + (pagesz - 1)) & -pagesz;
-    for (j = i + 1; j < e->e_phnum; ++j) {
-      if (p[j].p_type != PT_LOAD) continue;
-      c = p[j].p_vaddr & -pagesz;
-      d = (p[j].p_vaddr + p[j].p_memsz + (pagesz - 1)) & -pagesz;
-      if (MAX(a, c) < MIN(b, d)) {
-        Pexit(exe, 0, "ELF segments overlap each others virtual memory");
-      }
-    }
-    if (p[i].p_flags & PF_X) {
-      if (p[i].p_vaddr <= e->e_entry &&
-          e->e_entry < p[i].p_vaddr + p[i].p_memsz) {
-        found_entry = 1;
-      }
-    }
-    if (p[i].p_vaddr < virtmin) {
-      virtmin = p[i].p_vaddr;
-    }
-    if (p[i].p_vaddr + p[i].p_memsz > virtmax) {
-      virtmax = p[i].p_vaddr + p[i].p_memsz;
-    }
-  }
-  if (!found_entry) {
-    Pexit(exe, 0, "ELF entrypoint not found in PT_LOAD with PF_X");
-  }
-
-  /* choose loading address for dynamic elf executables
-     that maintains relative distances between segments */
-  if (e->e_type == ET_DYN) {
-    rc = (long)mmap(0, virtmax - virtmin, PROT_NONE,
-                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-    if (rc < 0) Pexit(exe, rc, "pie mmap");
-    dynbase = rc;
-    if (dynbase & (pagesz - 1)) {
-      Pexit(exe, 0, "OS mmap incongruent w/ AT_PAGESZ");
-    }
-    if (dynbase + virtmin < dynbase) {
-      Pexit(exe, 0, "ELF dynamic base overflow");
-    }
-  } else {
-    dynbase = 0;
-  }
-
-  /* load elf */
-  for (i = 0; i < e->e_phnum; ++i) {
-    if (p[i].p_type != PT_LOAD) continue;
-    if (!p[i].p_memsz) continue;
-
-    /* configure mapping */
-    prot = 0;
-    flags = MAP_FIXED | MAP_PRIVATE;
-    if (p[i].p_flags & PF_R) prot |= PROT_READ;
-    if (p[i].p_flags & PF_W) prot |= PROT_WRITE;
-    if (p[i].p_flags & PF_X) prot |= PROT_EXEC;
-
-    /* load from file */
-    if (p[i].p_filesz) {
-      void *addr;
-      int prot1, prot2;
-      unsigned long size;
-      prot1 = prot;
-      prot2 = prot;
-      a = p[i].p_vaddr + p[i].p_filesz; /* end of file content */
-      b = (a + (pagesz - 1)) & -pagesz; /* first pure bss page */
-      c = p[i].p_vaddr + p[i].p_memsz;  /* end of segment data */
-      if (b > c) b = c;
-      if (c > b && (~prot1 & PROT_WRITE)) {
-        prot1 = PROT_READ | PROT_WRITE;
-      }
-      addr = (void *)(dynbase + (p[i].p_vaddr & -pagesz));
-      size = (p[i].p_vaddr & (pagesz - 1)) + p[i].p_filesz;
-      rc = (long)mmap(addr, size, prot1, flags, fd, p[i].p_offset & -pagesz);
-      if (rc < 0) Pexit(exe, rc, "prog mmap");
-      if (c > b) Bzero((void *)(dynbase + a), b - a);
-      if (prot2 != prot1) {
-        rc = mprotect(addr, size, prot2);
-        if (rc < 0) Pexit(exe, rc, "prog mprotect");
-      }
-    }
-
-    /* allocate extra bss */
-    a = p[i].p_vaddr + p[i].p_filesz;
-    a = (a + (pagesz - 1)) & -pagesz;
-    b = p[i].p_vaddr + p[i].p_memsz;
-    if (b > a) {
-      flags |= MAP_ANONYMOUS;
-      rc = (long)mmap((void *)(dynbase + a), b - a, prot, flags, -1, 0);
-      if (rc < 0) Pexit(exe, rc, "bss mmap");
-    }
-  }
-
-  /* finish up */
-  close(fd);
-
-  register long *x0 asm("x0") = sp;
-  register struct Syslib *x15 asm("x15") = lib;
-  register long x16 asm("x16") = e->e_entry;
-  asm volatile("mov\tx1,#0\n\t"
-               "mov\tx2,#0\n\t"
-               "mov\tx3,#0\n\t"
-               "mov\tx4,#0\n\t"
-               "mov\tx5,#0\n\t"
-               "mov\tx6,#0\n\t"
-               "mov\tx7,#0\n\t"
-               "mov\tx8,#0\n\t"
-               "mov\tx9,#0\n\t"
-               "mov\tx10,#0\n\t"
-               "mov\tx11,#0\n\t"
-               "mov\tx12,#0\n\t"
-               "mov\tx13,#0\n\t"
-               "mov\tx14,#0\n\t"
-               "mov\tx17,#0\n\t"
-               "mov\tx19,#0\n\t"
-               "mov\tx20,#0\n\t"
-               "mov\tx21,#0\n\t"
-               "mov\tx22,#0\n\t"
-               "mov\tx23,#0\n\t"
-               "mov\tx24,#0\n\t"
-               "mov\tx25,#0\n\t"
-               "mov\tx26,#0\n\t"
-               "mov\tx27,#0\n\t"
-               "mov\tx28,#0\n\t"
-               "mov\tx29,#0\n\t"
-               "mov\tx30,#0\n\t"
-               "mov\tsp,x0\n\t"
-               "mov\tx0,#0\n\t"
-               "br\tx16"
-               : /* no outputs */
-               : "r"(x0), "r"(x15), "r"(x16)
-               : "memory");
-  __builtin_unreachable();
-}
-
-static const char *TryElf(struct ApeLoader *M, const char *exe, int fd,
-                          long *sp, long *bp, char *execfn) {
-  long i, rc;
-  unsigned size;
-  struct ElfEhdr *e;
-  struct ElfPhdr *p;
-
-  /* validate elf header */
-  e = &M->ehdr.ehdr;
-  if (READ32(M->ehdr.buf) != READ32("\177ELF")) {
-    return "didn't embed ELF magic";
-  }
-  if (e->e_ident[EI_CLASS] == ELFCLASS32) {
-    return "32-bit ELF isn't supported";
-  }
-  if (e->e_type != ET_EXEC && e->e_type != ET_DYN) {
-    return "ELF not ET_EXEC or ET_DYN";
-  }
-  if (e->e_machine != EM_AARCH64) {
-    return "couldn't find ELF header with ARM64 machine type";
-  }
-  if (e->e_phentsize != sizeof(struct ElfPhdr)) {
-    Pexit(exe, 0, "e_phentsize is wrong");
-  }
-  size = e->e_phnum;
-  if ((size *= sizeof(struct ElfPhdr)) > sizeof(M->phdr.buf)) {
-    Pexit(exe, 0, "too many ELF program headers");
-  }
-
-  /* read program headers */
-  rc = pread(fd, M->phdr.buf, size, M->ehdr.ehdr.e_phoff);
-  if (rc < 0) return "failed to read ELF program headers";
-  if (rc != size) return "truncated read of ELF program headers";
-
-  /* bail on recoverable program header errors */
-  p = &M->phdr.phdr;
-  for (i = 0; i < e->e_phnum; ++i) {
-    if (p[i].p_type == PT_INTERP) {
-      return "ELF has PT_INTERP which isn't supported";
-    }
-    if (p[i].p_type == PT_DYNAMIC) {
-      return "ELF has PT_DYNAMIC which isn't supported";
-    }
-  }
-
-  /* remove empty program headers */
-  for (i = 0; i < e->e_phnum;) {
-    if (p[i].p_type == PT_LOAD && !p[i].p_memsz) {
-      if (i + 1 < e->e_phnum) {
-        MemMove(p + i, p + i + 1,
-                (e->e_phnum - (i + 1)) * sizeof(struct ElfPhdr));
-      }
-      --e->e_phnum;
-    } else {
-      ++i;
-    }
-  }
-
-  /*
-   * merge adjacent loads that are contiguous with equal protection,
-   * which prevents our program header overlap check from needlessly
-   * failing later on; it also shaves away a microsecond of latency,
-   * since every program header requires invoking at least 1 syscall
-   */
-  for (i = 0; i + 1 < e->e_phnum;) {
-    if (p[i].p_type == PT_LOAD && p[i + 1].p_type == PT_LOAD &&
-        ((p[i].p_flags & (PF_R | PF_W | PF_X)) ==
-         (p[i + 1].p_flags & (PF_R | PF_W | PF_X))) &&
-        ((p[i].p_offset + p[i].p_filesz + (pagesz - 1)) & -pagesz) -
-                (p[i + 1].p_offset & -pagesz) <=
-            pagesz &&
-        ((p[i].p_vaddr + p[i].p_memsz + (pagesz - 1)) & -pagesz) -
-                (p[i + 1].p_vaddr & -pagesz) <=
-            pagesz) {
-      p[i].p_memsz = (p[i + 1].p_vaddr + p[i + 1].p_memsz) - p[i].p_vaddr;
-      p[i].p_filesz = (p[i + 1].p_offset + p[i + 1].p_filesz) - p[i].p_offset;
-      if (i + 2 < e->e_phnum) {
-        MemMove(p + i + 1, p + i + 2,
-                (e->e_phnum - (i + 2)) * sizeof(struct ElfPhdr));
-      }
-      --e->e_phnum;
-    } else {
-      ++i;
-    }
-  }
-
-  /* simulate linux auxiliary values */
-  long auxv[][2] = {
-      {AT_PHDR, (long)&M->phdr.phdr},        //
-      {AT_PHENT, M->ehdr.ehdr.e_phentsize},  //
-      {AT_PHNUM, M->ehdr.ehdr.e_phnum},      //
-      {AT_ENTRY, M->ehdr.ehdr.e_entry},      //
-      {AT_PAGESZ, pagesz},                   //
-      {AT_UID, getuid()},                    //
-      {AT_EUID, geteuid()},                  //
-      {AT_GID, getgid()},                    //
-      {AT_EGID, getegid()},                  //
-      {AT_HWCAP, 0xffb3ffffu},               //
-      {AT_HWCAP2, 0x181},                    //
-      {AT_SECURE, issetugid()},              //
-      {AT_RANDOM, (long)M->rando},           //
-      {AT_EXECFN, (long)execfn},             //
-      {0, 0},                                //
-  };
-  _Static_assert(sizeof(auxv) == AUXV_BYTES,
-                 "Please update the AUXV_BYTES constant");
-  MemMove(bp, auxv, sizeof(auxv));
-
-  /* we're now ready to load */
-  Spawn(exe, fd, sp, e, p, &M->lib);
-}
-
-__attribute__((__noinline__)) static long sysret(long rc) {
-  return rc == -1 ? -errno : rc;
-}
-
-static long sys_fork(void) {
-  return sysret(fork());
-}
-
-static long sys_pipe(int pfds[2]) {
-  return sysret(pipe(pfds));
-}
-
-static long sys_clock_gettime(int clock, struct timespec *ts) {
-  return sysret(clock_gettime(clock, ts));
-}
-
-static long sys_nanosleep(const struct timespec *req, struct timespec *rem) {
-  return sysret(nanosleep(req, rem));
-}
-
-static long sys_mmap(void *addr, size_t size, int prot, int flags, int fd,
-                     off_t off) {
-  return sysret((long)mmap(addr, size, prot, flags, fd, off));
-}
-
-int main(int argc, char **argv, char **envp) {
-  long z;
-  void *map;
-  long *sp, *bp, *ip;
-  int c, i, n, fd, rc;
-  struct ApeLoader *M;
-  unsigned char rando[24];
-  char *p, *pe, *tp, *exe, *prog, *execfn;
-
-  // generate some hard random data
-  if (getentropy(rando, sizeof(rando))) {
-    Pexit(argv[0], -1, "getentropy");
-  }
-
-  // make the stack look like a linux one
-  map = mmap((void *)(0x7f0000000000 | (long)rando[23] << 32), STACK_SIZE,
-             PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
-  if (map == MAP_FAILED) {
-    Pexit(argv[0], -1, "stack mmap");
-  }
-
-  // put argument block at top of allocated stack
-  z = (long)map;
-  z += STACK_SIZE - sizeof(struct ApeLoader);
-  z &= -_Alignof(struct ApeLoader);
-  M = (struct ApeLoader *)z;
-
-  // expose screwy apple libs
-  M->lib.magic = SYSLIB_MAGIC;
-  M->lib.version = SYSLIB_VERSION;
-  M->lib.fork = sys_fork;
-  M->lib.pipe = sys_pipe;
-  M->lib.clock_gettime = sys_clock_gettime;
-  M->lib.nanosleep = sys_nanosleep;
-  M->lib.mmap = sys_mmap;
-  M->lib.pthread_jit_write_protect_supported_np =
-      pthread_jit_write_protect_supported_np;
-  M->lib.pthread_jit_write_protect_np = pthread_jit_write_protect_np_workaround;
-  M->lib.pthread_create = pthread_create;
-  M->lib.pthread_exit = pthread_exit;
-  M->lib.pthread_kill = pthread_kill;
-  M->lib.pthread_sigmask = pthread_sigmask;
-  M->lib.pthread_setname_np = pthread_setname_np;
-  M->lib.dispatch_semaphore_create = dispatch_semaphore_create;
-  M->lib.dispatch_semaphore_signal = dispatch_semaphore_signal;
-  M->lib.dispatch_semaphore_wait = dispatch_semaphore_wait;
-  M->lib.dispatch_walltime = dispatch_walltime;
-
-  // copy system provided argument block
-  bp = M->numblock;
-  tp = M->argblock + sizeof(M->argblock);
-  *bp++ = argc;
-  for (i = 0; i < argc; ++i) {
-    tp -= (n = StrLen(argv[i]) + 1);
-    MemMove(tp, argv[i], n);
-    *bp++ = (long)tp;
-  }
-  *bp++ = 0;
-  for (i = 0; envp[i]; ++i) {
-    tp -= (n = StrLen(envp[i]) + 1);
-    MemMove(tp, envp[i], n);
-    *bp++ = (long)tp;
-  }
-  *bp++ = 0;
-
-  // get arguments that point into our block
-  sp = M->numblock;
-  argc = *sp;
-  argv = (char **)(sp + 1);
-  envp = (char **)(sp + 1 + argc + 1);
-
-  // xnu stores getauxval(at_execfn) in getenv("_")
-  execfn = argc > 0 ? argv[0] : 0;
-  for (i = 0; envp[i]; ++i) {
-    if (envp[i][0] == '_' && envp[i][1] == '=') {
-      execfn = envp[i] + 2;
-      break;
-    }
-  }
-
-  // interpret command line arguments
-  if (argc >= 3 && !StrCmp(argv[1], "-")) {
-    // if the first argument is a hyphen then we give the user the
-    // power to change argv[0] or omit it entirely. most operating
-    // systems don't permit the omission of argv[0] but we do, b/c
-    // it's specified by ANSI X3.159-1988.
-    prog = (char *)sp[3];
-    argc = sp[3] = sp[0] - 3;
-    argv = (char **)((sp += 3) + 1);
-  } else if (argc < 2) {
-    Emit("usage: ape   PROG [ARGV1,ARGV2,...]\n"
-         "       ape - PROG [ARGV0,ARGV1,...]\n"
-         "actually portable executable loader silicon 1.5\n"
-         "copyright 2023 justine alexandra roberts tunney\n"
-         "https://justine.lol/ape.html\n");
-    _exit(1);
-  } else {
-    prog = (char *)sp[2];
-    argc = sp[1] = sp[0] - 1;
-    argv = (char **)((sp += 1) + 1);
-  }
-
-  // search for executable
-  if (!(exe = Commandv(&M->ps, prog, GetEnv(envp, "PATH")))) {
-    Pexit(prog, 0, "not found (maybe chmod +x)");
-  } else if ((fd = openat(AT_FDCWD, exe, O_RDONLY)) < 0) {
-    Pexit(exe, -1, "open");
-  } else if ((rc = read(fd, M->ehdr.buf, sizeof(M->ehdr.buf))) < 0) {
-    Pexit(exe, -1, "read");
-  } else if ((unsigned long)rc < sizeof(M->ehdr.ehdr)) {
-    Pexit(exe, 0, "too small");
-  }
-  pe = M->ehdr.buf + rc;
-
-  // resolve argv[0] to reflect path search
-  if ((argc > 0 && *prog != '/' && *exe == '/' && !StrCmp(prog, argv[0])) ||
-      !StrCmp(BaseName(prog), argv[0])) {
-    tp -= (n = StrLen(exe) + 1);
-    MemMove(tp, exe, n);
-    argv[0] = tp;
-  }
-
-  // squeeze and align the argument block
-  ip = (long *)(((long)tp - AUXV_BYTES) & -sizeof(long));
-  ip -= (n = bp - sp);
-  ip = (long *)((long)ip & -STACK_ALIGN);
-  MemMove(ip, sp, n * sizeof(long));
-  bp = ip + n;
-  sp = ip;
-
-  // relocate the guest's random numbers
-  MemMove(M->rando, rando, sizeof(M->rando));
-  Bzero(rando, sizeof(rando));
-
-  // ape intended behavior
-  // 1. if file is an elf executable, it'll be used as-is
-  // 2. if ape, will scan shell script for elf printf statements
-  // 3. shell script may have multiple lines producing elf headers
-  // 4. all elf printf lines must exist in the first 8192 bytes of file
-  // 5. elf program headers may appear anywhere in the binary
-  if (READ64(M->ehdr.buf) == READ64("MZqFpD='") ||
-      READ64(M->ehdr.buf) == READ64("jartsr='") ||
-      READ64(M->ehdr.buf) == READ64("APEDBG='")) {
-    for (p = M->ehdr.buf; p < pe; ++p) {
-      if (READ64(p) != READ64("printf '")) {
-        continue;
-      }
-      for (i = 0, p += 8; p + 3 < pe && (c = *p++) != '\'';) {
-        if (c == '\\') {
-          if ('0' <= *p && *p <= '7') {
-            c = *p++ - '0';
-            if ('0' <= *p && *p <= '7') {
-              c *= 8;
-              c += *p++ - '0';
-              if ('0' <= *p && *p <= '7') {
-                c *= 8;
-                c += *p++ - '0';
-              }
-            }
-          }
-        }
-        M->ehdr.buf[i++] = c;
-        if (i >= sizeof(M->ehdr.buf)) {
-          break;
-        }
-      }
-      if (i >= sizeof(M->ehdr.ehdr)) {
-        TryElf(M, exe, fd, sp, bp, execfn);
-      }
-    }
-  }
-  Pexit(exe, 0, TryElf(M, exe, fd, sp, bp, execfn));
-}

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

@@ -177,40 +177,16 @@
 #include "ape/macros.internal.h"
 #include "ape/relocations.h"
 #include "libc/dce.h"
-#include "libc/elf/def.h"
-#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
-
-#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);
-  Ram PT_LOAD FLAGS(PF_W|PF_R);
-  stack PT_GNU_STACK FLAGS(PF_W|PF_R);
+  Head PT_LOAD FLAGS(5);
+  Rom PT_LOAD FLAGS(5);
+  Ram PT_LOAD FLAGS(6);
+  stack PT_GNU_STACK FLAGS(6);
 }
 
 SECTIONS {
@@ -220,62 +196,54 @@ 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(__SIZEOF_POINTER__);
-    ape_phdrs = .;
+    HIDDEN(ape_phdrs = .);
     KEEP(*(.elf.phdrs))
-    ape_phdrs_end = .;
-
-    KEEP(*(.emushprologue))
-    KEEP(*(.emush))
-    KEEP(*(.emushepilogue))
+    HIDDEN(ape_phdrs_end = .);
 
     /* OpenBSD */
     . = ALIGN(__SIZEOF_POINTER__);
-    ape_note = .;
+    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(__SIZEOF_POINTER__);
-    ape_macho_end = .;
-
-    /* APE loader */
-    KEEP(*(.ape.loader))
-    . = ALIGN(CODE_GRANULE);
+    HIDDEN(ape_macho_end = .);
 
     KEEP(*(.ape.pad.head))
-    . = ALIGN(SupportsWindows() || SupportsMetal() ? CONSTANT(COMMONPAGESIZE) : 16);
-    _ehead = .;
+    . = ALIGN(SupportsWindows() || SupportsMetal() ? PAGESIZE : 16);
+    HIDDEN(_ehead = .);
   } :Head
 
 /*BEGIN: nt addressability guarantee */
 
   .text . : {
-    BYTE(0x90) /* TODO: fix blinkenlights symbol __map_phdrs */
     /* Code that needs to be addressable in Real Mode */
     *(.text.real)
     KEEP(*(SORT_BY_NAME(.sort.text.real.*)))
-    _ereal = .;
+    HIDDEN(_ereal = .);
+    . += 1;
+
 /*END: realmode addressability guarantee */
-/*BEGIN: morphable code */
-    . += CODE_GRANULE;
 
     /* Normal Code */
     *(.start)
@@ -297,7 +265,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))
@@ -312,28 +279,25 @@ SECTIONS {
 
     /* Privileged code invulnerable to magic */
     KEEP(*(.ape.pad.privileged));
-    . = ALIGN(__privileged_end > __privileged_start ? CONSTANT(COMMONPAGESIZE) : 1);
-/*END: morphable code */
-    __privileged_start = .;
+    . += . > 0 ? 1 : 0;
+    HIDDEN(__privileged_start = .);
+    . += . > 0 ? 1 : 0;
     *(.privileged)
-    __privileged_end = .;
-
-    KEEP(*(.ape.pad.text))
-    . = ALIGN(CONSTANT(COMMONPAGESIZE));
-/*END: Read Only Data (only needed for initialization) */
-  } :Cod
+    HIDDEN(__privileged_end = .);
+    . += . > 0 ? 1 : 0;
 
 /*BEGIN: Read Only Data */
 
-  .rodata . : {
-    KEEP(*(.rodata.pytab.0));
-    KEEP(*(.rodata.pytab.1));
-    KEEP(*(.rodata.pytab.2));
+    KEEP(*(.ape.pad.rodata));
 
     *(.rodata .rodata.*)
     *(.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))
@@ -341,30 +305,25 @@ 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__);
-    __init_array_start = .;
+    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))
-    __init_array_end = .;
+    PROVIDE_HIDDEN(__init_array_end = .);
 
     . = ALIGN(__SIZEOF_POINTER__);
-    __fini_array_start = .;
+    PROVIDE_HIDDEN(__fini_array_start = .);
     KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*)
            SORT_BY_INIT_PRIORITY(.dtors.*)))
-    KEEP(*(.fini_array))
     KEEP(*(.dtors))
-    __fini_array_end = .;
+    PROVIDE_HIDDEN(__fini_array_end = .);
 
     /* Encoded Data Structures w/ Linear Initialization Order */
     KEEP(*(.initroprologue))
@@ -372,50 +331,20 @@ SECTIONS {
     KEEP(*(.initroepilogue))
     KEEP(*(SORT_BY_NAME(.sort.rodata.*)))
 
-/*END: read-only data that's only needed for initialization */
-
-  } :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(CONSTANT(COMMONPAGESIZE));
-    _etext = .;
-    PROVIDE(etext = .);
-  } :Tls :Rom
+    KEEP(*(.ape.pad.text))
+    . = ALIGN(PAGESIZE);
+    HIDDEN(_etext = .);
+    PROVIDE_HIDDEN(etext = .);
+/*END: Read Only Data (only needed for initialization) */
 /*END: Read Only Data */
-
-  . = DATA_SEGMENT_ALIGN(CONSTANT(COMMONPAGESIZE), CONSTANT(COMMONPAGESIZE));
-  . = DATA_SEGMENT_RELRO_END(0, .);
-
-/* 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
+  } :Rom
 
   .data . : {
 /*BEGIN: Read/Write Data */
-#if SupportsWindows()
-    KEEP(*(SORT_BY_NAME(.piro.data.sort.iat.*)))
-#endif
-/*BEGIN: NT FORK COPYING */
     KEEP(*(.dataprologue))
     *(.data .data.*)
-    *(.PyRuntime) /* for python */
-    *(.subrs) /* for emacs */
     KEEP(*(SORT_BY_NAME(.sort.data.*)))
-    . += . > 0 ? CODE_GRANULE : 0;
+    . += . > 0 ? 1 : 0;
 
     KEEP(*(.gotprologue))
     *(.got)
@@ -428,29 +357,32 @@ SECTIONS {
 /*BEGIN: Post-Initialization Read-Only */
     . = ALIGN(__SIZEOF_POINTER__);
     KEEP(*(SORT_BY_NAME(.piro.relo.sort.*)))
+    PROVIDE_HIDDEN(__relo_end = .);
     . = ALIGN(__SIZEOF_POINTER__);
     KEEP(*(SORT_BY_NAME(.piro.data.sort.*)))
     KEEP(*(.piro.pad.data))
-    KEEP(*(.dataepilogue))
-    . = ALIGN(512);
-/*END: NT FORK COPYING */
-    _edata = .;
-    PROVIDE(edata = .);
-    _ezip = .; /* <-- very deprecated */
+    . = ALIGN(PAGESIZE);
+    HIDDEN(_edata = .);
+    PROVIDE_HIDDEN(edata = .);
   } :Ram
 
 /*END:   file content that's loaded by o/s */
+/*BEGIN: bss memory void */
+
+  .zip . : {
+    KEEP(*(SORT_BY_NAME(.zip.*)))
+    HIDDEN(_ezip = .);
+  }
+
 /*END:   file content */
 /*BEGIN: bss memory that's addressable */
 
-  .bss : {
-/*BEGIN: NT FORK COPYING */
-    KEEP(*(.bssprologue))
+  .bss ALIGN(64) : {
     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 */
@@ -460,16 +392,10 @@ SECTIONS {
 
     KEEP(*(SORT_BY_NAME(.sort.bss.*)))
 
-    KEEP(*(.bssepilogue))
-
-    . = ALIGN(CONSTANT(COMMONPAGESIZE));
-
-/*END: NT FORK COPYING */
-    _end = .;
-    PROVIDE(end = .);
-  } :Ram
-
-  . = DATA_SEGMENT_END(.);
+    . = ALIGN(FRAMESIZE); /* for brk()/sbrk() allocation */
+    HIDDEN(_end = .);
+    PROVIDE_HIDDEN(end = .);
+  }
 
 /*END: nt addressability guarantee */
 /*END: bsd addressability guarantee */
@@ -497,7 +423,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) }
@@ -506,38 +431,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);
@@ -545,101 +451,106 @@ 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(__privileged_addr = ROUNDDOWN(__privileged_start, PAGESIZE)); 
+HIDDEN(__privileged_size = (ROUNDUP(__privileged_end, PAGESIZE) -
+                            ROUNDDOWN(__privileged_start, PAGESIZE))); 
 
-ape_cod_offset = 0;
-ape_cod_vaddr = ADDR(.head);
-ape_cod_paddr = LOADADDR(.head);
-ape_cod_filesz = SIZEOF(.head) + SIZEOF(.text);
-ape_cod_memsz = ape_cod_filesz;
-ape_cod_align = CONSTANT(COMMONPAGESIZE);
-ape_cod_rva = RVA(ape_cod_vaddr);
+HIDDEN(ape_rom_offset = 0);
+HIDDEN(ape_rom_vaddr = ADDR(.head));
+HIDDEN(ape_rom_paddr = LOADADDR(.head));
+HIDDEN(ape_rom_filesz = LOADADDR(.data) - ape_rom_paddr);
+HIDDEN(ape_rom_memsz = ADDR(.data) - ADDR(.head));
+HIDDEN(ape_rom_align = PAGESIZE);
+HIDDEN(ape_rom_rva = RVA(ape_rom_vaddr));
 
-ape_rom_offset = ape_cod_offset + ape_cod_filesz;
-ape_rom_vaddr = ADDR(.rodata);
-ape_rom_paddr = LOADADDR(.rodata);
-ape_rom_filesz = SIZEOF(.rodata) + SIZEOF(.tdata);
-ape_rom_memsz = ape_rom_filesz;
-ape_rom_align = CONSTANT(COMMONPAGESIZE);
-ape_rom_rva = RVA(ape_rom_vaddr);
+HIDDEN(ape_ram_offset = ape_rom_offset + ape_rom_filesz);
+HIDDEN(ape_ram_vaddr = ADDR(.data));
+HIDDEN(ape_ram_paddr = LOADADDR(.data));
+HIDDEN(ape_ram_filesz = SIZEOF(.data));
+HIDDEN(ape_ram_memsz = ADDR(.bss) + SIZEOF(.bss) - ape_ram_vaddr);
+HIDDEN(ape_ram_align = PAGESIZE);
+HIDDEN(ape_ram_rva = RVA(ape_ram_vaddr));
 
-ape_ram_offset = ape_rom_offset + ape_rom_filesz;
-ape_ram_vaddr = ADDR(.data);
-ape_ram_paddr = LOADADDR(.data);
-ape_ram_filesz = SIZEOF(.data);
-ape_ram_memsz = SIZEOF(.data) + SIZEOF(.bss);
-ape_ram_align = CONSTANT(COMMONPAGESIZE);
-ape_ram_rva = RVA(ape_ram_vaddr);
+HIDDEN(ape_stack_offset = ape_ram_offset + ape_ram_filesz);
+HIDDEN(ape_stack_vaddr = 0x700000000000 - STACKSIZE);
+HIDDEN(ape_stack_paddr = ape_ram_paddr + ape_ram_filesz);
+HIDDEN(ape_stack_filesz = 0);
+HIDDEN(ape_stack_memsz = STACKSIZE);
+HIDDEN(ape_stack_align = 16);
 
-ape_stack_pf = DEFINED(ape_stack_pf) ? ape_stack_pf : PF_R | PF_W;
-ape_stack_prot = _PF2PROT(ape_stack_pf);
-ape_stack_offset = 0;
-ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000;
-ape_stack_paddr = ape_ram_paddr + ape_ram_filesz;
-ape_stack_filesz = 0;
-ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : APE_STACKSIZE;
-ape_stack_memsz2 = ape_stack_memsz * 2;
-ape_stack_align = 16;
+HIDDEN(ape_note_offset = ape_rom_offset + (ape_note - ape_rom_vaddr));
+HIDDEN(ape_note_vaddr = ape_note);
+HIDDEN(ape_note_paddr = ape_rom_paddr + ape_note_offset);
+HIDDEN(ape_note_filesz = ape_note_end - ape_note);
+HIDDEN(ape_note_memsz = ape_note_filesz);
+HIDDEN(ape_note_align = __SIZEOF_POINTER__);
 
-ape_note_offset = ape_cod_offset + (ape_note - ape_cod_vaddr);
-ape_note_filesz = ape_note_end - ape_note;
-ape_note_memsz = ape_note_filesz;
+HIDDEN(ape_text_offset = ape_rom_offset + LOADADDR(.text) - ape_rom_paddr);
+HIDDEN(ape_text_paddr = LOADADDR(.text));
+HIDDEN(ape_text_vaddr = ADDR(.text));
+HIDDEN(ape_text_filesz = SIZEOF(.text));
+HIDDEN(ape_text_memsz = SIZEOF(.text));
+HIDDEN(ape_text_align = PAGESIZE);
+HIDDEN(ape_text_rva = RVA(ape_text_vaddr));
 
-ape_text_offset = ape_cod_offset + LOADADDR(.text) - ape_cod_paddr;
-ape_text_paddr = LOADADDR(.text);
-ape_text_vaddr = ADDR(.text);
-ape_text_filesz = SIZEOF(.text) + SIZEOF(.rodata) + SIZEOF(.tdata);
-ape_text_memsz = ape_text_filesz;
-ape_text_align = CONSTANT(COMMONPAGESIZE);
-ape_text_rva = RVA(ape_text_vaddr);
+HIDDEN(ape_data_offset = ape_ram_offset + LOADADDR(.data) - ape_ram_paddr);
+HIDDEN(ape_data_paddr = LOADADDR(.data));
+HIDDEN(ape_data_vaddr = ADDR(.data));
+HIDDEN(ape_data_filesz = SIZEOF(.data));
+HIDDEN(ape_data_memsz = SIZEOF(.data));
+HIDDEN(ape_data_align = PAGESIZE);
+HIDDEN(ape_data_rva = RVA(ape_data_vaddr));
 
-/* 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 */
-/* let ape.S dd read past the end of the file into the wrapping binaries */
-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
-            : 0);
+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);
 
-#if defined(APE_IS_SHELL_SCRIPT) && !IsTiny()
+#if SupportsXnu()
+SHSTUB2(ape_macho_dd_skip, RVA(ape_macho) / 8);
+SHSTUB2(ape_macho_dd_count, (ape_macho_end - ape_macho) / 8);
+#endif
 
-#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 SupportsWindows() || SupportsMetal()
+#define LINK_WINDOWS (SupportsWindows() && !DEFINED(EfiMain))
+PFSTUB4(ape_pe_offset, ape_pe - ape_mz);
+HIDDEN(ape_pe_optsz = ape_pe_sections - (ape_pe + 24));
+HIDDEN(ape_pe_shnum = (ape_pe_sections_end - ape_pe_sections) / 40);
+HIDDEN(ape_pe_base = IMAGE_BASE_VIRTUAL);
+HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_iat) : 0);
+HIDDEN(ape_idata_iatsize = LINK_WINDOWS ? ape_idata_iatend - ape_idata_iat : 0);
+HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_idt) : 0);
+HIDDEN(ape_idata_idtsize = LINK_WINDOWS ? ape_idata_idtend - ape_idata_idt : 0);
+HIDDEN(v_ntversion = LINK_WINDOWS ? 6 : 1);
+HIDDEN(v_ntdllchar = LINK_WINDOWS ? 288 : 0);
+HIDDEN(v_ntsubversion = LINK_WINDOWS ? 6 : 5);
+HIDDEN(v_ntsubsystem = (LINK_WINDOWS
+                        ? (DEFINED(GetMessage)
+                           ? kNtImageSubsystemWindowsGui
+                           : kNtImageSubsystemWindowsCui)
+                        : kNtImageSubsystemEfiApplication));
+HIDDEN(ape_pe_entry = LINK_WINDOWS ? WinMain : EfiMain);
+#endif
 
 #if SupportsMetal()
-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_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
@@ -658,8 +569,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);
@@ -668,10 +590,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);
@@ -685,14 +610,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);
@@ -704,7 +622,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);
@@ -722,33 +640,6 @@ CHURN(WinMain);
 #endif /* SupportsWindows() */
 #endif /* SupportsXnu() */
 
-#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;
-#endif
-
-#if SupportsXnu()
-SHSTUB2(ape_macho_dd_skip, RVA(ape_macho) / 8);
-SHSTUB2(ape_macho_dd_count, (ape_macho_end - ape_macho) / 8);
-#endif
-
 ASSERT(DEFINED(ape_mz) ? ape_mz == IMAGE_BASE_VIRTUAL : 1, "linker panic");
 ASSERT((DEFINED(__init_bss_end) ? __init_bss_end : 0) % __SIZEOF_POINTER__ == 0,
        "__init_bss misalign");
@@ -765,15 +656,6 @@ ASSERT(DEFINED(_start) || DEFINED(_start16),
 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);");
-
-ASSERT(ALIGNOF(.tdata) <= TLS_ALIGNMENT && ALIGNOF(.tbss) <= TLS_ALIGNMENT,
-       "_Thread_local _Alignof can't exceed TLS_ALIGNMENT");
-
 /* Let's not be like Knight Capital. */
 /* NOCROSSREFS_TO(.test .text) */
 

ape/ape.mk

@@ -15,289 +15,49 @@
 
 PKGS += APE
 
+APE =	$(APE_DEPS)			\
+	$(APE_OBJS)			\
+	o/$(MODE)/ape/ape.lds
+
+APE_BUILDSAFE =				\
+	$(APE_DEPS)			\
+	o/$(MODE)/ape/ape-buildsafe.o	\
+	o/$(MODE)/ape/ape.lds
+
+APELINK =				\
+	$(COMPILE)			\
+	-ALINK.ape			\
+	$(LINK)				\
+	$(LINKARGS)			\
+	$(OUTPUT_OPTION)
+
 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
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=1 -g $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/start.o: ape/start.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/ape/launch.o: ape/launch.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/ape/systemcall.o: ape/systemcall.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-
-.PHONY: o/$(MODE)/ape
-o/$(MODE)/ape: o/$(MODE)/ape/ape.elf
-
-else
-
-APE =	o/$(MODE)/ape/ape.o			\
-	o/$(MODE)/ape/ape.lds
-
-APELINK =					\
-	$(COMPILE)				\
-	-ALINK.ape				\
-	$(LINK)					\
-	$(LINKARGS)				\
-	$(OUTPUT_OPTION) &&			\
-	$(COMPILE)				\
-	-AFIXUP.ape				\
-	-wT$@					\
-	$(FIXUPOBJ)				\
-	$@
-
-APE_NO_MODIFY_SELF =				\
-	o/$(MODE)/ape/ape.lds			\
-	o/$(MODE)/ape/ape-no-modify-self.o
-
-APE_COPY_SELF =					\
-	o/$(MODE)/ape/ape.lds			\
-	o/$(MODE)/ape/ape-copy-self.o
-
-APE_LOADER_FLAGS =				\
-	-DNDEBUG				\
-	-iquote.				\
-	-Wall					\
-	-Wextra					\
-	-fpie					\
-	-Os					\
-	-ffreestanding				\
-	-mgeneral-regs-only			\
-	-fno-stack-protector			\
-	-fno-ident				\
-	-fno-gnu-unique				\
-	-c					\
-	 $(OUTPUT_OPTION)			\
-	$<
-
-APE_SRCS_C = ape/loader.c
-APE_SRCS_S = $(filter %.S,$(APE_FILES))
-APE_SRCS = $(APE_SRCS_C) $(APE_SRCS_S)
-APE_OBJS = $(APE_SRCS_S:%.S=o/$(MODE)/%.o)
+APE_SRCS = $(filter %.S,$(APE_FILES))
+APE_OBJS = $(APE_SRCS:%.S=o/$(MODE)/%.o)
 APE_CHECKS = $(APE_HDRS:%=o/%.ok)
 
-o/$(MODE)/ape/public/ape.lds: CPPFLAGS += -UCOSMO
-o/$(MODE)/ape/public/ape.lds:			\
-		ape/public/ape.lds		\
-		ape/ape.lds			\
-		ape/ape.internal.h		\
-		ape/macros.internal.h		\
-		ape/relocations.h		\
-		libc/intrin/bits.h		\
-		libc/thread/tls.h		\
-		libc/calls/struct/timespec.h	\
-		libc/thread/thread.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/elf/pf2prot.internal.h	\
-		libc/macros.internal.h		\
-		libc/nt/pedef.internal.h	\
-		libc/str/str.h			\
-		libc/zip.internal.h
+o/$(MODE)/ape/ape.lds:			\
+		ape/ape.lds		\
+		ape/macros.internal.h	\
+		libc/dce.h		\
+		libc/zip.h
 
-o/ape/idata.inc:				\
-		ape/idata.internal.h		\
+o/ape/idata.inc:			\
+		ape/idata.internal.h	\
 		ape/relocations.h
 
-o/$(MODE)/ape/ape-no-modify-self.o:		\
-		ape/ape.S			\
-		ape/macros.internal.h		\
-		ape/notice.inc			\
-		ape/relocations.h		\
-		ape/ape.internal.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/thread/tls.h		\
-		libc/intrin/asancodes.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
-		libc/nexgen32e/uart.internal.h	\
-		libc/calls/metalfile.internal.h	\
-		libc/nexgen32e/vidya.internal.h	\
-		libc/nt/pedef.internal.h	\
-		libc/runtime/e820.internal.h	\
-		libc/runtime/mman.internal.h	\
-		libc/runtime/pc.internal.h	\
-		libc/sysv/consts/prot.h		\
-		ape/blink-linux-aarch64.gz	\
-		ape/blink-xnu-aarch64.gz	\
-		o/$(MODE)/ape/ape.elf
-	@$(COMPILE)				\
-		-AOBJECTIFY.S			\
-		$(OBJECTIFY.S)			\
-		$(OUTPUT_OPTION)		\
-		-DAPE_NO_MODIFY_SELF		\
-		-DAPE_LOADER='"o/$(MODE)/ape/ape.elf"' $<
+$(APE_OBJS):	$(BUILD_FILES)		\
+		ape/ape.mk
 
-o/$(MODE)/ape/ape-copy-self.o:			\
-		ape/ape.S			\
-		ape/macros.internal.h		\
-		ape/notice.inc			\
-		ape/relocations.h		\
-		ape/ape.internal.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/thread/tls.h		\
-		libc/intrin/asancodes.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
-		libc/nexgen32e/uart.internal.h	\
-		libc/calls/metalfile.internal.h	\
-		libc/nexgen32e/vidya.internal.h	\
-		libc/nt/pedef.internal.h	\
-		libc/runtime/e820.internal.h	\
-		libc/runtime/mman.internal.h	\
-		libc/runtime/pc.internal.h	\
-		libc/sysv/consts/prot.h		\
-		ape/blink-linux-aarch64.gz	\
-		ape/blink-xnu-aarch64.gz
-	@$(COMPILE)				\
-		-AOBJECTIFY.S			\
-		$(OBJECTIFY.S)			\
-		$(OUTPUT_OPTION)		\
-		-DAPE_NO_MODIFY_SELF $<
+o/$(MODE)/ape/ape-no-modify-self.o: ape/ape.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -DAPE_NO_MODIFY_SELF $<
 
-o/$(MODE)/ape/loader.o: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=121 -g $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-gcc.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=121 -S -g0 $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-clang.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=121 -S -g0 $(APE_LOADER_FLAGS)
-
-o/$(MODE)/ape/loader-xnu.o: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=8 -g $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-xnu-gcc.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-xnu-clang.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
-
-o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
-	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy.com -f -o $@ $<
-
-o/$(MODE)/ape/ape.macho: o/$(MODE)/ape/ape.elf.dbg
-	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy.com -fm -o $@ $<
-
-APE_LOADER_LDFLAGS =				\
-	-static					\
-	-nostdlib				\
-	--no-dynamic-linker			\
-	-z separate-code			\
-	-z common-page-size=0x1000		\
-	-z max-page-size=0x10000
-
-o/$(MODE)/ape/ape.elf.dbg:			\
-		o/$(MODE)/ape/loader-macho.o	\
-		o/$(MODE)/ape/start.o		\
-		o/$(MODE)/ape/loader.o		\
-		o/$(MODE)/ape/launch.o		\
-		o/$(MODE)/ape/systemcall.o	\
-		ape/loader.lds
-	@$(COMPILE) -ALINK.elf $(LD) $(APE_LOADER_LDFLAGS) -o $@ $(patsubst %.lds,-T %.lds,$^)
+o/$(MODE)/ape/ape-buildsafe.o: ape/ape.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -DAPE_BUILDSAFE $<
 
 .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)			\
+		$(APE_CHECKS)		\
 		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,123 +0,0 @@
-#!/bin/sh
-
-if [ "$(id -u)" -eq 0 ]; then
-  SUDO=
-else
-  SUDO=sudo
-fi
-
-echo "Actually Portable Executable (APE) Installer" >&2
-echo "Author:  Justine Tunney <[email protected]>"  >&2
-
-################################################################################
-# INSTALL APE LOADER SYSTEMWIDE
-
-if [ -f o/depend ] && make -j8 o//ape; then
-  echo "successfully recompiled ape loader" >&2
-elif [ -d build/bootstrap ]; then
-  # if make isn't being used then it's unlikely the user changed the sources
-  # in that case the prebuilt binaries should be completely up-to-date
-  echo "using prebuilt ape loader from cosmo repo" >&2
-  mkdir -p o//ape || exit
-  cp -af build/bootstrap/ape.elf o//ape/ape.elf || exit
-  cp -af build/bootstrap/ape.macho o//ape/ape.macho || exit
-else
-  echo "no cosmopolitan libc repository here" >&2
-  echo "fetching ape loader from justine.lol"  >&2
-  mkdir -p o//ape || exit
-  if command -v wget >/dev/null 2>&1; then
-    wget -qO o//ape/ape.elf https://justine.lol/ape.elf || exit
-    wget -qO o//ape/ape.macho https://justine.lol/ape.macho || exit
-  else
-    curl -Rso o//ape/ape.elf https://justine.lol/ape.elf || exit
-    curl -Rso o//ape/ape.macho https://justine.lol/ape.macho || exit
-  fi
-  chmod +x o//ape/ape.elf || exit
-  chmod +x o//ape/ape.macho || exit
-fi
-
-if [ "$(uname -s)" = "Darwin" ]; then
-  if ! [ /usr/bin/ape -nt o//ape/ape.macho ]; then
-    echo >&2
-    echo "installing o//ape/ape.elf to /usr/bin/ape" >&2
-    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
-    $SUDO cp -f o//ape/ape.macho /usr/bin/ape || exit
-    echo "done" >&2
-  fi
-else
-  if ! [ /usr/bin/ape -nt o//ape/ape.elf ]; then
-    echo >&2
-    echo "installing o//ape/ape.elf to /usr/bin/ape" >&2
-    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
-    $SUDO cp -f o//ape/ape.elf /usr/bin/ape || exit
-    echo "done" >&2
-  fi
-fi
-
-################################################################################
-# REGISTER APE LOADER WITH BINFMT_MISC TOO (LINUX-ONLY)
-
-if [ x"$(uname -s)" = xLinux ]; then
-
-  if [ -e /proc/sys/fs/binfmt_misc/APE ]; then
-    echo >&2
-    echo it looks like APE is already registered with binfmt_misc >&2
-    echo To reinstall please run ape/apeuninstall.sh first >&2
-    echo please check that it is mapped to ape not /bin/sh >&2
-    echo cat /proc/sys/fs/binfmt_misc/APE >&2
-    cat /proc/sys/fs/binfmt_misc/APE >&2
-    exit
-  fi
-
-  if ! [ -e /proc/sys/fs/binfmt_misc ]; then
-    echo >&2
-    echo loading binfmt_misc into your kernel >&2
-    echo you may need to edit configs to persist across reboot >&2
-    echo $SUDO modprobe binfmt_misc >&2
-    $SUDO modprobe binfmt_misc || exit
-    echo done >&2
-  fi
-
-  if ! [ -e /proc/sys/fs/binfmt_misc/register ]; then
-    echo >&2
-    echo mounting binfmt_misc into your kernel >&2
-    echo you may need to edit configs to persist across reboot >&2
-    echo $SUDO mount -t binfmt_misc none /proc/sys/fs/binfmt_misc >&2
-    $SUDO mount -t binfmt_misc none /proc/sys/fs/binfmt_misc || exit
-    echo done >&2
-  fi
-
-  echo >&2
-  echo registering APE with binfmt_misc >&2
-  echo you may need to edit configs to persist across reboot >&2
-  echo '$SUDO sh -c "echo '"'"':APE:M::MZqFpD::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
-  $SUDO sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
-  echo '$SUDO sh -c "echo '"'"':APE-jart:M::jartsr::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
-  $SUDO sh -c "echo ':APE-jart:M::jartsr::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
-  echo done >&2
-
-  if [ x"$(cat /proc/sys/fs/binfmt_misc/status)" = xdisabled ]; then
-    echo >&2
-    echo enabling binfmt_misc >&2
-    echo you may need to edit configs to persist across reboot >&2
-    echo $SUDO sh -c 'echo 1 >/proc/sys/fs/binfmt_misc/status' >&2
-    $SUDO sh -c 'echo 1 >/proc/sys/fs/binfmt_misc/status' || exit
-    echo done >&2
-  fi
-
-fi
-
-################################################################################
-
-{
-  echo
-  echo "------------------------------------------------------------------"
-  echo
-  echo "APE INSTALL COMPLETE"
-  echo
-  echo "If you decide to uninstall APE later on"
-  echo "you may do so using ape/apeuninstall.sh"
-  echo
-  echo "Enjoy your APE loader (>'.')>"
-  echo
-} >&2

ape/apeuninstall.sh

@@ -1,48 +0,0 @@
-#!/bin/sh
-
-if [ "$UID" = "0" ]; then
-  SUDO=
-else
-  SUDO=sudo
-fi
-
-{
-  echo
-  echo "APE Uninstaller intends to run (in pseudo-shell)"
-  echo
-  echo "    sudo echo -1 into /proc/sys/fs/binfmt_misc/APE*"
-  echo "    sudo rm -f /usr/bin/ape ~/.ape /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-blink-0.9.2 \
-         .ape-blink-1.0.0; do
-  rm -f \
-     ~/$x \
-     /tmp/$x \
-     o/tmp/$x \
-     "${TMPDIR:-/tmp}/$x"
-done

ape/idata.internal.h

@@ -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
-".Lidata.ilt.\dll\().\actual":
-	.quad	RVA("\dll\().\actual")
-	.type	".Lidata.ilt.\dll\().\actual",@object
-	.size	".Lidata.ilt.\dll\().\actual",.-".Lidata.ilt.\dll\().\actual"
+	.section .idata.ro.ilt.\dll\().2.\actual,"a",@progbits
+.Lidata.ilt.\dll\().\actual:
+	.quad	RVA((\dll\().\actual))
+	.type	.Lidata.ilt.\dll\().\actual,@object
+	.size	.Lidata.ilt.\dll\().\actual,.-.Lidata.ilt.\dll\().\actual
 	.previous
-	.section ".idata.ro.hnt.\dll\().2.\actual","a",@progbits
-"\dll\().\actual":
-	.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
+  .section .idata.ro.ilt.\name\().1,"aG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
-	.type	"idata.ilt.\name",@object
-"idata.ilt.\name":
+	.type	idata.ilt.\name,@object
+idata.ilt.\name:
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section ".idata.ro.ilt.\name\().3","aG",@progbits,"\name",comdat
+	*/.section .idata.ro.ilt.\name\().3,"aG",@progbits,\name,comdat
 	.quad	0
   .previous
-  .section ".idata.ro.hnt.\name\().1","aG",@progbits,"\name",comdat
+  .section .idata.ro.hnt.\name\().1,"aG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
-	.type	"idata.hnt.\name",@object
-	.equ	"idata.hnt.\name",.
+	.type	idata.hnt.\name,@object
+	.equ	idata.hnt.\name,.
   .previous
-  .section ".piro.data.sort.iat.2.\name\().1","awG",@progbits,"\name",comdat
+  .section .piro.data.sort.iat.2.\name\().1,"awG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
-	.type	"idata.iat.\name",@object
-"idata.iat.\name":
+	.type	idata.iat.\name,@object
+idata.iat.\name:
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section ".piro.data.sort.iat.2.\name\().3","awG",@progbits,"\name",comdat
+	*/.section .piro.data.sort.iat.2.\name\().3,"awG",@progbits,\name,comdat
 	.quad	0
   .previous
   .section .rodata.str1.1,"aSM",@progbits,1
-".Lidata.str.\name":
+.Lidata.str.\name:
 	.asciz	"\name\().dll"
   .previous
 .endm

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-macho.S

@@ -1,95 +0,0 @@
-/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macho.internal.h"
-#include "libc/sysv/consts/prot.h"
-#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
-
-	.section .macho,"a",@progbits
-	.balign	64
-	.long	0xFEEDFACE+1
-	.long	MAC_CPU_NEXGEN32E
-	.long	MAC_CPU_NEXGEN32E_ALL
-	.long	MAC_EXECUTE
-	.long	5				// number of load commands
-	.long	60f-10f				// size of all load commands
-	.long	MAC_NOUNDEFS|MAC_SPLIT_SEGS	// flags
-	.long	0				// reserved
-10:	.long	MAC_LC_SEGMENT_64
-	.long	20f-10b				// unmaps first page dir
-	.ascin	"__PAGEZERO",16			// consistent with linux
-	.quad	0,0x200000,0,0			// which forbids mem <2m
-	.long	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
-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
-40:	.long	MAC_LC_UUID
-	.long	50f-40b
-	.quad	0x4527148ba7a513ef		// uuid1
-	.quad	0x56fa865940665e8f		// uuid2
-50:	.long	MAC_LC_UNIXTHREAD
-	.long	60f-50b				// cmdsize
-	.long	MAC_THREAD_NEXGEN32E		// flavaflav
-	.long	(520f-510f)/4			// count
-510:	.quad	0				// rax
-	.quad	0				// rbx
-	.quad	0				// rcx
-	.quad	0				// rdx
-	.quad	0				// rdi
-	.quad	0				// rsi
-	.quad	0				// rbp
-	.quad	0				// rsp
-	.quad	0				// r8
-	.quad	0				// r9
-	.quad	0				// r10
-	.quad	0				// r11
-	.quad	0				// r12
-	.quad	0				// r13
-	.quad	0				// r14
-	.quad	0				// r15
-	.quad	XnuEntrypoint			// rip
-	.quad	0				// rflags
-	.quad	0				// cs
-	.quad	0				// fs
-	.quad	0				// gs
-520:
-60:

ape/loader.lds

@@ -1,95 +0,0 @@
-/*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
-│vi: set et sts=2 tw=2 fenc=utf-8                                           :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 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.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-
-ENTRY(ElfEntrypoint)
-
-PHDRS {
-  text PT_LOAD FLAGS(1) FILEHDR PHDRS; /* PF_X */
-  rodata PT_LOAD FLAGS(4); /* PF_R */
-  stack PT_GNU_STACK FLAGS(6); /* PF_W|PF_R */
-  note PT_NOTE FLAGS(4); /* PF_R */
-}
-
-SECTIONS {
-
-  . = SEGMENT_START("text-segment", 0x7f000000);
-  __executable_start = .;
-  . += SIZEOF_HEADERS;
-
-  .macho : {
-    KEEP(*(.macho))
-  } :text
-
-  .note : {
-    KEEP(*(.note))
-  } :text :note
-
-  .text : {
-    *(.text .text.* .gnu.linkonce.t.*)
-  } :text
-
-  .rodata ALIGN(CONSTANT(COMMONPAGESIZE)) : {
-    *(.rodata .rodata.* .gnu.linkonce.r.*)
-  } :rodata
-
-  .stack : {
-    *(.stack)
-  } :stack
-
-  _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)) }
-
-  /DISCARD/ : {
-    *(.*)
-  }
-}

ape/macros.internal.h

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

ape/public/ape.lds

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

ape/relocations.h

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

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 "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
-	sub	$1024*1024,%rsp			// room for allocs
-	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	105000000
-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

build/config.mk

@@ -4,61 +4,22 @@
 # Default Mode
 #
 #   - `make`
-#   - Optimized
 #   - Backtraces
-#   - Syscall tracing
 #   - Function tracing
-#
+#   - Reasonably small
+#   - Reasonably optimized
+#   - Reasonably debuggable
+
 ifeq ($(MODE),)
-ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
-CONFIG_CCFLAGS += -O2 $(BACKTRACES)
-CONFIG_CPPFLAGS += -DSYSDEBUG
-TARGET_ARCH ?= -msse3
-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
-OVERRIDE_CXXFLAGS += -O0
-CONFIG_CPPFLAGS += -DSYSDEBUG
-endif
+CONFIG_CCFLAGS +=		\
+	$(BACKTRACES)		\
+	$(FTRACE)		\
+	-Og
+
+TARGET_ARCH ?=			\
+	-msse3
 
-# Fast Build Mode
-#
-#   - `make MODE=fastbuild`
-#   - No debugging
-#   - Syscall tracing
-#   - Function tracing
-#   - Some optimizations
-#   - Limited Backtraces
-#
-ifeq ($(MODE), fastbuild)
-ENABLE_FTRACE = 1
-CONFIG_CCFLAGS += $(BACKTRACES) -O
-CONFIG_CPPFLAGS += -DSYSDEBUG -DDWARFLESS
-CONFIG_LDFLAGS += -S
-TARGET_ARCH ?= -msse3
 endif
 
 # Optimized Mode
@@ -66,37 +27,25 @@ endif
 #   - `make MODE=opt`
 #   - Backtraces
 #   - More optimized
-#   - Syscall tracing
-#   - Function tracing
 #   - Reasonably small
 #   - No memory corruption detection
 #   - assert() / CHECK_xx() may leak code into binary for debuggability
 #   - GCC 8+ hoists check fails into .text.cold, thus minimizing impact
-#
-ifeq ($(MODE), opt)
-ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
-CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
-CONFIG_CCFLAGS += $(BACKTRACES) -O3 -fmerge-all-constants
-TARGET_ARCH ?= -march=native
-endif
 
-# Optimized Linux Mode
-# The Fastest Mode of All
-#
-#   - `make MODE=optlinux`
-#   - Turns on red zone
-#   - Turns off backtraces
-#   - Turns off function tracing
-#   - Turns off support for older cpu models
-#   - Turns off support for other operating systems
-#
-ifeq ($(MODE), optlinux)
-CONFIG_OFLAGS ?= -g
-CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
-CONFIG_CCFLAGS += -O3 -fmerge-all-constants
-CONFIG_COPTS += -mred-zone
-TARGET_ARCH ?= -march=native
+ifeq ($(MODE), opt)
+
+CONFIG_CPPFLAGS +=		\
+	-DNDEBUG		\
+	-msse2avx		\
+	-Wa,-msse2avx
+
+CONFIG_CCFLAGS +=		\
+	$(BACKTRACES)		\
+	-O3
+
+TARGET_ARCH ?=			\
+	-march=native
+
 endif
 
 # Release Mode
@@ -107,18 +56,24 @@ endif
 #   - More optimized
 #   - Reasonably small
 #   - Numeric backtraces
-#   - No DWARF data bloat
 #   - Toilsome debuggability
 #   - assert() statements removed
 #   - DCHECK_xx() statements removed
 #   - No memory corruption detection
 #   - CHECK_xx() won't leak strings into binary
-#
+
 ifeq ($(MODE), rel)
-CONFIG_CPPFLAGS += -DNDEBUG -DDWARFLESS
-CONFIG_CCFLAGS += $(BACKTRACES) -O2
-TARGET_ARCH ?= -msse3
-PYFLAGS += -O1
+
+CONFIG_CPPFLAGS +=		\
+	-DNDEBUG
+
+CONFIG_CCFLAGS +=		\
+	$(BACKTRACES)		\
+	-O2
+
+TARGET_ARCH ?=			\
+	-msse3
+
 endif
 
 # Asan Mode
@@ -131,15 +86,19 @@ endif
 #   - Backtraces
 #   - Debuggability
 #   - Larger binaries
-#
+
 ifeq ($(MODE), asan)
-ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
-CONFIG_CPPFLAGS += -D__SANITIZE_ADDRESS__
-CONFIG_CCFLAGS += $(BACKTRACES) -O2 -DSYSDEBUG
-CONFIG_COPTS += -fsanitize=address
-TARGET_ARCH ?= -msse3
-QUOTA ?= -C64 -L300
+
+CONFIG_CCFLAGS +=		\
+	$(BACKTRACES)		\
+	-O2
+
+CONFIG_COPTS +=			\
+	-fsanitize=address
+
+TARGET_ARCH ?=			\
+	-msse3
+
 endif
 
 # Debug Mode
@@ -147,46 +106,30 @@ 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_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
-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
+ifeq ($(MODE), dbg)
+
+CONFIG_CPPFLAGS +=		\
+	-DMODE_DBG
+
+CONFIG_CCFLAGS +=		\
+	$(BACKTRACES)		\
+	$(FTRACE)		\
+	-O2
+
+CONFIG_COPTS +=			\
+	-fsanitize=address
+
+TARGET_ARCH ?=			\
+	-msse3
+
+OVERRIDE_CCFLAGS +=		\
+	-fno-pie
+
 endif
 
 # Tiny Mode
@@ -200,47 +143,20 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
-#
+
 ifeq ($(MODE), tiny)
-CONFIG_CPPFLAGS +=			\
-	-DTINY				\
-	-DNDEBUG			\
+CONFIG_CPPFLAGS +=		\
+	-DTINY			\
+	-DNDEBUG		\
 	-DTRUSTWORTHY
-CONFIG_CCFLAGS +=			\
-	-Os				\
-	-fno-align-functions		\
-	-fno-align-jumps		\
-	-fno-align-labels		\
-	-fno-align-loops		\
-	-fschedule-insns2		\
-	-momit-leaf-frame-pointer	\
-	-foptimize-sibling-calls	\
-	-DDWARFLESS
-TARGET_ARCH ?=				\
+CONFIG_CCFLAGS +=		\
+	-Os			\
+	-fno-align-functions	\
+	-fno-align-jumps	\
+	-fno-align-labels	\
+	-fno-align-loops
+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
@@ -255,21 +171,20 @@ endif
 #   - No portability
 #   - No algorithmics
 #   - YOLO
-#
+
 ifeq ($(MODE), tinylinux)
-CONFIG_CPPFLAGS +=			\
-	-DTINY				\
-	-DNDEBUG			\
-	-DTRUSTWORTHY			\
-	-DSUPPORT_VECTOR=1		\
-	-DDWARFLESS
-CONFIG_CCFLAGS +=			\
-	-Os				\
-	-fno-align-functions		\
-	-fno-align-jumps		\
-	-fno-align-labels		\
+CONFIG_CPPFLAGS +=		\
+	-DTINY			\
+	-DNDEBUG		\
+	-DTRUSTWORTHY		\
+	-DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS +=		\
+	-Os			\
+	-fno-align-functions	\
+	-fno-align-jumps	\
+	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=				\
+TARGET_ARCH ?=			\
 	-msse3
 endif
 
@@ -286,14 +201,13 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
-#
+
 ifeq ($(MODE), tinylinuxbsd)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=113	\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=113
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -316,14 +230,13 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
-#
+
 ifeq ($(MODE), tinysysv)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=121	\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=121
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -346,14 +259,13 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
-#
+
 ifeq ($(MODE), tinynowin)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=251	\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=251
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -364,40 +276,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) -O2
 AS = clang
 CC = clang
 CXX = clang++
@@ -435,65 +317,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,131 +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)
 
+V ?= 1
 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
+GZ ?= gzip
 CLANG = clang
 FC = gfortran  #/opt/cross9f/bin/x86_64-linux-musl-gfortran
-TMPDIR = o/tmp
 
+# see build/compile, etc. which run third_party/gcc/unbundle.sh
 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
-FIXUPOBJ = build/bootstrap/fixupobj.com
-MKDIR = build/bootstrap/mkdir.com -p
-COMPILE = build/bootstrap/compile.com -V9 -P4096 $(QUOTA)
+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 = o/third_party/gcc/bin/x86_64-linux-musl-addr2line
 
 COMMA := ,
-PWD := $(shell build/bootstrap/pwd.com)
-
-IGNORE := $(shell $(ECHO) -2 ♥cosmo)
-IGNORE := $(shell $(MKDIR) $(TMPDIR))
-
-ifneq ($(findstring aarch64,$(MODE)),)
-ARCH = aarch64
-VM = o/third_party/qemu/qemu-aarch64
-HOSTS ?= pi silicon
-else
-ARCH = x86_64
-HOSTS ?= freebsd openbsd openbsd73 netbsd rhel7 rhel5 xnu win10
-endif
-
-ifeq ($(PREFIX),)
-ifeq ($(USE_SYSTEM_TOOLCHAIN),)
-ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-pc-linux-gnu-*)","")
-PREFIX = o/third_party/gcc/bin/x86_64-pc-linux-gnu-
-else
-IGNORE := $(shell build/bootstrap/unbundle.com)
-PREFIX = o/third_party/gcc/bin/x86_64-linux-musl-
-endif
-ifeq ($(ARCH), aarch64)
-PREFIX = o/third_party/gcc/bin/aarch64-linux-musl-
-endif
-endif
-endif
-
-AS = $(PREFIX)as
-CC = $(PREFIX)gcc
-CXX = $(PREFIX)g++
-CXXFILT = $(PREFIX)c++filt
-LD = $(PREFIX)ld.bfd
-NM = $(PREFIX)nm
-GCC = $(PREFIX)gcc
-STRIP = $(PREFIX)strip
-OBJCOPY = $(PREFIX)objcopy
-OBJDUMP = $(PREFIX)objdump
-ifneq ($(wildcard $(PWD)/$(PREFIX)addr2line), )
-ADDR2LINE = $(PWD)/$(PREFIX)addr2line
-else
-ADDR2LINE = $(PREFIX)addr2line
-endif
+PWD := $(shell pwd)
+IMAGE_BASE_VIRTUAL ?= 0x400000
+HELLO := $(shell build/hello)
+TMPDIR := $(shell build/findtmp)
+SPAWNER := $(shell build/getcompile) -V$(shell build/getccversion $(CC))
+COMPILE = $(SPAWNER) $(QUOTA)
 
 export ADDR2LINE
 export LC_ALL
-export MKDIR
 export MODE
 export SOURCE_DATE_EPOCH
 export TMPDIR
+export V
 
-ifeq ($(LANDLOCKMAKE_VERSION),)
-TMPSAFE = $(join $(TMPDIR),$(subst /,_,$@)).tmp
-else
-TMPSAFE = $(TMPDIR)/
-endif
-
-ifeq ($(ARCH), aarch64)
-IMAGE_BASE_VIRTUAL ?= 0x010000000000
-else
-IMAGE_BASE_VIRTUAL ?= 0x400000
-endif
-
-BACKTRACES =								\
-	-fno-optimize-sibling-calls					\
-	-mno-omit-leaf-frame-pointer
-
-ifneq ($(ARCH), aarch64)
-BACKTRACES += -fno-schedule-insns2
-endif
+FTRACE =								\
+	-pg
 
 SANITIZER =								\
 	-fsanitize=address
 
 NO_MAGIC =								\
+	-mno-fentry							\
 	-fno-stack-protector						\
-	-fwrapv								\
-	-fno-sanitize=all
+	-fno-sanitize=all						\
+	-fwrapv
 
 OLD_CODE =								\
 	-fno-strict-aliasing						\
@@ -168,97 +108,75 @@ 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-omit-frame-pointer						\
 	-fno-semantic-interposition					\
-	-fno-dwarf2-cfi-asm						\
-	-fno-unwind-tables						\
-	-fno-asynchronous-unwind-tables
-
-ifeq ($(ARCH), x86_64)
-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.
-#
-DEFAULT_COPTS +=							\
-	-ffixed-x18							\
-	-ffixed-x28							\
-	-mno-outline-atomics
-endif
+	-mno-omit-leaf-frame-pointer
 
 MATHEMATICAL =								\
 	-O3								\
 	-fwrapv
 
-DEFAULT_CPPFLAGS +=							\
+DEFAULT_CPPFLAGS =							\
 	-DCOSMO								\
 	-DMODE='"$(MODE)"'						\
 	-DIMAGE_BASE_VIRTUAL=$(IMAGE_BASE_VIRTUAL)			\
 	-nostdinc							\
-	-iquote .
+	-iquote.
 
 DEFAULT_CFLAGS =							\
 	-std=gnu2x
 
 DEFAULT_CXXFLAGS =							\
+	-std=gnu++11							\
 	-fno-rtti							\
 	-fno-exceptions							\
 	-fuse-cxa-atexit						\
 	-fno-threadsafe-statics						\
 	-Wno-int-in-bool-context					\
-	-Wno-narrowing							\
-	-Wno-literal-suffix
+	-Wno-narrowing
 
 DEFAULT_ASFLAGS =							\
 	-W								\
 	-I.								\
-	--noexecstack
+	--noexecstack							\
+	--nocompress-debug-sections
 
 DEFAULT_LDFLAGS =							\
 	-static								\
 	-nostdlib							\
-	-znorelro							\
+	-m elf_x86_64							\
 	--gc-sections							\
 	--build-id=none							\
-	--no-dynamic-linker
+	--no-dynamic-linker						\
+	-z max-page-size=0x1000
 
-# # generate linker report files
-# DEFAULT_LDFLAGS += --cref [email protected]
-
-ifeq ($(ARCH), aarch64)
-DEFAULT_LDFLAGS +=							\
-	-zmax-page-size=0x4000						\
-	-zcommon-page-size=0x4000					\
-	-znorelro
-else
-DEFAULT_LDFLAGS +=							\
-	-zmax-page-size=0x10000						\
-	-zcommon-page-size=0x1000
-endif
+ZIPOBJ_FLAGS =								\
+	 -b$(IMAGE_BASE_VIRTUAL)
 
 ASONLYFLAGS =								\
 	-c								\
-	-g
+	-g								\
+	--debug-prefix-map="$(PWD)"=
 
 DEFAULT_LDLIBS =
 
@@ -332,19 +250,19 @@ 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) $(copt.flags) $(cpp.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.f.flags = $(cc.flags) $(o.flags) $(S.flags) $(f.flags)
-OBJECTIFY.F.flags = $(cc.flags) $(o.flags) $(S.flags) $(cpp.flags) $(copt.flags) $(f.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
 
@@ -363,7 +281,7 @@ 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)
 
@@ -379,8 +297,6 @@ OBJECTIFY.greg.c =							\
 	-fno-instrument-functions					\
 	-fno-optimize-sibling-calls					\
 	-fno-sanitize=all						\
-	-ffreestanding							\
-	-fwrapv								\
 	-c
 
 OBJECTIFY.ansi.c = $(CC) $(OBJECTIFY.c.flags) -ansi -Wextra -Werror -pedantic-errors -c
@@ -419,6 +335,7 @@ OBJECTIFY.ncabi.c =							\
 	$(OBJECTIFY.c.flags)						\
 	-mno-sse							\
 	-mfpmath=387							\
+	-mno-fentry							\
 	-fno-stack-protector						\
 	-fno-instrument-functions					\
 	-fno-optimize-sibling-calls					\
@@ -437,6 +354,7 @@ OBJECTIFY.ncabi.c =							\
 OBJECTIFY.initabi.c =							\
 	$(GCC)								\
 	$(OBJECTIFY.c.flags)						\
+	-mno-fentry							\
 	-fno-stack-protector						\
 	-fno-instrument-functions					\
 	-fno-optimize-sibling-calls					\

build/findtmp

@@ -0,0 +1,17 @@
+#!/bin/sh
+#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
+#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+#
+# OVERVIEW
+#
+#   Temporary Directory Discovery
+#
+# DESCRIPTION
+#
+#   We call this script once per build to ideally find a folder that's
+#   backed by an in-memory file system. We then export it to the TMPDIR
+#   environment variable. Many programs use it under the hood, e.g. gcc,
+#   so it grants many small performance improvements.
+
+mkdir -p o/tmp
+echo o/tmp

build/functions.mk

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

build/getccversion

@@ -0,0 +1,39 @@
+#!/bin/sh
+#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
+#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+#
+# OVERVIEW
+#
+#   Compiler Version Discovery
+#
+# DESCRIPTION
+#
+#   Cosmopolitan itself may be built using either GCC and Clang, and our
+#   build irons out many of the differences between the two. This script
+#   is used by build/definitions.mk alongside build/getccname to support
+#   the different versions folks use.
+#
+#   Our aim is to support GCC 4.2.1+ since that's the last GPLv2 version
+#   with any sort of industry consensus. Please note, Cosmopolitan never
+#   links GCC runtimes when using later versions, so some concerns might
+#   not apply.
+
+if [ ! -d o/third_party/gcc ]; then
+  third_party/gcc/unbundle.sh
+fi
+
+set -e
+
+MAJOR_VERSION=$(
+  $1 --version |
+    head -n1 |
+    sed -n '
+        s!^[^(]*([^)]*) \([[:digit:]][[:digit:]]*\).*!\1!p
+        s!^.*clang.*version \([[:digit:]][[:digit:]]*\).*!\1!p
+      ')
+
+if [ -z "$MAJOR_VERSION" ]; then
+  echo 6
+else
+  printf '%s\n' "$MAJOR_VERSION"
+fi

build/getcompile

@@ -0,0 +1,12 @@
+#!/bin/sh
+#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
+#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+
+if ! [ o/build/bootstrap/compile.com -nt build/bootstrap/compile.com ]; then
+  mkdir -p o/build/bootstrap/
+  cp -f build/bootstrap/compile.com o/build/bootstrap/compile.$$.com
+  o/build/bootstrap/compile.$$.com -n
+  mv -f o/build/bootstrap/compile.$$.com o/build/bootstrap/compile.com
+fi
+
+echo o/build/bootstrap/compile.com

build/hello

@@ -0,0 +1,20 @@
+#!/bin/sh
+#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
+#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+#
+# SYNOPSIS
+#
+#   HELLO BUILD
+#
+# OVERVIEW
+#
+#   We generate a line at the start of each Makefile run, because if we
+#   use `make V=0` mode then the terminal logging trick we use in
+#   tool/build/compile.c will delete the previous line, and we'd rather
+#   have that line not be the bash prompt that ran make.
+#
+#   This script is also useful for giving us an indicator each time the
+#   build restarts itself from scratch, which can happen in cases like
+#   when dependencies need to be regenerated by tool/build/mkdeps.c
+
+echo ♥cosmo >&2

build/htags

@@ -43,19 +43,12 @@
 #     '(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' "$@"
-
 # ctags doesn't understand variable prototypes, e.g.
 #   extern char **environ;
 set -- --regex-c='/^\(\(hidden\|extern\|const\) \)*[_[:alpha:]][_[:alnum:]]*[ *][ *]*\([_[:alpha:]][_[:alnum:]]*[ *][ *]*\)*\([_[:alpha:]][_$[:alnum:]]*\)/\4/b' "$@"
 
 # ctags doesn't understand function prototypes, e.g.
-#   bool isheap(void *p) dontthrow nocallback;
+#   bool isheap(void *p) nothrow nocallback;
 set -- --regex-c='/^[_[:alpha:]][_[:alnum:]]*[ *][ *]*\([_[:alpha:]][_[:alnum:]]*[ *][ *]*\)*\([_[:alpha:]][_$[:alnum:]]*\)(.*/\2/b' "$@"
 
 # ctags doesn't understand function pointers, e.g.
@@ -66,7 +59,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,6 +0,0 @@
-#!/bin/sh
-if printf '%s\n' "$*" | grep aarch64 >/dev/null 2>&1; then
-  exec o/third_party/gcc/bin/aarch64-linux-musl-objdump "$@"
-else
-  exec o/third_party/gcc/bin/x86_64-linux-musl-objdump "$@"
-fi

build/online.mk

@@ -23,9 +23,8 @@
 #   - 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:				\
-		o//tool/build/runit.com		\
-		o//tool/build/runitd.com	\
+		o/$(MODE)/tool/build/runit.com	\
+		o/$(MODE)/tool/build/runitd.com	\
 		o/$(MODE)/%.com
-	@$(COMPILE) -wATEST -tT$@ $^ $(HOSTS)
+	@$(COMPILE) -ATEST -tT$@ $^ $(HOSTS)

build/rules.mk

@@ -16,234 +16,70 @@
 
 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/%.lds: %.lds                     ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
-o/%.inc: %.h                       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) -D__ASSEMBLER__ -P $<
-o/$(MODE)/%: o/$(MODE)/%.dbg       ; @$(MAKE_OBJCOPY)
-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: %.cc                ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.lds: %.lds             ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(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) $<
-
-ifneq ($(ARCH), aarch64)
+o/%.a:                             ; @$(COMPILE) -AARCHIVE -T$@ $(AR) $(ARFLAGS) $@ $^
 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/%.i: %.S                         ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
 o/%.o: %.S                         ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
 o/%.o: o/%.S                       ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/%.s: %.i                         ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/%.s: o/%.i                       ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/%.o: %.cc                        ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/%.o: o/%.cc                      ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/%.lds: %.lds                     ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
+o/%.inc: %.h                       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) -D__ASSEMBLER__ -P $<
+o/%.pkg:                           ; @$(COMPILE) -APACKAGE -T$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) $(filter %.o,$^)
+o/%.h.ok: %.h                      ; @$(COMPILE) -ACHECK.h $(COMPILE.c) -x c -g0 -o $@ $<
+o/%.h.okk: %.h                     ; @$(COMPILE) -ACHECK.h $(COMPILE.cxx) -x c++ -g0 -o $@ $<
+o/%.greg.o: %.greg.c               ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/%.zip.o: o/%                     ; @$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+
+o/$(MODE)/%.a:                     ; @$(COMPILE) -AARCHIVE -T$@ $(AR) $(ARFLAGS) $@ $^
+o/$(MODE)/%: o/$(MODE)/%.dbg       ; @$(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -S -O binary $< $@
 o/$(MODE)/%.o: %.s                 ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: o/$(MODE)/%.s       ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: %.S                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: o/$(MODE)/%.S       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.c                 ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.f                 ; @$(COMPILE) -AOBJECTIFY.f $(OBJECTIFY.f) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.F                 ; @$(COMPILE) -AOBJECTIFY.F $(OBJECTIFY.F) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.c       ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ss: %.c                ; @$(COMPILE) -ACOMPILE.c $(COMPILE.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ss: o/$(MODE)/%.c      ; @$(COMPILE) -AOBJECTIFY.s $(COMPILE.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.S                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.c                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.cc                ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: o/$(MODE)/%.c       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.h: %.c                 ; @$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
+o/$(MODE)/%.h: o/$(MODE)/%.c       ; @$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
 o/$(MODE)/%.o: %.S                 ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: o/$(MODE)/%.S       ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
-else
-o/%.o: %.s libc/empty.s                   ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) libc/empty.s
-o/%.o: o/%.s libc/empty.s                 ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) libc/empty.s
-o/%.s: %.S libc/empty.s                   ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) libc/empty.s
-o/%.s: o/%.S libc/empty.s                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) libc/empty.s
-o/%.o: %.S libc/empty.s                   ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.s) $(OUTPUT_OPTION) libc/empty.s
-o/%.o: o/%.S libc/empty.s                 ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.s) $(OUTPUT_OPTION) libc/empty.s
-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
-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)/%.s: %.i                 ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: o/$(MODE)/%.i       ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.cc                ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.cc      ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.lds: %.lds             ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.h.ok: %.h              ; @$(COMPILE) -ACHECK.h $(COMPILE.c) -x c -g0 -o $@ $<
+o/$(MODE)/%.h.okk: %.h             ; @$(COMPILE) -ACHECK.h $(COMPILE.cxx) -x c++ -g0 -o $@ $<
+o/$(MODE)/%.o: %.greg.c            ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.greg.o: %.greg.c       ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ansi.o: %.ansi.c       ; @$(COMPILE) -AOBJECTIFY.ansi $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ansi.o: %.c            ; @$(COMPILE) -AOBJECTIFY.ansi $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c99.o: %.c99.c         ; @$(COMPILE) -AOBJECTIFY.c99 $(OBJECTIFY.c99.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c11.o: %.c11.c         ; @$(COMPILE) -AOBJECTIFY.c11 $(OBJECTIFY.c11.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c2x.o: %.c2x.c         ; @$(COMPILE) -AOBJECTIFY.c2x $(OBJECTIFY.c2x.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.initabi.o: %.initabi.c ; @$(COMPILE) -AOBJECTIFY.init $(OBJECTIFY.initabi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ncabi.o: %.ncabi.c     ; @$(COMPILE) -AOBJECTIFY.nc $(OBJECTIFY.ncabi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.real.o: %.c            ; @$(COMPILE) -AOBJECTIFY.real $(OBJECTIFY.real.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.runs: o/$(MODE)/%      ; @$(COMPILE) -ACHECK -tT$@ $< $(TESTARGS)
+o/$(MODE)/%.pkg:                   ; @$(COMPILE) -APACKAGE -T$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) $(filter %.o,$^)
+o/$(MODE)/%.zip.o: %               ; @$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%-gcc.asm: %.c           ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
+o/$(MODE)/%-clang.asm: %.c         ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@
 
-o/%.o: %.cc
-	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
+o/$(MODE)/%.lua: %.lua o/$(MODE)/third_party/lua/luac.com
+	@$(COMPILE) -ALUAC -T$@ o/$(MODE)/third_party/lua/luac.com -s -o $@ $<
 
-o/%.o: o/%.cc
-	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-o/$(MODE)/%.o: %.c
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-o/$(MODE)/%.o: o/$(MODE)/%.c
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-o/$(MODE)/%.o: o/$(MODE)/%.cc
-	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-o/%.greg.o: %.greg.c
-	@$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-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:
-	$(file >$(TMPDIR)/$(subst /,_,$@),$^)
-	@$(COMPILE) -AARCHIVE -wT$@ $(AR) $(ARFLAGS) $@ @$(TMPDIR)/$(subst /,_,$@)
-
-o/%.pkg:
-	$(file >$(TMPSAFE).args,$(filter %.o,$^))
-	@$(COMPILE) -APACKAGE -wT$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) @$(TMPSAFE).args
-
-o/$(MODE)/%.pkg:
-	$(file >$(TMPSAFE).args,$(filter %.o,$^))
-	@$(COMPILE) -APACKAGE -wT$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) @$(TMPSAFE).args
-
-o/$(MODE)/%.o: %.py o/$(MODE)/third_party/python/pyobj.com $(VM)
-	@$(COMPILE) -wAPYOBJ $(VM) o/$(MODE)/third_party/python/pyobj.com $(PYFLAGS) -o $@ $<
-
-o/$(MODE)/%.pyc: %.py o/$(MODE)/third_party/python/pycomp.com $(VM)
-	@$(COMPILE) -wAPYCOMP $(VM) o/$(MODE)/third_party/python/pycomp.com $(PYCFLAGS) -o $@ $<
-
-o/$(MODE)/%.lua: %.lua o/$(MODE)/third_party/lua/luac.com $(VM)
-	@$(COMPILE) -wALUAC $(VM) o/$(MODE)/third_party/lua/luac.com -s -o $@ $<
-
-o/$(MODE)/%.lua.runs: %.lua o/$(MODE)/tool/net/redbean.com $(VM)
-	@$(COMPILE) -wALUA -tT$@ $(VM) o/$(MODE)/tool/net/redbean.com $(LUAFLAGS) -i $<
-
-################################################################################
-# LOCAL UNIT TESTS
-#
-# We always run unit tests as part of the normal `make` invocation. you
-# may override the $(TESTARGS) variable to do things such as enable the
-# benchmarking feature. For example:
-#
-#     TESTARGS = -b
-#
-# May be specified in your ~/.cosmo.mk file. You can also use this to
-# enable things like function tracing. For example:
-#
-#     TESTARGS = ----ftrace
-#     .PLEDGE += prot_exec
-#
-# You could then run a command like:
-#
-#     make -j8 o//test/libc/calls/openbsd_test.com.runs
-#
-# You need PROT_EXEC permission since ftrace morphs the binary. It's
-# also worth mentioning that the pledge.com command can simulate what
-# Landlock Make does:
-#
-#     o//tool/build/pledge.com \
-#       -v. -p 'stdio rpath wpath cpath tty prot_exec' \
-#       o//test/libc/calls/openbsd_test.com \
-#       ----ftrace
-#
-# This is useful in the event a test binary should run by itself, but
-# fails to run beneath Landlock Make. It's also useful sometimes to
-# override the verbosity when running tests:
-#
-#     make V=5 TESTARGS=-b o//test/libc/calls/openbsd_test.com.runs
-#
-# This way, if for some reason a test should fail but calls exit(0),
-# then the stdout/stderr output, which would normally be suppressed,
-# will actually be displayed.
-
-o/$(MODE)/%.runs: o/$(MODE)/% $(VM)
-	@$(COMPILE) -ACHECK -wtT$@ $(VM) $< $(TESTARGS)
-
-################################################################################
-# ELF ZIP FILES
-#
-# zipobj.com lets us do fast incremental linking of compressed data.
-# it's nice because if we link a hundred binaries that use the time zone
-# database, then that database only needs to be DEFLATE'd once.
-
-o/%.zip.o: o/%
-	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
-
-o/$(MODE)/%.zip.o: %
-	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
-
-o/$(MODE)/%.zip.o: %
-	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
-
-# an issue with sandboxing arises when creating directory entries in the
-# zip file. we need the trailing slash (e.g. o//foo/.zip.o) but Landlock
-# Make avoids sandboxing directory names that have a trailing slash (so
-# they can be used to watch for deleted files, without creating overly
-# broad unveiling). such rules need to be written more explicitly.
-o/$(MODE)%/.zip.o: %
-	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
-
-################################################################################
-# STRICT HEADER CHECKING
-#
-# these rules are unsandboxed since they're already a sandboxing test,
-# and it would be too costly in terms of make latency to have every
-# header file depend on $(HDRS) and $(INCS).
-
-o/%.h.ok: private .UNSANDBOXED = 1
-o/%.h.ok: %.h
-	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
-
-o/$(MODE)/%.h.ok: private .UNSANDBOXED = 1
-o/$(MODE)/%.h.ok: %.h
-	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
-
-o/$(MODE)/%.hh.ok: private .UNSANDBOXED = 1
-o/$(MODE)/%.hh.ok: %.hh
-	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
-
-o/%.okk: .UNSANDBOXED = 1
-o/%.okk: %
-	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
-
-o/$(MODE)/%.okk: private .UNSANDBOXED = 1
-o/$(MODE)/%.okk: %
-	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
-
-################################################################################
-# EXECUTABLE HELPERS
-
-MAKE_SYMTAB_CREATE =				\
-	$(COMPILE) -wASYMTAB			\
-	$(VM)					\
-	o/$(MODE)/tool/build/symtab.com		\
-	-o $(TMPSAFE)/.symtab			\
-	$<
-
-MAKE_SYMTAB_ZIP =				\
-	$(COMPILE) -AZIP -T$@			\
-	$(VM)					\
-	o/$(MODE)/third_party/zip/zip.com	\
-	-b$(TMPDIR)				\
-	-9qj					\
-	$@					\
-	$(TMPSAFE)/.symtab
-
-################################################################################
-# EMACS ASSEMBLY GENERATION
-
-o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
-o/$(MODE)/%-gcc.asm: %.c
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
-
-o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
-o/$(MODE)/%-gcc.asm: %.cc
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
-
-o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
-o/$(MODE)/%-clang.asm: %.c
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
-
-# TODO(jart): Make intrinsics support Clang.
 o/$(MODE)/%-clang.asm: CC = $(CLANG)
-o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
-o/$(MODE)/%-clang.asm: %.cc
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<

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

build/sanitycheck

@@ -27,37 +27,29 @@ EOF
   exit 1
 fi
 
-if [ ! -f /proc/sys/fs/binfmt_misc/status ]; then
-  exit 0
-fi
-
-if ! build/bootstrap/echo.com -n; then
+build/sanitycheck2
+if [ $? -ne 123 ]; then
   cat <<'EOF' >&2
 
 ERROR
 
-  APE Execution error.
+  Thompson Shell Backwards Compatibility Issue Detected
 
 DETAILS
 
-  Your system has probably been configured to use binfmt_misc. You need
-  to run the command below to install /usr/bin/ape and register it with
-  binfmt_misc. See ape/loader.c for source code, and technical details.
+  Actually Portable Executable assumes stock Linux configuration.
+  Normal behavior is non-ELF files with x bit are run by /bin/sh.
+  Linux lets people globally define arbitrary magic interpreters.
+  Your computer couldve been tuned to run MZ scripts inside WINE.
+  So if you use binfmt_misc you need to explicitly register this.
 
 WORKAROUND
 
-  ape/apeinstall.sh
-
-NOTES
-
-  If it still doesn't work, possibly due to an overly aggressive WINE
-  or WSL registration, or possibly due to the ordering of definitions,
-  then one troubleshooting step is to just unregister everything using
-  sudo sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/status' and try again.
+  sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
 
 SEE ALSO
 
-  https://justine.lol/ape.html
+  https://justine.storage.googleapis.com/ape.html
 
 EOF
   kill $1

build/sanitycheck2

@@ -0,0 +1,9 @@
+MZqFpD=123
+exit $MZqFpD
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+ 

dsp/bmp/bmp.mk

@@ -25,7 +25,8 @@ DSP_BMP_A_CHECKS =				\
 
 DSP_BMP_A_DIRECTDEPS =				\
 	LIBC_NEXGEN32E				\
-	LIBC_TINYMATH
+	LIBC_TINYMATH				\
+	LIBC_STUBS
 
 DSP_BMP_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(DSP_BMP_A_DIRECTDEPS),$($(x))))
@@ -39,12 +40,12 @@ $(DSP_BMP_A).pkg:				\
 		$(foreach x,$(DSP_BMP_A_DIRECTDEPS),$($(x)_A).pkg)
 
 o/$(MODE)/dsp/bmp/float2short.o			\
-o/$(MODE)/dsp/bmp/scalevolume.o: private	\
-		CFLAGS +=			\
+o/$(MODE)/dsp/bmp/scalevolume.o:		\
+		OVERRIDE_CFLAGS +=		\
 			$(MATHEMATICAL)
 
-o/tiny/dsp/bmp/scalevolume.o: private		\
-		CFLAGS +=			\
+o/tiny/dsp/bmp/scalevolume.o:			\
+		OVERRIDE_CFLAGS +=		\
 			-Os
 
 DSP_BMP_LIBS = $(foreach x,$(DSP_BMP_ARTIFACTS),$($(x)))

dsp/core/alaw.c

@@ -1,45 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ 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 "dsp/core/core.h"
-
-/**
- * Compresses 16-bit signed linear audio sample with a-Law.
- *
- * @param x is clamped to 16-bits of which the top 14 are considered
- * @return coded number in range [0..255]
- * @see ITU G.711
- */
-int alaw(int x) {
-  int a, b, i;
-  if ((a = x) < 0) a = ~a;
-  a >>= 4;
-  if (a > 15) {
-    if ((i = a >> 5)) {
-      b = (__builtin_clz(i) ^ 31) + 1;
-      a >>= b;
-      a -= 16;
-      a += (b + 1) << 4;
-    } else {
-      a -= 16;
-      a += 16;
-    }
-  }
-  if (x >= 0) a |= 128;
-  return a ^ 85;
-}

dsp/core/byte2double.c

@@ -22,7 +22,7 @@
 void *byte2double(long n, const void *p, double weight, double bias) {
   long i;
   double f, *dst;
-  const unsigned char *src;
+  unsigned char *src;
   if ((dst = valloc(n * sizeof(double)))) {
     for (src = p, i = 0; i < n; ++i) {
       f = src[i];

dsp/core/c11.h

@@ -7,7 +7,8 @@
  *
  * @define (a + b) / 2
  */
-__funline unsigned char C11(unsigned char al, unsigned char bl) {
+static inline pureconst artificial unsigned char C11(unsigned char al,
+                                                     unsigned char bl) {
   short ax;
   ax = al;
   ax += bl;

dsp/core/c121.h

@@ -3,8 +3,9 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-__funline unsigned char C121(unsigned char al, unsigned char bl,
-                             unsigned char cl) {
+forceinline pureconst artificial unsigned char C121(unsigned char al,
+                                                    unsigned char bl,
+                                                    unsigned char cl) {
   unsigned short ax, bx;
   ax = al;
   ax += bl;

dsp/core/c121s.h

@@ -2,7 +2,9 @@
 #define COSMOPOLITAN_DSP_CORE_C121S_H_
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 
-__funline signed char C121S(signed char al, signed char bl, signed char cl) {
+forceinline pureconst artificial signed char C121S(signed char al,
+                                                   signed char bl,
+                                                   signed char cl) {
   short ax, bx;
   ax = al;
   ax += bl;

dsp/core/c1331.h

@@ -9,8 +9,10 @@
  * @see C161() afterward for superior sin(𝑥)/𝑥
  * @limit [0,255] → [0..2,044] → [0..255]
  */
-__funline unsigned char C1331(unsigned char al, unsigned char bl,
-                              unsigned char cl, unsigned char dl) {
+forceinline pureconst artificial unsigned char C1331(unsigned char al,
+                                                     unsigned char bl,
+                                                     unsigned char cl,
+                                                     unsigned char dl) {
   short ax, bx;
   bx = bl;
   bx += cl;

dsp/core/c1331s.h

@@ -8,8 +8,10 @@
  * @define (1*(a-128)+3*(a-128)+3*(a-128)+1*(a-128))/(1+3+3+1)+128
  * @see C1331(), Y420CbCr2RgbScale()
  */
-__funline signed char C1331S(signed char al, signed char bl, signed char cl,
-                             signed char dl) {
+forceinline pureconst artificial signed char C1331S(signed char al,
+                                                    signed char bl,
+                                                    signed char cl,
+                                                    signed char dl) {
   short ax, bx;
   bx = bl;
   bx += cl;

dsp/core/c161.h

@@ -12,8 +12,9 @@
  * @limit [0..255] → [-510..1,532] → [-127..383] → [0..255]
  * @see C1331()
  */
-__funline unsigned char C161(unsigned char al, unsigned char bl,
-                             unsigned char cl) {
+forceinline pureconst artificial unsigned char C161(unsigned char al,
+                                                    unsigned char bl,
+                                                    unsigned char cl) {
   short ax, bx, cx;
   ax = al;
   bx = bl;

dsp/core/c161s.h

@@ -4,7 +4,9 @@
 #include "libc/macros.internal.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 
-__funline signed char C161S(signed char al, signed char bl, signed char cl) {
+forceinline pureconst artificial signed char C161S(signed char al,
+                                                   signed char bl,
+                                                   signed char cl) {
   short ax, bx, cx;
   ax = al;
   bx = bl;

dsp/core/c331.h

@@ -9,8 +9,9 @@ COSMOPOLITAN_C_START_
  * @define (3*a + 3*b + 1*c) / 7
  * @see C1331()
  */
-__funline unsigned char C331(unsigned char al, unsigned char bl,
-                             unsigned char cl) {
+static inline pureconst artificial unsigned char C331(unsigned char al,
+                                                      unsigned char bl,
+                                                      unsigned char cl) {
   unsigned eax, ebx, ecx;
   eax = al;
   ebx = bl;

dsp/core/core.h

@@ -3,19 +3,23 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int alaw(int);
-int unalaw(int);
+/**
+ * @fileoverview Cosmopolitan Digital Signal Processing.
+ */
+
 int mulaw(int);
-int unmulaw(int);
 void *double2byte(long, const void *, double, double) vallocesque;
 void *byte2double(long, const void *, double, double) vallocesque;
+
 void *dct(float[8][8], float, float, float, float, float);
 void *dctjpeg(float[8][8]);
+
 double det3(const double[3][3]) nosideeffect;
 void *inv3(double[restrict 3][3], const double[restrict 3][3], double);
 void *matmul3(double[restrict 3][3], const double[3][3], const double[3][3]);
 void *vmatmul3(double[restrict 3], const double[3], const double[3][3]);
 void *matvmul3(double[restrict 3], const double[3][3], const double[3]);
+
 double rgb2stdtv(double) pureconst;
 double rgb2lintv(double) pureconst;
 double rgb2stdpc(double, double) pureconst;

dsp/core/core.mk

@@ -8,8 +8,16 @@ DSP_CORE = $(DSP_CORE_A_DEPS) $(DSP_CORE_A)
 DSP_CORE_A = o/$(MODE)/dsp/core/core.a
 DSP_CORE_A_FILES := $(wildcard dsp/core/*)
 DSP_CORE_A_HDRS = $(filter %.h,$(DSP_CORE_A_FILES))
-DSP_CORE_A_SRCS = $(filter %.c,$(DSP_CORE_A_FILES))
-DSP_CORE_A_OBJS = $(DSP_CORE_A_SRCS:%.c=o/$(MODE)/%.o)
+DSP_CORE_A_SRCS_S = $(filter %.S,$(DSP_CORE_A_FILES))
+DSP_CORE_A_SRCS_C = $(filter %.c,$(DSP_CORE_A_FILES))
+
+DSP_CORE_A_SRCS =				\
+	$(DSP_CORE_A_SRCS_S)			\
+	$(DSP_CORE_A_SRCS_C)
+
+DSP_CORE_A_OBJS =				\
+	$(DSP_CORE_A_SRCS_S:%.S=o/$(MODE)/%.o)	\
+	$(DSP_CORE_A_SRCS_C:%.c=o/$(MODE)/%.o)
 
 DSP_CORE_A_CHECKS =				\
 	$(DSP_CORE_A).pkg			\
@@ -20,7 +28,8 @@ DSP_CORE_A_DIRECTDEPS =				\
 	LIBC_MEM				\
 	LIBC_NEXGEN32E				\
 	LIBC_STR				\
-	LIBC_TINYMATH
+	LIBC_TINYMATH				\
+	LIBC_STUBS
 
 DSP_CORE_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(DSP_CORE_A_DIRECTDEPS),$($(x))))
@@ -38,16 +47,16 @@ o/$(MODE)/dsp/core/c1331.o			\
 o/$(MODE)/dsp/core/magikarp.o			\
 o/$(MODE)/dsp/core/c93654369.o			\
 o/$(MODE)/dsp/core/float2short.o		\
-o/$(MODE)/dsp/core/scalevolume.o: private	\
-		CFLAGS +=			\
+o/$(MODE)/dsp/core/scalevolume.o:		\
+		OVERRIDE_CFLAGS +=		\
 			$(MATHEMATICAL)
 
-o/tiny/dsp/core/scalevolume.o: private		\
-		CFLAGS +=			\
+o/tiny/dsp/core/scalevolume.o:			\
+		OVERRIDE_CFLAGS +=		\
 			-Os
 
-o/$(MODE)/dsp/core/det3.o: private		\
-		CFLAGS +=			\
+o/$(MODE)/dsp/core/det3.o:			\
+		OVERRIDE_CFLAGS +=		\
 			-ffast-math
 
 DSP_CORE_LIBS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)))

dsp/core/dct.c

@@ -21,7 +21,7 @@
 #define DCT(A, B, C, D, E, F, G, H, T, C0, C1, C2, C3, C4)    \
   do {                                                        \
     T z1, z2, z3, z4, z5, z11, z13;                           \
-    T t0, t1, t2, t3, t4, t5, t6, t7, t10, t11, t12, t13;     \
+    T t0, t1, t2, t3, t4, t5, t6, t7, t8, t10, t11, t12, t13; \
     t0 = A + H;                                               \
     t7 = A - H;                                               \
     t1 = B + G;                                               \

dsp/core/float2short.c

@@ -30,6 +30,7 @@
  */
 void float2short(size_t n, short pcm16[n][8], const float binary32[n][8]) {
   size_t i, j;
+  float f[8], w[8];
   for (i = 0; i < n; ++i) {
     for (j = 0; j < 8; ++j) {
       pcm16[i][j] =

dsp/core/ituround.h

@@ -11,11 +11,11 @@
  *
  * @see round(), rint()
  */
-__funline long ituround(double x) {
+static inline pureconst artificial long ituround(double x) {
   return floor(x + .5);
 }
 
-__funline int ituroundf(float x) {
+static inline pureconst artificial int ituroundf(float x) {
   return floorf(x + .5f);
 }
 

dsp/core/mulaw.S

@@ -0,0 +1,63 @@
+/*-*- 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 2020 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"
+
+#define BIAS 0x84
+
+//	Encodes audio sample with µ-Law.
+//
+//	This is both the highest quality and most widely supported
+//	telephony codec, whose use was phased out in the 2000's in
+//	favor of cost-saving GSM audio compression that was so bad
+//	consumers were willing to pay more cash, for the privilege
+//	of saving telcos even more money w/ text messaging. Mu Law
+//	reduces PCM data to half its original size, by diminishing
+//	audio bands not vocalized by human voice.
+//
+//	@param	%edi is pcm sample
+//	@return	%eax is uint8_t encoded sample
+mulaw:	.leafprologue
+	.profilable
+	mov	$BIAS,%eax
+	xor	%edx,%edx
+	test	%edi,%edi
+	js	1f
+	lea	(%edi,%eax),%eax
+	mov	$0xFF,%dl
+	jmp	2f
+1:	sub	%edi,%eax
+	mov	$0x7F,%dl
+2:	mov	%eax,%esi
+	or	$0xFF,%sil
+	bsr	%esi,%esi
+	sub	$7,%esi
+	cmp	$8,%esi
+	jge	4f
+	lea	3(%rdx),%ecx
+	sar	%cl,%eax
+	and	$0xF,%eax
+	shl	$4,%esi
+	or	%esi,%eax
+	xor	%edx,%eax
+3:	.leafepilogue
+4:	xor	$0x7F,%dl
+	mov	%edx,%eax
+	jmp	3b
+	.endfn	mulaw,globl
+	.source	__FILE__

dsp/core/mulaw.c

@@ -1,40 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ 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 "dsp/core/core.h"
-
-/**
- * Compresses 16-bit signed linear audio sample with μ-Law.
- *
- * @param x is clamped to 16-bits of which the top 14 are considered
- * @return coded number in range [0..255]
- * @see ITU G.711
- */
-int mulaw(int x) {
-  int b, i, a, s, l, h;
-  a = x < 0 ? (~x >> 2) + 33 : (x >> 2) + 33;
-  if (a > 8191) a = 8191;
-  i = a >> 6;
-  s = i ? (__builtin_clz(i) ^ 31) + 2 : 1;
-  h = 8 - s;
-  l = (a >> s) & 15;
-  l = 15 - l;
-  b = (h << 4) | l;
-  if (x >= 0) b |= 128;
-  return b;
-}

dsp/core/sad16x8n.S

@@ -0,0 +1,40 @@
+/*-*- 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 2020 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"
+.align	16
+
+//	Mixes audio.
+//
+//	@param	rdi is # aligned int16[16] sample chunks to process
+//	@param	rsi points to aligned pcm s16le input/output memory
+//	@param	rdx points to aligned pcm s16le [0..1] input memory
+sad16x8n:
+	.leafprologue
+	.profilable
+	test	%rdi,%rdi
+	jz	1f
+	shl	$3,%rdi
+0:	sub	$8,%rdi
+	movdqa	(%rsi,%rdi,2),%xmm0
+	paddsw	(%rdx,%rdi,2),%xmm0
+	movdqa	%xmm0,(%rsi,%rdi,2)
+	jnz	0b
+1:	.leafepilogue
+	.endfn	sad16x8n,globl,hidden
+	.source	__FILE__

dsp/core/sad16x8n.c

@@ -1,46 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ 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 "dsp/core/core.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "third_party/aarch64/arm_neon.internal.h"
-#include "third_party/intel/emmintrin.internal.h"
-
-/**
- * Mixes audio.
- *
- * This function performs saturated addition on an array of shorts.
- *
- * @param x needs to be 16-byte aligned
- * @param y needs to be 16-byte aligned
- */
-void sad16x8n(size_t n, short x[n][8], const short y[n][8]) {
-  size_t i, j;
-  for (i = 0; i < n; ++i) {
-#ifdef __x86_64__
-    *(__m128i *)x[i] = _mm_adds_epi16(*(__m128i *)x[i], *(__m128i *)y[i]);
-#elif defined(__aarch64__)
-    *(int16x4_t *)x[i] = vqadd_s16(*(int16x4_t *)x[i], *(int16x4_t *)y[i]);
-#else
-    for (j = 0; j < 8; ++j) {
-      x[i][j] = MIN(MAX(x[i][j] + y[i][j], INT16_MIN), INT16_MAX);
-    }
-#endif
-  }
-}

dsp/core/scalevolume.c

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

dsp/core/twixt8.h

@@ -6,8 +6,9 @@ COSMOPOLITAN_C_START_
 /**
  * 8-bit linear interpolation kernel.
  */
-__funline unsigned char twixt8(unsigned char al, unsigned char bl,
-                               unsigned char p) {
+static inline pureconst artificial unsigned char twixt8(unsigned char al,
+                                                        unsigned char bl,
+                                                        unsigned char p) {
   short bx;
   bx = bl;
   bx -= al;

dsp/core/unalaw.c

@@ -1,38 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ 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 "dsp/core/core.h"
-
-/**
- * Expands a-Law coded to audio sample.
- *
- * @param x is coded number masked to range [0..255]
- * @return 16-bit signed linear audio sample
- * @note generate lut to save 2 cycles
- * @see ITU G.711
- */
-int unalaw(int x) {
-  int e, i, m;
-  i = (x ^ 85) & 127;
-  e = i >> 4;
-  m = i & 15;
-  if (e > 0) m += 16;
-  m = (m << 4) + 8;
-  if (e > 1) m = m << (e - 1);
-  return x & 128 ? m : -m;
-}

dsp/core/unmulaw.c

@@ -1,37 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ 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 "dsp/core/core.h"
-#include "libc/intrin/likely.h"
-
-/**
- * Expands μ-Law coded to audio sample.
- *
- * @param x is coded number masked to range [0..255]
- * @return 16-bit signed linear audio sample
- * @note generate lut to save 2 cycles
- * @see ITU G.711
- */
-int unmulaw(int x) {
-  int e, m, k, s;
-  e = (~x >> 4) & 7;
-  m = ~x & 15;
-  k = 4 << (e + 1);
-  s = (128 << e) + k * m + k / 2 - 4 * 33;
-  return x & 128 ? s : -s;
-}

dsp/mpeg/README.txt

@@ -37,10 +37,10 @@ This library provides several interfaces to load, demux and decode MPEG video
 and audio data. A high-level API combines the demuxer, video & audio decoders
 in an easy to use wrapper.
 
-Lower-level APIs for accessing the demuxer, video decoder and audio decoder,
+Lower-level APIs for accessing the demuxer, video decoder and audio decoder, 
 as well as providing different data sources are also available.
 
-Interfaces are written in an object orientet style, meaning you create object
+Interfaces are written in an object orientet style, meaning you create object 
 instances via various different constructor functions (plm_*create()),
 do some work on them and later dispose them via plm_*destroy().
 
@@ -51,11 +51,11 @@ plm_video_*  -- the MPEG1 Video ("mpeg1") decoder
 plm_audio_*  -- the MPEG1 Audio Layer II ("mp2") decoder
 
 
-This library uses malloc(), realloc() and free() to manage memory. Typically
+This library uses malloc(), realloc() and free() to manage memory. Typically 
 all allocation happens up-front when creating the interface. However, the
 default buffer size may be too small for certain inputs. In these cases plmpeg
 will realloc() the buffer with a larger size whenever needed. You can configure
-the default buffer size by defining PLM_BUFFER_DEFAULT_SIZE *before*
+the default buffer size by defining PLM_BUFFER_DEFAULT_SIZE *before* 
 including this library.
 
 With the high-level interface you have two options to decode video & audio:
@@ -85,7 +85,7 @@ mat4 rec601 = mat4(
 gl_FragColor = vec4(y, cb, cr, 1.0) * rec601;
 
 Audio data is decoded into a struct with either one single float array with the
-samples for the left and right channel interleaved, or if the
+samples for the left and right channel interleaved, or if the 
 PLM_AUDIO_SEPARATE_CHANNELS is defined *before* including this library, into
 two separate float arrays - one for each channel.
 

dsp/mpeg/buffer.c

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

dsp/mpeg/clamp4int256-core.S

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/macros.internal.h"
+.source	__FILE__
 
 clamp4int256$core:
 	.leafprologue

dsp/mpeg/demux.c

@@ -115,8 +115,8 @@ plm_packet_t *plm_demux_decode(plm_demux_t *self) {
 	do {
 		code = plm_buffer_next_start_code(self->buffer);
 		if (
-			code == PLM_DEMUX_PACKET_VIDEO_1 ||
-			code == PLM_DEMUX_PACKET_PRIVATE ||
+			code == PLM_DEMUX_PACKET_VIDEO_1 || 
+			code == PLM_DEMUX_PACKET_PRIVATE || 
 			(code >= PLM_DEMUX_PACKET_AUDIO_1 && code <= PLM_DEMUX_PACKET_AUDIO_4)
 		) {
 			return plm_demux_decode_packet(self, code);

dsp/mpeg/mp2.c

@@ -273,11 +273,11 @@ typedef plm_audio_t plm_audio_t;
 int plm_audio_decode_header(plm_audio_t *self);
 void plm_audio_decode_frame(plm_audio_t *self);
 const plm_quantizer_spec_t *plm_audio_read_allocation(plm_audio_t *self, int sb, int tab3);
-void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part);
+void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part); 
 void plm_audio_matrix_transform(int s[32][3], int ss, float *d, int dp);
 
 plm_audio_t *plm_audio_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {
-	plm_audio_t *self = (plm_audio_t *)memalign(_Alignof(plm_audio_t), sizeof(plm_audio_t));
+	plm_audio_t *self = (plm_audio_t *)memalign(alignof(plm_audio_t), sizeof(plm_audio_t));
 	memset(self, 0, sizeof(plm_audio_t));
 
 	self->samples.count = PLM_AUDIO_SAMPLES_PER_FRAME;
@@ -345,7 +345,7 @@ plm_samples_t *plm_audio_decode(plm_audio_t *self) {
 	self->samples.time = self->time;
 
 	self->samples_decoded += PLM_AUDIO_SAMPLES_PER_FRAME;
-	self->time = (double)self->samples_decoded /
+	self->time = (double)self->samples_decoded / 
 		(double)PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
 
 	return &self->samples;
@@ -402,7 +402,7 @@ int plm_audio_decode_header(plm_audio_t *self) {
 		plm_buffer_skip(self->buffer, 16);
 	}
 
-	// Compute frame size, check if we have enough data to decode the whole
+	// Compute frame size, check if we have enough data to decode the whole 
 	// frame.
 	int bitrate = PLM_AUDIO_BIT_RATE[self->bitrate_index];
 	int samplerate = PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
@@ -561,7 +561,7 @@ void plm_audio_decode_frame(plm_audio_t *self) {
 						}
 					#else
 						for (int j = 0; j < 32; j++) {
-							self->samples.interleaved[((out_pos + j) << 1) + ch] =
+							self->samples.interleaved[((out_pos + j) << 1) + ch] = 
 								self->U[j] / 2147418112.0f;
 						}
 					#endif

dsp/mpeg/mpeg.mk

@@ -34,10 +34,11 @@ DSP_MPEG_A_DIRECTDEPS =				\
 	LIBC_RUNTIME				\
 	LIBC_STDIO				\
 	LIBC_STR				\
+	LIBC_STUBS				\
 	LIBC_SYSV				\
 	LIBC_TIME				\
 	LIBC_TINYMATH				\
-	THIRD_PARTY_COMPILER_RT
+	LIBC_UNICODE
 
 DSP_MPEG_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x))))
@@ -50,10 +51,13 @@ $(DSP_MPEG_A).pkg:				\
 		$(DSP_MPEG_A_OBJS)		\
 		$(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x)_A).pkg)
 
-o/$(MODE)/dsp/mpeg/clamp4int256-k8.o: private	\
-		CFLAGS +=			\
+o/$(MODE)/dsp/mpeg/clamp4int256-k8.o:		\
+		OVERRIDE_CFLAGS +=		\
 			-Os
 
+#o/$(MODE)/dsp/mpeg/macroblock.o:		\
+		CC = $(CLANG)
+
 DSP_MPEG_LIBS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)))
 DSP_MPEG_SRCS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_SRCS))
 DSP_MPEG_HDRS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_HDRS))

dsp/mpeg/mpeg1.c

@@ -32,6 +32,7 @@
 #include "dsp/mpeg/idct.h"
 #include "dsp/mpeg/mpeg.h"
 #include "dsp/mpeg/video.h"
+#include "libc/bits/initializer.internal.h"
 #include "libc/fmt/conv.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
@@ -71,8 +72,7 @@ static const float PLM_VIDEO_PIXEL_ASPECT_RATIO[] = {
     0.6735, /* 3:4? */
     0.7031, /* MPEG-1 / MPEG-2 video encoding divergence? */
     0.7615, 0.8055, 0.8437, 0.8935, 0.9157, 0.9815,
-    1.0255, 1.0695, 1.0950, 1.1575, 1.2051,
-};
+    1.0255, 1.0695, 1.0950, 1.1575, 1.2051};
 
 static const float PLM_VIDEO_PICTURE_RATE[] = {
     23.976, /* NTSC-Film */
@@ -591,24 +591,24 @@ void plm_video_decode_sequence_header(plm_video_t *self) {
 
   self->has_sequence_header = true;
 
-  INFOF("%s:\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15f;\n"
-        "\t%-20s = %15f;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;",
-        "New MPEG Sequence", "width", self->width, "height", self->height,
-        "framerate", self->framerate, "pixel_aspect_ratio",
-        self->pixel_aspect_ratio, "mb_size", self->mb_size, "mb_width",
-        self->mb_width, "mb_height", self->mb_height, "luma_width",
-        self->luma_width, "luma_height", self->luma_height, "chroma_width",
-        self->chroma_width, "chroma_height", self->chroma_height);
+  LOGF("%s:\n"
+       "\t%-20s = %15d;\n"
+       "\t%-20s = %15d;\n"
+       "\t%-20s = %15f;\n"
+       "\t%-20s = %15f;\n"
+       "\t%-20s = %15d;\n"
+       "\t%-20s = %15d;\n"
+       "\t%-20s = %15d;\n"
+       "\t%-20s = %15d;\n"
+       "\t%-20s = %15d;\n"
+       "\t%-20s = %15d;\n"
+       "\t%-20s = %15d;",
+       "New MPEG Sequence", "width", self->width, "height", self->height,
+       "framerate", self->framerate, "pixel_aspect_ratio",
+       self->pixel_aspect_ratio, "mb_size", self->mb_size, "mb_width",
+       self->mb_width, "mb_height", self->mb_height, "luma_width",
+       self->luma_width, "luma_height", self->luma_height, "chroma_width",
+       self->chroma_width, "chroma_height", self->chroma_height);
 }
 
 static void plm_video_copy_macroblock(plm_video_t *self, int motion_h,
@@ -1082,7 +1082,7 @@ static plm_frame_t *plm_video_decode_impl(plm_video_t *self) {
 plm_frame_t *plm_video_decode(plm_video_t *self) {
   long double tsc;
   plm_frame_t *res;
-  INFOF("plm_video_decode");
+  LOGF("plm_video_decode");
   tsc = nowl();
   res = plm_video_decode_impl(self);
   plmpegdecode_latency_ = lroundl((nowl() - tsc) * 1e6l);

dsp/mpeg/plm.c

@@ -94,9 +94,9 @@ plm_t *plm_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {
 
 	self->demux = plm_demux_create(buffer, destroy_when_done);
 
-	// In theory we should check plm_demux_get_num_video_streams() and
+	// In theory we should check plm_demux_get_num_video_streams() and 
 	// plm_demux_get_num_audio_streams() here, but older files typically
-	// do not specify these correctly. So we just assume we have a video and
+	// do not specify these correcly. So we just assume we have a video and
 	// audio stream and create the decoders.
 
 	self->video_packet_type = PLM_DEMUX_PACKET_VIDEO_1;
@@ -159,7 +159,7 @@ double plm_get_framerate(plm_t *self) {
 
 int plm_get_num_audio_streams(plm_t *self) {
 	// Some files do not specify the number of audio streams in the system header.
-	// If the reported number of streams is 0, we check if we have a samplerate,
+	// If the reported number of streams is 0, we check if we have a samplerate, 
 	// indicating at least one audio stream.
 	int num_streams = plm_demux_get_num_audio_streams(self->demux);
 	return num_streams == 0 && plm_get_samplerate(self) ? 1 : num_streams;

dsp/mpeg/slowrgb.c

@@ -40,7 +40,7 @@ asm(".include \"libc/disclaimer.inc\"");
  * @see YCbCr2RGB() in tool/viz/lib/ycbcr2rgb.c
  */
 void plm_frame_to_rgb(plm_frame_t *frame, uint8_t *rgb) {
-  // Chroma values are the same for each block of 4 pixels, so we process
+  // Chroma values are the same for each block of 4 pixels, so we proccess
   // 2 lines at a time, 2 neighboring pixels each.
   int w = frame->y.width, w2 = w >> 1;
   int y_index1 = 0, y_index2 = w, y_next_2_lines = w + (w - frame->width);

dsp/scale/gyarados.c

@@ -21,14 +21,14 @@
 #include "dsp/core/ituround.h"
 #include "dsp/core/q.h"
 #include "dsp/core/twixt8.h"
-#include "libc/intrin/bsr.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
 #include "libc/math.h"
-#include "libc/mem/gc.internal.h"
 #include "libc/mem/mem.h"
+#include "libc/nexgen32e/bsr.h"
+#include "libc/runtime/gc.internal.h"
 #include "libc/str/str.h"
 #include "libc/testlib/testlib.h"
 #include "libc/x/x.h"
@@ -101,7 +101,7 @@ struct SamplingSolution *ComputeSamplingSolution(long dn, long sn, double dar,
   if (!off) off = (dar - 1) / 2;
   f = dar < 1 ? 1 / dar : dar;
   s = 3 * f + 4;
-  fweights = gc(xcalloc(s + /*xxx*/ 2, sizeof(double)));
+  fweights = gc(xcalloc(s, sizeof(double)));
   res = NewSamplingSolution(dn, s);
   weights = res->weights;
   indices = res->indices;
@@ -203,8 +203,8 @@ void *Gyarados(long dyw, long dxw, int dst[dyw][dxw], long syw, long sxw,
       CHECK_LE(sxn, sxw);
       CHECK_LE(dyn, dyw);
       CHECK_LE(dxn, dxw);
-      CHECK_LT(_bsrl(syn) + _bsrl(sxn), 32);
-      CHECK_LT(_bsrl(dyn) + _bsrl(dxn), 32);
+      CHECK_LT(bsrl(syn) + bsrl(sxn), 32);
+      CHECK_LT(bsrl(dyn) + bsrl(dxn), 32);
       CHECK_LE(dyw, 0x7fff);
       CHECK_LE(dxw, 0x7fff);
       CHECK_LE(syw, 0x7fff);