Release Cosmopolitan v3.1.2

* Better refcounting

Cribbed from [Rust Arc][1] and the [Boost docs][2]:

"""
Increasing the reference counter can always be done with
memory_order_relaxed: New references to an object can only be formed
from an existing reference, and passing an existing reference from one
thread to another must already provide any required synchronization.

It is important to enforce any possible access to the object in one
thread (through an existing reference) to happen before deleting the
object in a different thread. This is achieved by a "release" operation
after dropping a reference (any access to the object through this
reference must obviously happened before), and an "acquire" operation
before deleting the object.

It would be possible to use memory_order_acq_rel for the fetch_sub
operation, but this results in unneeded "acquire" operations when the
reference counter does not yet reach zero and may impose a performance
penalty.
"""

[1] https://moshg.github.io/rust-std-ja/src/alloc/arc.rs.html
[2] https://www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html

* Make ZiposHandle's pos atomic

Implements a somewhat stronger guarantee than POSIX specifies: reads and
seeks are atomic. They may be arbitrarily reordered between threads, but
each one happens all the way and leaves the fd in a consistent state.

This is achieved by "locking" pos in __zipos_read by storing SIZE_MAX to
pos during the operation, so only one can be in-flight at a time. Seeks,
on the other hand, just update pos in one go, and rerun if it changed in
the meantime.

I used `LIKELY` / `UNLIKELY` to pessimize the concurrent case; hopefully
that buys back some performance.

Makefile

@@ -73,8 +73,16 @@ MODE := $(m)
 endif
 endif
 
-UNAME_M = $(shell uname -m)
-UNAME_S = $(shell uname -s)
+# detect wsl2 running cosmopolitan binaries on the host by checking whether:
+# - user ran build/bootstrap/make.com, in which case make's working directory is in wsl
+# - user ran make, in which case cocmd.com's working directory is in wsl
+ifneq ($(findstring //wsl.localhost/,$(CURDIR) $(shell pwd)),)
+$(warning wsl2 interop is enabled)
+$(error you need to run sudo sh -c 'echo -1 > /proc/sys/fs/binfmt_misc/WSLInterop')
+endif
+
+UNAME_M := $(shell uname -m)
+UNAME_S := $(shell uname -s)
 
 # apple still distributes a 17 year old version of gnu make
 ifeq ($(MAKE_VERSION), 3.81)
@@ -85,7 +93,7 @@ endif
 ifeq ($(TOOLCHAIN),)                                                # if TOOLCHAIN isn't defined
 ifeq ("$(wildcard o/third_party/gcc/bin/x86_64-linux-cosmo-*)","")  # if our gcc isn't unbundled
 ifneq ($(UNAME_M)-$(UNAME_S), x86_64-Linux)                         # if this is not amd64 linux
-$(error you need to download https://justine.lol/cosmocc-0.0.12.zip and unzip it inside the cosmo directory)
+$(error please run tool/cosmocc/fetch.sh)
 endif
 endif
 endif
@@ -115,6 +123,11 @@ o/$(MODE):			\
 	o/$(MODE)/examples	\
 	o/$(MODE)/third_party
 
+# TODO(jart): Make Emacs `C-c C-c` shortcut not need this.
+.PHONY: o/$(MODE)/ o/$(MODE)/.
+o/$(MODE)/: o/$(MODE)
+o/$(MODE)/.: o/$(MODE)
+
 # check if we're using o//third_party/make/make.com
 # we added sandboxing to guarantee cosmo's makefile is hermetic
 # it also shaves away 200ms of startup latency with native $(uniq)
@@ -158,149 +171,153 @@ include build/definitions.mk			# ├──META
 include build/config.mk				# │  You can build
 include build/rules.mk				# │  You can topologically order
 include build/online.mk				#─┘
-include libc/nexgen32e/nexgen32e.mk		#─┐
-include libc/sysv/sysv.mk			# ├──SYSTEM SUPPORT
-include libc/nt/nt.mk				# │  You can do math
-include libc/intrin/intrin.mk			# │  You can use the stack
-include third_party/compiler_rt/compiler_rt.mk	# │  You can manipulate arrays
-include libc/tinymath/tinymath.mk		# │  You can issue raw system calls
-include libc/str/str.mk				# │
-include third_party/xed/xed.mk			# │
-include third_party/puff/puff.mk		# │
-include libc/elf/elf.mk				# │
-include ape/ape.mk				# │
-include libc/fmt/fmt.mk				# │
-include libc/vga/vga.mk				#─┘
-include libc/calls/calls.mk			#─┐
-include third_party/nsync/nsync.mk		# │
-include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
-include third_party/double-conversion/dc.mk	# │  You can issue system calls
-include libc/crt/crt.mk				# │
-include third_party/dlmalloc/dlmalloc.mk	#─┘
-include libc/mem/mem.mk				#─┐
-include third_party/gdtoa/gdtoa.mk		# ├──DYNAMIC RUNTIME
-include third_party/nsync/mem/mem.mk		# │  You can now use stdio
-include libc/proc/proc.mk			# │  You can now use threads
-include libc/thread/thread.mk			# │  You can now use processes
-include tool/hello/hello.mk			# │  You can finally call malloc()
-include third_party/zlib/zlib.mk		# │
-include libc/stdio/stdio.mk			# │
-include libc/time/time.mk			# │
-include net/net.mk				# │
-include third_party/vqsort/vqsort.mk		# │
-include libc/log/log.mk				# │
-include third_party/getopt/getopt.mk		# │
-include third_party/bzip2/bzip2.mk		# │
-include dsp/core/core.mk			# │
-include third_party/musl/musl.mk		# │
-include libc/x/x.mk				# │
-include third_party/stb/stb.mk			# │
-include dsp/scale/scale.mk			# │
-include dsp/mpeg/mpeg.mk			# │
-include dsp/dsp.mk				# │
-include third_party/zlib/gz/gz.mk		# │
-include third_party/intel/intel.mk		# │
-include third_party/aarch64/aarch64.mk		# │
-include libc/libc.mk				#─┘
-include libc/sock/sock.mk			#─┐
-include dsp/tty/tty.mk				# ├──ONLINE RUNTIME
-include libc/dns/dns.mk				# │  You can communicate with the network
-include net/http/http.mk			# │
-include third_party/mbedtls/mbedtls.mk		# │
-include third_party/libcxx/libcxx.mk		# │
-include third_party/ggml/ggml.mk		# │
-include third_party/radpajama/radpajama.mk	# │
-include net/https/https.mk			# │
-include third_party/regex/regex.mk		#─┘
-include third_party/tidy/tidy.mk
-include third_party/third_party.mk
-include third_party/nsync/testing/testing.mk
-include libc/testlib/testlib.mk
-include tool/viz/lib/vizlib.mk
-include tool/args/args.mk
-include test/tool/args/test.mk
-include third_party/linenoise/linenoise.mk
-include third_party/maxmind/maxmind.mk
-include net/finger/finger.mk
-include third_party/double-conversion/test/test.mk
-include third_party/lua/lua.mk
-include third_party/tree/tree.mk
-include third_party/zstd/zstd.mk
-include third_party/tr/tr.mk
-include third_party/sed/sed.mk
-include third_party/awk/awk.mk
-include third_party/hiredis/hiredis.mk
-include third_party/make/make.mk
-include third_party/ctags/ctags.mk
-include third_party/finger/finger.mk
-include third_party/argon2/argon2.mk
-include third_party/smallz4/smallz4.mk
-include third_party/sqlite3/sqlite3.mk
-include third_party/mbedtls/test/test.mk
-include third_party/quickjs/quickjs.mk
-include third_party/lz4cli/lz4cli.mk
-include third_party/zip/zip.mk
-include third_party/xxhash/xxhash.mk
-include third_party/unzip/unzip.mk
-include tool/build/lib/buildlib.mk
-include third_party/chibicc/chibicc.mk
-include third_party/chibicc/test/test.mk
-include third_party/python/python.mk
-include tool/build/build.mk
-include tool/curl/curl.mk
-include third_party/qemu/qemu.mk
-include examples/examples.mk
-include examples/pyapp/pyapp.mk
-include examples/pylife/pylife.mk
-include tool/decode/lib/decodelib.mk
-include tool/decode/decode.mk
-include tool/lambda/lib/lib.mk
-include tool/lambda/lambda.mk
-include tool/plinko/lib/lib.mk
-include tool/plinko/plinko.mk
-include test/tool/plinko/test.mk
-include tool/net/net.mk
-include tool/viz/viz.mk
-include tool/tool.mk
-include net/turfwar/turfwar.mk
-include test/libc/tinymath/test.mk
-include test/libc/intrin/test.mk
-include test/libc/mem/test.mk
-include test/libc/nexgen32e/test.mk
-include test/libc/runtime/test.mk
-include test/libc/thread/test.mk
-include test/libc/sock/test.mk
-include test/libc/str/test.mk
-include test/libc/log/test.mk
-include test/libc/str/test.mk
-include test/libc/calls/test.mk
-include test/libc/x/test.mk
-include test/libc/xed/test.mk
-include test/libc/fmt/test.mk
-include test/libc/dns/test.mk
-include test/libc/time/test.mk
-include test/libc/proc/test.mk
-include test/libc/stdio/test.mk
-include test/libc/release/test.mk
-include test/libc/test.mk
-include test/net/http/test.mk
-include test/net/https/test.mk
-include test/net/finger/test.mk
-include test/net/test.mk
-include test/tool/build/lib/test.mk
-include test/tool/build/test.mk
-include test/tool/viz/lib/test.mk
-include test/tool/viz/test.mk
-include test/tool/net/test.mk
-include test/tool/test.mk
-include test/dsp/core/test.mk
-include test/dsp/scale/test.mk
-include test/dsp/tty/test.mk
-include test/dsp/test.mk
-include examples/package/lib/build.mk
-include examples/package/build.mk
+include libc/nexgen32e/BUILD.mk			#─┐
+include libc/sysv/BUILD.mk			# ├──SYSTEM SUPPORT
+include libc/nt/BUILD.mk			# │  You can do math
+include libc/intrin/BUILD.mk			# │  You can use the stack
+include third_party/compiler_rt/BUILD.mk	# │  You can manipulate arrays
+include libc/tinymath/BUILD.mk			# │  You can issue raw system calls
+include libc/str/BUILD.mk			# │
+include third_party/xed/BUILD.mk		# │
+include third_party/puff/BUILD.mk		# │
+include libc/elf/BUILD.mk			# │
+include ape/BUILD.mk				# │
+include libc/fmt/BUILD.mk			# │
+include libc/vga/BUILD.mk			# │
+include libc/irq/BUILD.mk			#─┘
+include libc/calls/BUILD.mk			#─┐
+include libc/irq/BUILD.mk			# ├──SYSTEMS RUNTIME
+include third_party/nsync/BUILD.mk		# │  You can issue system calls
+include libc/runtime/BUILD.mk			# │
+include third_party/double-conversion/BUILD.mk	# │
+include libc/crt/BUILD.mk			# │
+include third_party/dlmalloc/BUILD.mk		#─┘
+include libc/mem/BUILD.mk			#─┐
+include third_party/gdtoa/BUILD.mk		# ├──DYNAMIC RUNTIME
+include third_party/nsync/mem/BUILD.mk		# │  You can now use stdio
+include libc/proc/BUILD.mk			# │  You can now use threads
+include libc/dlopen/BUILD.mk			# │  You can now use processes
+include libc/thread/BUILD.mk			# │  You can finally call malloc()
+include tool/hello/BUILD.mk			# │
+include third_party/zlib/BUILD.mk		# │
+include libc/stdio/BUILD.mk			# │
+include libc/time/BUILD.mk			# │
+include net/BUILD.mk				# │
+include third_party/vqsort/BUILD.mk		# │
+include libc/log/BUILD.mk			# │
+include third_party/getopt/BUILD.mk		# │
+include third_party/bzip2/BUILD.mk		# │
+include dsp/core/BUILD.mk			# │
+include third_party/musl/BUILD.mk		# │
+include libc/x/BUILD.mk				# │
+include third_party/stb/BUILD.mk		# │
+include dsp/scale/BUILD.mk			# │
+include dsp/mpeg/BUILD.mk			# │
+include dsp/BUILD.mk				# │
+include third_party/zlib/gz/BUILD.mk		# │
+include third_party/intel/BUILD.mk		# │
+include third_party/aarch64/BUILD.mk		# │
+include libc/BUILD.mk				#─┘
+include libc/sock/BUILD.mk			#─┐
+include dsp/tty/BUILD.mk			# ├──ONLINE RUNTIME
+include libc/dns/BUILD.mk			# │  You can communicate with the network
+include net/http/BUILD.mk			# │
+include third_party/mbedtls/BUILD.mk		# │
+include third_party/libcxx/BUILD.mk		# │
+include third_party/ggml/BUILD.mk		# │
+include third_party/radpajama/BUILD.mk		# │
+include net/https/BUILD.mk			# │
+include third_party/regex/BUILD.mk		#─┘
+include third_party/tidy/BUILD.mk
+include third_party/BUILD.mk
+include third_party/nsync/testing/BUILD.mk
+include libc/testlib/BUILD.mk
+include tool/viz/lib/BUILD.mk
+include tool/args/BUILD.mk
+include test/posix/BUILD.mk
+include test/tool/args/BUILD.mk
+include third_party/linenoise/BUILD.mk
+include third_party/maxmind/BUILD.mk
+include net/finger/BUILD.mk
+include third_party/double-conversion/test/BUILD.mk
+include third_party/lua/BUILD.mk
+include third_party/tree/BUILD.mk
+include third_party/zstd/BUILD.mk
+include third_party/tr/BUILD.mk
+include third_party/sed/BUILD.mk
+include third_party/awk/BUILD.mk
+include third_party/hiredis/BUILD.mk
+include third_party/make/BUILD.mk
+include third_party/ctags/BUILD.mk
+include third_party/finger/BUILD.mk
+include third_party/argon2/BUILD.mk
+include third_party/smallz4/BUILD.mk
+include third_party/sqlite3/BUILD.mk
+include third_party/mbedtls/test/BUILD.mk
+include third_party/quickjs/BUILD.mk
+include third_party/lz4cli/BUILD.mk
+include third_party/zip/BUILD.mk
+include third_party/xxhash/BUILD.mk
+include third_party/unzip/BUILD.mk
+include tool/build/lib/BUILD.mk
+include third_party/chibicc/BUILD.mk
+include third_party/chibicc/test/BUILD.mk
+include third_party/python/BUILD.mk
+include tool/build/BUILD.mk
+include tool/curl/BUILD.mk
+include third_party/qemu/BUILD.mk
+include examples/BUILD.mk
+include examples/pyapp/BUILD.mk
+include examples/pylife/BUILD.mk
+include tool/decode/lib/BUILD.mk
+include tool/decode/BUILD.mk
+include tool/lambda/lib/BUILD.mk
+include tool/lambda/BUILD.mk
+include tool/plinko/lib/BUILD.mk
+include tool/plinko/BUILD.mk
+include test/tool/plinko/BUILD.mk
+include tool/net/BUILD.mk
+include tool/viz/BUILD.mk
+include tool/BUILD.mk
+include net/turfwar/BUILD.mk
+include test/libc/tinymath/BUILD.mk
+include test/libc/intrin/BUILD.mk
+include test/libc/mem/BUILD.mk
+include test/libc/nexgen32e/BUILD.mk
+include test/libc/runtime/BUILD.mk
+include test/libc/thread/BUILD.mk
+include test/libc/sock/BUILD.mk
+include test/libc/str/BUILD.mk
+include test/libc/log/BUILD.mk
+include test/libc/str/BUILD.mk
+include test/libc/calls/BUILD.mk
+include test/libc/x/BUILD.mk
+include test/libc/xed/BUILD.mk
+include test/libc/fmt/BUILD.mk
+include test/libc/dns/BUILD.mk
+include test/libc/time/BUILD.mk
+include test/libc/proc/BUILD.mk
+include test/libc/stdio/BUILD.mk
+include test/libc/release/BUILD.mk
+include test/libc/BUILD.mk
+include test/net/http/BUILD.mk
+include test/net/https/BUILD.mk
+include test/net/finger/BUILD.mk
+include test/net/BUILD.mk
+include test/tool/build/lib/BUILD.mk
+include test/tool/build/BUILD.mk
+include test/tool/viz/lib/BUILD.mk
+include test/tool/viz/BUILD.mk
+include test/tool/net/BUILD.mk
+include test/tool/BUILD.mk
+include test/dsp/core/BUILD.mk
+include test/dsp/scale/BUILD.mk
+include test/dsp/tty/BUILD.mk
+include test/dsp/BUILD.mk
+include examples/package/lib/BUILD.mk
+include examples/package/BUILD.mk
 #-φ-examples/package/new.sh
-include test/test.mk
+include test/BUILD.mk
 
 OBJS	 = $(foreach x,$(PKGS),$($(x)_OBJS))
 SRCS	:= $(foreach x,$(PKGS),$($(x)_SRCS))
@@ -326,7 +343,7 @@ o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(
 o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x)))) $(INCS) $(INCS)
 	$(file >$@,$(INCS))
 o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt o/$(MODE)/incs.txt $(SRCS) $(HDRS) $(INCS)
-	$(COMPILE) -AMKDEPS -L320 $(MKDEPS) -o $@ -r o/$(MODE)/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt @o/$(MODE)/incs.txt
+	$(COMPILE) -AMKDEPS -L320 $(MKDEPS) -o $@ -s -r o/$(MODE)/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt @o/$(MODE)/incs.txt
 
 o/$(MODE)/srcs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(SRCS),$(file >>$@,$(x)))
@@ -371,9 +388,11 @@ COSMOPOLITAN_OBJECTS =			\
 	THIRD_PARTY_NSYNC_MEM		\
 	LIBC_MEM			\
 	THIRD_PARTY_DLMALLOC		\
+	LIBC_DLOPEN			\
 	LIBC_RUNTIME			\
 	THIRD_PARTY_NSYNC		\
 	LIBC_ELF			\
+	LIBC_IRQ			\
 	LIBC_CALLS			\
 	LIBC_SYSV_CALLS			\
 	LIBC_VGA			\
@@ -398,13 +417,14 @@ COSMOPOLITAN_OBJECTS =			\
 	LIBC_NT_KERNEL32		\
 	LIBC_NEXGEN32E
 
-COSMOPOLITAN_HEADERS =			\
+COSMOPOLITAN_H_PKGS =			\
 	APE				\
 	LIBC				\
 	LIBC_CALLS			\
 	LIBC_DNS			\
 	LIBC_ELF			\
 	LIBC_FMT			\
+	LIBC_DLOPEN			\
 	LIBC_INTRIN			\
 	LIBC_LOG			\
 	LIBC_MEM			\
@@ -429,21 +449,41 @@ COSMOPOLITAN_HEADERS =			\
 	THIRD_PARTY_GDTOA		\
 	THIRD_PARTY_GETOPT		\
 	THIRD_PARTY_MUSL		\
+	THIRD_PARTY_ZLIB		\
 	THIRD_PARTY_REGEX
 
+COSMOCC_PKGS =				\
+	$(COSMOPOLITAN_H_PKGS)		\
+	THIRD_PARTY_AARCH64		\
+	THIRD_PARTY_LIBCXX		\
+	THIRD_PARTY_INTEL
+
 o/$(MODE)/cosmopolitan.a:		\
 		$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS))
 
-o/cosmopolitan.h:							\
-		o/$(MODE)/tool/build/rollup.com				\
-		libc/integral/normalize.inc				\
-		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS))	\
-		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_INCS))
-	$(file >$(TMPDIR)/$(subst /,_,$@),libc/integral/normalize.inc $(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS)))
+COSMOCC_HDRS =								\
+	$(wildcard libc/integral/*)					\
+	$(foreach x,$(COSMOCC_PKGS),$($(x)_HDRS))			\
+	$(foreach x,$(COSMOCC_PKGS),$($(x)_INCS))
+
+o/cosmocc.h.txt: Makefile
+	$(file >$@, $(call uniq,$(COSMOCC_HDRS)))
+
+COSMOPOLITAN_H_ROOT_HDRS =						\
+	libc/integral/normalize.inc					\
+	$(foreach x,$(COSMOPOLITAN_H_PKGS),$($(x)_HDRS))
+
+o/cosmopolitan.h.txt: Makefile
+	$(file >$@, $(call uniq,$(COSMOPOLITAN_H_ROOT_HDRS)))
+
+o/cosmopolitan.h: o/cosmopolitan.h.txt					\
+		$(wildcard libc/integral/*)				\
+		$(foreach x,$(COSMOPOLITAN_H_PKGS),$($(x)_HDRS))	\
+		$(foreach x,$(COSMOPOLITAN_H_PKGS),$($(x)_INCS))
 	@$(ECHO) '#ifndef __STRICT_ANSI__' >$@
 	@$(ECHO) '#define _COSMO_SOURCE' >>$@
 	@$(ECHO) '#endif' >>$@
-	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >>$@
+	@$(COMPILE) -AROLLUP -T$@ build/bootstrap/rollup.com @$< >>$@
 
 o/cosmopolitan.html: private .UNSANDBOXED = 1
 o/cosmopolitan.html:							\

README.md

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

ape/BUILD.mk

@@ -46,7 +46,6 @@ 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			\
@@ -274,7 +273,6 @@ o/$(MODE)/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		\

ape/ape-m1.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include <dispatch/dispatch.h>
+#include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <libkern/OSCacheControl.h>
@@ -26,6 +27,7 @@
 #include <signal.h>
 #include <stdarg.h>
 #include <stdint.h>
+#include <string.h>
 #include <sys/mman.h>
 #include <sys/random.h>
 #include <sys/uio.h>
@@ -34,7 +36,7 @@
 
 #define pagesz         16384
 #define SYSLIB_MAGIC   ('s' | 'l' << 8 | 'i' << 16 | 'b' << 24)
-#define SYSLIB_VERSION 5
+#define SYSLIB_VERSION 8
 
 struct Syslib {
   int magic;
@@ -60,7 +62,7 @@ struct Syslib {
   /* v2 (2023-09-10) */
   pthread_t (*pthread_self)(void);
   void (*dispatch_release)(dispatch_semaphore_t);
-  int (*raise)(int);
+  long (*raise)(int);
   int (*pthread_join)(pthread_t, void **);
   void (*pthread_yield_np)(void);
   int pthread_stack_min;
@@ -91,6 +93,11 @@ struct Syslib {
   long (*sem_trywait)(int *);
   long (*getrlimit)(int, struct rlimit *);
   long (*setrlimit)(int, const struct rlimit *);
+  // v6 (2023-11-03)
+  void *(*dlopen)(const char *, int);
+  void *(*dlsym)(void *, const char *);
+  int (*dlclose)(void *);
+  char *(*dlerror)(void);
 };
 
 #define ELFCLASS32  1
@@ -225,60 +232,6 @@ static const char *BaseName(const char *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) {
@@ -361,7 +314,7 @@ __attribute__((__noreturn__)) static void Pexit(const char *c, int failed,
 static char AccessCommand(struct PathSearcher *ps, unsigned long pathlen) {
   if (pathlen + 1 + ps->namelen + 1 > sizeof(ps->path)) return 0;
   if (pathlen && ps->path[pathlen - 1] != '/') ps->path[pathlen++] = '/';
-  MemMove(ps->path + pathlen, ps->name, ps->namelen);
+  memmove(ps->path + pathlen, ps->name, ps->namelen);
   ps->path[pathlen + ps->namelen] = 0;
   return !access(ps->path, X_OK);
 }
@@ -390,7 +343,7 @@ static char FindCommand(struct PathSearcher *ps) {
 
   /* paths are always 100% taken literally when a slash exists
        $ ape foo/bar.com arg1 arg2 */
-  if (MemChr(ps->name, '/', ps->namelen)) {
+  if (memchr(ps->name, '/', ps->namelen)) {
     return AccessCommand(ps, 0);
   }
 
@@ -476,6 +429,111 @@ static void pthread_jit_write_protect_np_workaround(int enabled) {
   Pexit("ape", 0, "failed to set jit write protection");
 }
 
+__attribute__((__noinline__)) static long sysret(long rc) {
+  return rc == -1 ? -errno : rc;
+}
+
+static long sys_fork(void) {
+  return sysret(fork());
+}
+
+static long sys_close(int fd) {
+  return sysret(close(fd));
+}
+
+static long sys_raise(int sig) {
+  return sysret(raise(sig));
+}
+
+static long sys_pipe(int pfds[2]) {
+  return sysret(pipe(pfds));
+}
+
+static long sys_munmap(void *addr, size_t size) {
+  return sysret(munmap(addr, size));
+}
+
+static long sys_read(int fd, void *data, size_t size) {
+  return sysret(read(fd, data, size));
+}
+
+static long sys_mprotect(void *data, size_t size, int prot) {
+  return sysret(mprotect(data, size, prot));
+}
+
+static long sys_sigaltstack(const stack_t *ss, stack_t *oss) {
+  return sysret(sigaltstack(ss, oss));
+}
+
+static long sys_getentropy(void *buf, size_t buflen) {
+  return sysret(getentropy(buf, buflen));
+}
+
+static long sys_sem_open(const char *name, int oflags, mode_t mode,
+                         unsigned value) {
+  return sysret((long)sem_open(name, oflags, mode, value));
+}
+
+static long sys_sem_unlink(const char *name) {
+  return sysret(sem_unlink(name));
+}
+
+static long sys_sem_close(sem_t *sem) {
+  return sysret(sem_close(sem));
+}
+
+static long sys_sem_post(sem_t *sem) {
+  return sysret(sem_post(sem));
+}
+
+static long sys_sem_wait(sem_t *sem) {
+  return sysret(sem_wait(sem));
+}
+
+static long sys_sem_trywait(sem_t *sem) {
+  return sysret(sem_trywait(sem));
+}
+
+static long sys_getrlimit(int which, struct rlimit *rlim) {
+  return sysret(getrlimit(which, rlim));
+}
+
+static long sys_setrlimit(int which, const struct rlimit *rlim) {
+  return sysret(setrlimit(which, rlim));
+}
+
+static long sys_write(int fd, const void *data, size_t size) {
+  return sysret(write(fd, data, size));
+}
+
+static long sys_clock_gettime(int clock, struct timespec *ts) {
+  return sysret(clock_gettime((clockid_t)clock, ts));
+}
+
+static long sys_openat(int fd, const char *path, int flags, int mode) {
+  return sysret(openat(fd, path, flags, mode));
+}
+
+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));
+}
+
+static long sys_sigaction(int sig, const struct sigaction *act,
+                          struct sigaction *oact) {
+  return sysret(sigaction(sig, act, oact));
+}
+
+static long sys_pselect(int nfds, fd_set *readfds, fd_set *writefds,
+                        fd_set *errorfds, const struct timespec *timeout,
+                        const sigset_t *sigmask) {
+  return sysret(pselect(nfds, readfds, writefds, errorfds, timeout, sigmask));
+}
+
 __attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
                                                 long *sp, struct ElfEhdr *e,
                                                 struct ElfPhdr *p,
@@ -542,8 +600,8 @@ __attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
   /* 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);
+    rc = sys_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)) {
@@ -593,17 +651,47 @@ __attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
       }
       addr = (void *)(dynbase + (p[i].p_vaddr & -pagesz));
       size = (p[i].p_vaddr & (pagesz - 1)) + p[i].p_filesz;
-      rc = (long)mmap(addr, size, prot1, flags, fd, p[i].p_offset & -pagesz);
-      if (rc < 0) Pexit(exe, rc, "prog mmap");
-      if (wipe) Bzero((void *)(dynbase + a), wipe);
+      if (prot1 & PROT_EXEC) {
+#ifdef SIP_DISABLED
+        // if sip is disabled then we can load the executable segments
+        // off the binary into memory without needing to copy anything
+        // which provides considerably better performance for building
+        rc = sys_mmap(addr, size, prot1, flags, fd, p[i].p_offset & -pagesz);
+        if (rc < 0) {
+          if (rc == -EPERM) {
+            Pexit(exe, rc,
+                  "map(exec) failed because SIP (System Integrity Protection) "
+                  "is enabled, but APE Loader was compiled with SIP_DISABLED");
+          } else {
+            Pexit(exe, rc, "map(exec) failed");
+          }
+        }
+#else
+        // the issue is that if sip is enabled then, attempting to map
+        // it with exec permission will cause xnu to phone home a hash
+        // of the entire file to apple intelligence as a one time cost
+        // which is literally minutes for executables holding big data
+        // since there's no public apple api for detecting sip we read
+        // as the default strategy which is slow but it works for both
+        rc = sys_mmap(addr, size, (prot1 = PROT_READ | PROT_WRITE),
+                      MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
+        if (rc < 0) Pexit(exe, rc, "prog mmap anon");
+        rc = pread(fd, addr, p[i].p_filesz, p[i].p_offset & -pagesz);
+        if (rc != p[i].p_filesz) Pexit(exe, -errno, "prog pread");
+#endif
+      } else {
+        rc = sys_mmap(addr, size, prot1, flags, fd, p[i].p_offset & -pagesz);
+        if (rc < 0) Pexit(exe, rc, "prog mmap");
+      }
+      if (wipe) memset((void *)(dynbase + a), 0, wipe);
       if (prot2 != prot1) {
-        rc = mprotect(addr, size, prot2);
+        rc = sys_mprotect(addr, size, prot2);
         if (rc < 0) Pexit(exe, rc, "prog mprotect");
       }
       /* allocate extra bss */
       if (c > b) {
         flags |= MAP_ANONYMOUS;
-        rc = (long)mmap((void *)(dynbase + b), c - b, prot, flags, -1, 0);
+        rc = sys_mmap((void *)(dynbase + b), c - b, prot, flags, -1, 0);
         if (rc < 0) Pexit(exe, rc, "extra bss mmap");
       }
     } else {
@@ -611,7 +699,7 @@ __attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
       addr = (void *)(dynbase + (p[i].p_vaddr & -pagesz));
       size = (p[i].p_vaddr & (pagesz - 1)) + p[i].p_memsz;
       flags |= MAP_ANONYMOUS;
-      rc = (long)mmap(addr, size, prot, flags, -1, 0);
+      rc = sys_mmap(addr, size, prot, flags, -1, 0);
       if (rc < 0) Pexit(exe, rc, "bss mmap");
     }
   }
@@ -708,7 +796,7 @@ static const char *TryElf(struct ApeLoader *M, union ElfEhdrBuf *ebuf,
   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,
+        memmove(p + i, p + i + 1,
                 (e->e_phnum - (i + 1)) * sizeof(struct ElfPhdr));
       }
       --e->e_phnum;
@@ -736,7 +824,7 @@ static const char *TryElf(struct ApeLoader *M, union ElfEhdrBuf *ebuf,
       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,
+        memmove(p + i + 1, p + i + 2,
                 (e->e_phnum - (i + 2)) * sizeof(struct ElfPhdr));
       }
       --e->e_phnum;
@@ -780,107 +868,6 @@ static const char *TryElf(struct ApeLoader *M, union ElfEhdrBuf *ebuf,
   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_close(int fd) {
-  return sysret(close(fd));
-}
-
-static long sys_pipe(int pfds[2]) {
-  return sysret(pipe(pfds));
-}
-
-static long sys_munmap(void *addr, size_t size) {
-  return sysret(munmap(addr, size));
-}
-
-static long sys_read(int fd, void *data, size_t size) {
-  return sysret(read(fd, data, size));
-}
-
-static long sys_mprotect(void *data, size_t size, int prot) {
-  return sysret(mprotect(data, size, prot));
-}
-
-static long sys_sigaltstack(const stack_t *ss, stack_t *oss) {
-  return sysret(sigaltstack(ss, oss));
-}
-
-static long sys_getentropy(void *buf, size_t buflen) {
-  return sysret(getentropy(buf, buflen));
-}
-
-static long sys_sem_open(const char *name, int oflags, mode_t mode,
-                         unsigned value) {
-  return sysret((long)sem_open(name, oflags, mode, value));
-}
-
-static long sys_sem_unlink(const char *name) {
-  return sysret(sem_unlink(name));
-}
-
-static long sys_sem_close(sem_t *sem) {
-  return sysret(sem_close(sem));
-}
-
-static long sys_sem_post(sem_t *sem) {
-  return sysret(sem_post(sem));
-}
-
-static long sys_sem_wait(sem_t *sem) {
-  return sysret(sem_wait(sem));
-}
-
-static long sys_sem_trywait(sem_t *sem) {
-  return sysret(sem_trywait(sem));
-}
-
-static long sys_getrlimit(int which, struct rlimit *rlim) {
-  return sysret(getrlimit(which, rlim));
-}
-
-static long sys_setrlimit(int which, const struct rlimit *rlim) {
-  return sysret(setrlimit(which, rlim));
-}
-
-static long sys_write(int fd, const void *data, size_t size) {
-  return sysret(write(fd, data, size));
-}
-
-static long sys_clock_gettime(int clock, struct timespec *ts) {
-  return sysret(clock_gettime((clockid_t)clock, ts));
-}
-
-static long sys_openat(int fd, const char *path, int flags, int mode) {
-  return sysret(openat(fd, path, flags, mode));
-}
-
-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));
-}
-
-static long sys_sigaction(int sig, const struct sigaction *act,
-                          struct sigaction *oact) {
-  return sysret(sigaction(sig, act, oact));
-}
-
-static long sys_pselect(int nfds, fd_set *readfds, fd_set *writefds,
-                        fd_set *errorfds, const struct timespec *timeout,
-                        const sigset_t *sigmask) {
-  return sysret(pselect(nfds, readfds, writefds, errorfds, timeout, sigmask));
-}
-
 int main(int argc, char **argv, char **envp) {
   unsigned i;
   int c, n, fd, rc;
@@ -904,6 +891,7 @@ int main(int argc, char **argv, char **envp) {
   M->lib.pthread_jit_write_protect_supported_np =
       pthread_jit_write_protect_supported_np;
   M->lib.pthread_jit_write_protect_np = pthread_jit_write_protect_np_workaround;
+  M->lib.sys_icache_invalidate = sys_icache_invalidate;
   M->lib.pthread_create = pthread_create;
   M->lib.pthread_exit = pthread_exit;
   M->lib.pthread_kill = pthread_kill;
@@ -915,7 +903,7 @@ int main(int argc, char **argv, char **envp) {
   M->lib.dispatch_walltime = dispatch_walltime;
   M->lib.pthread_self = pthread_self;
   M->lib.dispatch_release = dispatch_release;
-  M->lib.raise = raise;
+  M->lib.raise = sys_raise;
   M->lib.pthread_join = pthread_join;
   M->lib.pthread_yield_np = pthread_yield_np;
   M->lib.pthread_stack_min = PTHREAD_STACK_MIN;
@@ -943,6 +931,10 @@ int main(int argc, char **argv, char **envp) {
   M->lib.sem_trywait = sys_sem_trywait;
   M->lib.getrlimit = sys_getrlimit;
   M->lib.setrlimit = sys_setrlimit;
+  M->lib.dlopen = dlopen;
+  M->lib.dlsym = dlsym;
+  M->lib.dlclose = dlclose;
+  M->lib.dlerror = dlerror;
 
   /* getenv("_") is close enough to at_execfn */
   execfn = argc > 0 ? argv[0] : 0;
@@ -956,6 +948,21 @@ int main(int argc, char **argv, char **envp) {
   sp = (long *)(argv - 1);
   auxv = (long *)(envp + i + 1);
 
+  /* create new bottom of stack for spawned program
+     system v abi aligns this on a 16-byte boundary
+     grows down the alloc by poking the guard pages */
+  n = (auxv - sp + AUXV_WORDS + 1) * sizeof(long);
+  sp2 = (long *)__builtin_alloca(n);
+  if ((long)sp2 & 15) ++sp2;
+  for (; n > 0; n -= pagesz) {
+    ((char *)sp2)[n - 1] = 0;
+  }
+  memmove(sp2, sp, (auxv - sp) * sizeof(long));
+  argv = (char **)(sp2 + 1);
+  envp = (char **)(sp2 + 1 + argc + 1);
+  auxv = sp2 + (auxv - sp);
+  sp = sp2;
+
   /* interpret command line arguments */
   if ((M->ps.literally = argc >= 3 && !StrCmp(argv[1], "-"))) {
     /* if the first argument is a hyphen then we give the user the
@@ -968,7 +975,7 @@ int main(int argc, char **argv, char **envp) {
   } else if (argc < 2) {
     Emit("usage: ape   PROG [ARGV1,ARGV2,...]\n"
          "       ape - PROG [ARGV0,ARGV1,...]\n"
-         "actually portable executable loader silicon 1.8\n"
+         "actually portable executable loader silicon 1.9\n"
          "copyright 2023 justine alexandra roberts tunney\n"
          "https://justine.lol/ape.html\n");
     _exit(1);
@@ -978,21 +985,6 @@ int main(int argc, char **argv, char **envp) {
     argv = (char **)((sp += 1) + 1);
   }
 
-  /* create new bottom of stack for spawned program
-     system v abi aligns this on a 16-byte boundary
-     grows down the alloc by poking the guard pages */
-  n = (auxv - sp + AUXV_WORDS + 1) * sizeof(long);
-  sp2 = (long *)__builtin_alloca(n);
-  if ((long)sp2 & 15) ++sp2;
-  for (; n > 0; n -= pagesz) {
-    ((char *)sp2)[n - 1] = 0;
-  }
-  MemMove(sp2, sp, (auxv - sp) * sizeof(long));
-  argv = (char **)(sp2 + 1);
-  envp = (char **)(sp2 + 1 + argc + 1);
-  auxv = sp2 + (auxv - sp);
-  sp = sp2;
-
   /* allocate ephemeral memory for reading file */
   n = sizeof(union ElfEhdrBuf);
   ebuf = (union ElfEhdrBuf *)__builtin_alloca(n);
@@ -1003,10 +995,10 @@ int main(int argc, char **argv, char **envp) {
   /* 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, ebuf->buf, sizeof(ebuf->buf))) < 0) {
-    Pexit(exe, -1, "read");
+  } else if ((fd = sys_openat(AT_FDCWD, exe, O_RDONLY, 0)) < 0) {
+    Pexit(exe, fd, "open");
+  } else if ((rc = sys_read(fd, ebuf->buf, sizeof(ebuf->buf))) < 0) {
+    Pexit(exe, rc, "read");
   } else if ((unsigned long)rc < sizeof(ebuf->ehdr)) {
     Pexit(exe, 0, "too small");
   }
@@ -1019,8 +1011,8 @@ int main(int argc, char **argv, char **envp) {
   }
 
   /* generate some hard random data */
-  if (getentropy(M->rando, sizeof(M->rando))) {
-    Pexit(argv[0], -1, "getentropy");
+  if ((rc = sys_getentropy(M->rando, sizeof(M->rando))) < 0) {
+    Pexit(argv[0], rc, "getentropy");
   }
 
   /* ape intended behavior

ape/ape.S

@@ -592,7 +592,9 @@ ape_disk:
 
 #ifdef APE_IS_SHELL_SCRIPT
 apesh:	.ascii	"\n@\n#'\"\n"			// sixth edition shebang
-	.ascii	"m=\"$(uname -m)\"\n"
+	.ascii	"m=$(/bin/uname -m 2>/dev/null) || "
+	.ascii	"m=$(/usr/bin/uname -m 2>/dev/null) || "
+	.ascii	"m=x86_64\n"
 
 	.ascii	"if [ \"$m\" = x86_64 ] || [ \"$m\" = amd64 ]; then\n"
 //	Until all operating systems can be updated to support APE,
@@ -615,15 +617,15 @@ apesh:	.ascii	"\n@\n#'\"\n"			// sixth edition shebang
 	.ascii	     APE_VERSION_STR
 	.ascii	     "\"\n"
 	.ascii	    "[ -x \"$t\" ] || {\n"
-	.ascii	      "mkdir -p \"${t%/*}\" &&\n"
-	.ascii	      "dd if=\"$o\" of=\"$t.$$\" skip="
+	.ascii	      "/bin/mkdir -p \"${t%/*}\" &&\n"
+	.ascii	      "/bin/dd if=\"$o\" of=\"$t.$$\" skip="
 	.shstub	        ape_loader_dd_skip,2
 	.ascii	        " count="
 	.shstub	        ape_loader_dd_count,2
 	.ascii	        " bs=64 2>/dev/null\n"
 #if SupportsXnu()
 	.ascii	      "[ -d /Applications ] && "
-	.ascii	        "dd if=\"$t.$$\""
+	.ascii	        "/bin/dd if=\"$t.$$\""
 	.ascii	          " of=\"$t.$$\""
 	.ascii	          " skip=5"
 	.ascii	          " count=8"
@@ -631,8 +633,8 @@ apesh:	.ascii	"\n@\n#'\"\n"			// sixth edition shebang
 	.ascii	          " conv=notrunc"
 	.ascii	          " 2>/dev/null\n"
 #endif /* SupportsXnu() */
-	.ascii	      "chmod 755 \"$t.$$\"\n"
-	.ascii	      "mv -f \"$t.$$\" \"$t\"\n"
+	.ascii	      "/bin/chmod 755 \"$t.$$\"\n"
+	.ascii	      "/bin/mv -f \"$t.$$\" \"$t\"\n"
 	.ascii	    "}\n"
 	.ascii	    "exec \"$t\" \"$o\" \"$@\"\n"
 	.ascii	  "}\n"
@@ -648,9 +650,9 @@ apesh:	.ascii	"\n@\n#'\"\n"			// sixth edition shebang
 	.ascii	  "t=\"${TMPDIR:-${HOME:-.}}/$0\"\n"
 	.ascii	  "[ x\"$1\" != x--assimilate ] || [ ! -e \"$t\" ] && {\n"
 	.ascii	    "[ x\"$1\" != x--assimilate ] && {\n"
-	.ascii	      "mkdir -p \"${t%/*}\" 2>/dev/null\n"
-	.ascii	      "cp -f \"$o\" \"$t.$$\" &&\n"
-	.ascii	      "mv -f \"$t.$$\" \"$t\" || exit 120\n"
+	.ascii	      "/bin/mkdir -p \"${t%/*}\" 2>/dev/null\n"
+	.ascii	      "/bin/cp -f \"$o\" \"$t.$$\" &&\n"
+	.ascii	      "/bin/mv -f \"$t.$$\" \"$t\" || exit 120\n"
 	.ascii	      "o=\"$t\"\n"
 	.ascii	    "}\n"
 #endif /* APE_NO_MODIFY_SELF */
@@ -681,7 +683,7 @@ apesh:	.ascii	"\n@\n#'\"\n"			// sixth edition shebang
 	.ascii	  "exec 7<&-\n"
 #if SupportsXnu()
 	.ascii	  "[ -d /Applications ] && "
-	.ascii	    "dd if=\"$o\""
+	.ascii	    "/bin/dd if=\"$o\""
 	.ascii	      " of=\"$o\""
 	.ascii	      " bs=8"
 	.ascii	      " skip="
@@ -710,7 +712,9 @@ apesh:	.ascii	"\n@\n#'\"\n"			// sixth edition shebang
 //	because they need to be in the first 4096 bytes
         .section .emushprologue,"a",@progbits
 emush:	.ascii	"\n@\n#'\"\n"
-	.ascii	"s=\"$(uname -s)\"\n"
+	.ascii	"s=$(/bin/uname -s 2>/dev/null) || "
+	.ascii	"s=$(/usr/bin/uname -s 2>/dev/null) || "
+	.ascii	"s=Darwin\n"
 //	our script is running on a non-x86_64 architecture
 //	1. `dd` out the appropriate blink vm blob
 //	2. gunzip the blink virtual machine executable

ape/ape.h

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

ape/apeinstall.sh

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

ape/apeinstall.sh

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

ape/apeuninstall.sh

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

ape/apeuninstall.sh

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

ape/loader.c

@@ -947,6 +947,11 @@ EXTERN_C __attribute__((__noreturn__)) void ApeLoader(long di, long *sp,
     os = OPENBSD;
   }
 
+  /* xnu passes auxv as an array of strings */
+  if (os == XNU) {
+    *auxv = 0;
+  }
+
   /* detect netbsd and find end of words */
   pagesz = 0;
   for (ap = auxv; ap[0]; ap += 2) {

ape/sections.internal.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
 #define COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 extern const char __comment_start[] __attribute__((__weak__));
@@ -25,5 +24,4 @@ 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

@@ -23,6 +23,7 @@
 #ifdef __aarch64__
 
 _start:	mov	x1,sp
+	and     sp,x1,#-16
 	mov	x29,0
 	bl	ApeLoader
 	.endfn	_start,globl
@@ -33,6 +34,7 @@ XnuEntrypoint:
 	mov	$_HOSTXNU,%dl			// xnu's not unix!
 ElfEntrypoint:
 	mov	%rsp,%rsi			// save real stack
+	andq    $-16,%rsp                       // force SSE alignment
 	call	ApeLoader
 	.endfn	ElfEntrypoint,globl
 	.endfn	XnuEntrypoint,globl

bin/aarch64-unknown-cosmo-addr2line

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

bin/aarch64-unknown-cosmo-apecopy

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

bin/aarch64-unknown-cosmo-ar

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

bin/aarch64-unknown-cosmo-as

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

bin/aarch64-unknown-cosmo-nm

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

bin/aarch64-unknown-cosmo-objcopy

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

bin/aarch64-unknown-cosmo-objdump

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

bin/aarch64-unknown-cosmo-strip

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

bin/ape-install

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

bin/ape-uninstall

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

bin/apecopy

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

bin/apelink

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

bin/cosmoaddr2line

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

bin/cosmocc

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

bin/fatcosmoc++

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

bin/unknown-unknown-cosmo-ar

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

bin/unknown-unknown-cosmo-c++

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

bin/unknown-unknown-cosmo-cc

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

bin/unknown-unknown-cosmo-install

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

bin/x86_64-unknown-cosmo-addr2line

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

bin/x86_64-unknown-cosmo-apecopy

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

bin/x86_64-unknown-cosmo-ar

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

bin/x86_64-unknown-cosmo-as

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

bin/x86_64-unknown-cosmo-c++

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

bin/x86_64-unknown-cosmo-cc

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

bin/x86_64-unknown-cosmo-nm

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

bin/x86_64-unknown-cosmo-objcopy

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

bin/x86_64-unknown-cosmo-objdump

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

bin/x86_64-unknown-cosmo-strip

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

build/config.mk

@@ -228,6 +228,27 @@ PYFLAGS +=				\
 	-O2				\
 	-B
 endif
+ifeq ($(MODE), x86_64-tiny)
+CONFIG_CPPFLAGS +=			\
+	-DTINY				\
+	-DNDEBUG			\
+	-DTRUSTWORTHY
+CONFIG_CCFLAGS +=			\
+	-Os				\
+	-fno-align-functions		\
+	-fno-align-jumps		\
+	-fno-align-labels		\
+	-fno-align-loops		\
+	-fschedule-insns2		\
+	-momit-leaf-frame-pointer	\
+	-foptimize-sibling-calls	\
+	-DDWARFLESS
+TARGET_ARCH ?=				\
+	-msse3
+PYFLAGS +=				\
+	-O2				\
+	-B
+endif
 ifeq ($(MODE), aarch64-tiny)
 # TODO(jart): -mcmodel=tiny
 CONFIG_CPPFLAGS +=			\

build/definitions.mk

@@ -92,6 +92,8 @@ ARCH = x86_64
 HOSTS ?= freebsd rhel7 xnu win10 openbsd netbsd
 endif
 
+ZIPOBJ_FLAGS += -a$(ARCH)
+
 ifeq ($(PREFIX),)
 ifeq ($(USE_SYSTEM_TOOLCHAIN),)
 ifeq ($(ARCH),x86_64)
@@ -222,7 +224,8 @@ DEFAULT_CPPFLAGS +=							\
 	-D_COSMO_SOURCE							\
 	-DMODE='"$(MODE)"'						\
 	-nostdinc							\
-	-iquote .
+	-iquote.							\
+	-isystem libc/isystem
 
 DEFAULT_CFLAGS =							\
 	-std=gnu2x

dsp/core/BUILD.mk

@@ -55,7 +55,7 @@ DSP_CORE_SRCS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_SRCS))
 DSP_CORE_HDRS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_HDRS))
 DSP_CORE_CHECKS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_CHECKS))
 DSP_CORE_OBJS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_OBJS))
-$(DSP_CORE_OBJS): $(BUILD_FILES) dsp/core/core.mk
+$(DSP_CORE_OBJS): $(BUILD_FILES) dsp/core/BUILD.mk
 
 .PHONY: o/$(MODE)/dsp/core
 o/$(MODE)/dsp/core: $(DSP_CORE_CHECKS)

dsp/core/c11.h

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

dsp/core/c121.h

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

dsp/core/c121s.h

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

dsp/core/c1331.h

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

dsp/core/c1331s.h

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

dsp/core/c161.h

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

dsp/core/c161s.h

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

dsp/core/c331.h

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

dsp/core/gamma.h

@@ -1,7 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_CORE_GAMMA_H_
 #define COSMOPOLITAN_DSP_CORE_GAMMA_H_
 #include "libc/math.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 #define COMPANDLUMA(X, ...) COMPANDLUMA_(X, __VA_ARGS__)
 #define COMPANDLUMA_(X, K1, K2, K3, K4) \
@@ -19,5 +18,4 @@
 #define COMPANDLUMA_BT1886(X)     COMPANDLUMA(X, COMPANDLUMA_BT1886_MAGNUM)
 #define UNCOMPANDLUMA_BT1886(X)   UNCOMPANDLUMA(X, COMPANDLUMA_BT1886_MAGNUM)
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_GAMMA_H_ */

dsp/core/half.h

@@ -1,12 +1,10 @@
 #ifndef COSMOPOLITAN_DSP_CORE_HALF_H_
 #define COSMOPOLITAN_DSP_CORE_HALF_H_
 #include "libc/macros.internal.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 /**
  * Divides integer in half w/ rounding.
  */
 #define HALF(X) (((X) + 1) / 2)
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_HALF_H_ */

dsp/core/illumination.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_CORE_ILLUMINANT_H_
 #define COSMOPOLITAN_DSP_CORE_ILLUMINANT_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 extern const double kBradford[3][3];
@@ -27,5 +26,4 @@ void *GetChromaticAdaptationMatrix(double[3][3], const double[3],
                                    const double[3]);
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_ILLUMINANT_H_ */

dsp/core/ituround.h

@@ -1,7 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_CORE_ITUROUND_H_
 #define COSMOPOLITAN_DSP_CORE_ITUROUND_H_
 #include "libc/math.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 /**
  * An ITU recommended rounding function.
@@ -19,5 +18,4 @@ __funline int ituroundf(float x) {
   return floorf(x + .5f);
 }
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_ITUROUND_H_ */

dsp/core/ks8.h

@@ -1,7 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_CORE_KS8_H_
 #define COSMOPOLITAN_DSP_CORE_KS8_H_
 #include "libc/macros.internal.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 /**
  * Performs 16-bit scaled rounded madd w/ eight coefficients or fewer.
@@ -43,5 +42,4 @@
     x1;                                                                        \
   })
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_KS8_H_ */

dsp/core/kss8.h

@@ -2,7 +2,6 @@
 #define COSMOPOLITAN_DSP_CORE_KSS8_H_
 #include "libc/limits.h"
 #include "libc/macros.internal.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 /**
  * Performs 16-bit scaled rounded saturated madd w/ eight coefficients or fewer.
@@ -39,5 +38,4 @@
     x1;                                                                     \
   })
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_KSS8_H_ */

dsp/core/q.h

@@ -3,7 +3,6 @@
 #include "libc/limits.h"
 #include "libc/macros.internal.h"
 #include "libc/math.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 /**
  * @fileoverview Fixed point arithmetic macros.
@@ -23,5 +22,4 @@ long GetIntegerCoefficients(long[static 6], const double[static 6], long, long,
 long GetIntegerCoefficients8(long[static 8], const double[static 8], long, long,
                              long);
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_Q_H_ */

dsp/core/scalevolume.c

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

dsp/core/twixt8.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_CORE_TWIXT8_H_
 #define COSMOPOLITAN_DSP_CORE_TWIXT8_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 /**
@@ -19,5 +18,4 @@ __funline unsigned char twixt8(unsigned char al, unsigned char bl,
 }
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_TWIXT8_H_ */

dsp/mpeg/BUILD.mk

@@ -59,7 +59,7 @@ DSP_MPEG_SRCS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_SRCS))
 DSP_MPEG_HDRS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_HDRS))
 DSP_MPEG_CHECKS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_CHECKS))
 DSP_MPEG_OBJS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_OBJS))
-$(DSP_MPEG_OBJS): $(BUILD_FILES) dsp/mpeg/mpeg.mk
+$(DSP_MPEG_OBJS): $(BUILD_FILES) dsp/mpeg/BUILD.mk
 
 .PHONY: o/$(MODE)/dsp/mpeg
 o/$(MODE)/dsp/mpeg: $(DSP_MPEG_CHECKS)

dsp/mpeg/blockset.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_
 #define COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 
 #define PLM_BLOCK_SET(DEST, DEST_INDEX, DEST_WIDTH, SOURCE_INDEX, \
                       SOURCE_WIDTH, BLOCK_SIZE, OP)               \
@@ -18,5 +17,4 @@
     }                                                             \
   } while (false)
 
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_ */

dsp/mpeg/buffer.h

@@ -1,7 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_MPEG_BUFFER_H_
 #define COSMOPOLITAN_DSP_MPEG_BUFFER_H_
 #include "dsp/mpeg/mpeg.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 struct FILE;
@@ -159,5 +158,4 @@ forceinline uint16_t plm_buffer_read_vlc_uint(plm_buffer_t *self,
 }
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_MPEG_BUFFER_H_ */

dsp/mpeg/demux.h

@@ -1,7 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_MPEG_DEMUX_H_
 #define COSMOPOLITAN_DSP_MPEG_DEMUX_H_
 #include "dsp/mpeg/mpeg.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 #define START_PACK 0xBA
@@ -27,5 +26,4 @@ plm_packet_t *plm_demux_decode_packet(plm_demux_t *self, int start_code);
 plm_packet_t *plm_demux_get_packet(plm_demux_t *self);
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_MPEG_DEMUX_H_ */

dsp/mpeg/idct.h

@@ -1,10 +1,8 @@
 #ifndef COSMOPOLITAN_DSP_MPEG_IDCT_H_
 #define COSMOPOLITAN_DSP_MPEG_IDCT_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 void plm_video_idct(int *);
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_MPEG_IDCT_H_ */

dsp/mpeg/mpeg.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_MPEG_MPEG_H_
 #define COSMOPOLITAN_DSP_MPEG_MPEG_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 struct FILE;
@@ -446,5 +445,4 @@ plm_samples_t *plm_audio_decode(plm_audio_t *self);
 extern long plmpegdecode_latency_;
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_MPEG_MPEG_H_ */

dsp/mpeg/video.h

@@ -1,7 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_MPEG_VIDEO_H_
 #define COSMOPOLITAN_DSP_MPEG_VIDEO_H_
 #include "dsp/mpeg/mpeg.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 typedef struct {
@@ -58,5 +57,4 @@ void plm_video_process_macroblock_16(plm_video_t *, uint8_t *restrict,
                                      uint8_t *restrict, int, int, bool);
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_MPEG_VIDEO_H_ */

dsp/scale/BUILD.mk

@@ -58,7 +58,7 @@ DSP_SCALE_SRCS = $(foreach x,$(DSP_SCALE_ARTIFACTS),$($(x)_SRCS))
 DSP_SCALE_HDRS = $(foreach x,$(DSP_SCALE_ARTIFACTS),$($(x)_HDRS))
 DSP_SCALE_CHECKS = $(foreach x,$(DSP_SCALE_ARTIFACTS),$($(x)_CHECKS))
 DSP_SCALE_OBJS = $(foreach x,$(DSP_SCALE_ARTIFACTS),$($(x)_OBJS))
-$(DSP_SCALE_OBJS): $(BUILD_FILES) dsp/scale/scale.mk
+$(DSP_SCALE_OBJS): $(BUILD_FILES) dsp/scale/BUILD.mk
 
 .PHONY: o/$(MODE)/dsp/scale
 o/$(MODE)/dsp/scale: $(DSP_SCALE_CHECKS)

dsp/scale/cdecimate2xuint8x8.h

@@ -1,11 +1,9 @@
 #ifndef COSMOPOLITAN_DSP_SCALE_CDECIMATE2XUINT8X8_H_
 #define COSMOPOLITAN_DSP_SCALE_CDECIMATE2XUINT8X8_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 void *cDecimate2xUint8x8(unsigned long n, unsigned char[n],
                          const signed char[8]);
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_SCALE_CDECIMATE2XUINT8X8_H_ */

dsp/scale/scale.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_DSP_SCALE_SCALE_H_
 #define COSMOPOLITAN_DSP_SCALE_SCALE_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 extern long gyarados_latency_;
@@ -33,5 +32,4 @@ void *EzGyarados(long, long, long, void *, long, long, long, const void *, long,
                  long, long, long, long, long, double, double, double, double);
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_SCALE_SCALE_H_ */

dsp/tty/BUILD.mk

@@ -67,7 +67,7 @@ DSP_TTY_SRCS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)_SRCS))
 DSP_TTY_HDRS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)_HDRS))
 DSP_TTY_CHECKS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)_CHECKS))
 DSP_TTY_OBJS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)_OBJS))
-$(DSP_TTY_OBJS): $(BUILD_FILES) dsp/tty/tty.mk
+$(DSP_TTY_OBJS): $(BUILD_FILES) dsp/tty/BUILD.mk
 
 .PHONY: o/$(MODE)/dsp/tty
 o/$(MODE)/dsp/tty: $(DSP_TTY_CHECKS)

dsp/tty/describe.c

@@ -17,7 +17,6 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/tty.h"
-#include "libc/fmt/fmt.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"

dsp/tty/internal.h

@@ -3,7 +3,6 @@
 #include "dsp/tty/quant.h"
 #include "dsp/tty/ttyrgb.h"
 #include "third_party/intel/xmmintrin.internal.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 struct TtyRgb rgb2tty24f_(ttyrgb_m128);
@@ -30,5 +29,4 @@ char *setbgfg24_(char *, struct TtyRgb, struct TtyRgb);
 struct TtyRgb rgb2ansi8_(int, int, int);
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_TTY_INTERNAL_H_ */

dsp/tty/itoa8.c

@@ -17,7 +17,6 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/itoa8.h"
-#include "libc/intrin/bits.h"
 #include "libc/str/str.h"
 
 struct Itoa8 kItoa8;

dsp/tty/itoa8.h

@@ -1,7 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_TTY_ITOA8_H_
 #define COSMOPOLITAN_DSP_TTY_ITOA8_H_
 #include "libc/str/str.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 struct Itoa8 {
@@ -17,5 +16,4 @@ forceinline char *itoa8(char *p, uint8_t c) {
 }
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_TTY_ITOA8_H_ */

dsp/tty/quant.h

@@ -2,10 +2,8 @@
 #define DSP_TTY_QUANT_H_
 #include "dsp/tty/ttyrgb.h"
 #include "libc/assert.h"
-#include "libc/intrin/bits.h"
 #include "libc/limits.h"
 #include "libc/str/str.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 #define TL 0
@@ -90,5 +88,4 @@ forceinline bool ttyeq(struct TtyRgb x, struct TtyRgb y) {
 }
 
 COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* DSP_TTY_QUANT_H_ */