Add APE support for 32-bit programs

This is an experimental proof of concept demo: make -j8 o//examples/i386.i386.com o//examples/i386.i386.com --32 echo $? # <-- prints main32's argc parameter Please note there's no libc support at the moment. This change is just for fun and shouldn't be interpreted as intent to support. Having this project on the whole support i386 would be tough because the calling conventions are so different. There really isn't much in the way of low hanging fruit opportunities to do something like NOP out REX prefixes and call it a day. It'd likely need disjoint builds or possibly better yet really cleverly crafted code generation in //third_party/chibicc! Another challenge is is that Linux changed its SYSCALL ordinals when it migrated from i386 to x86_64. Linux used to use the same magic numbers as everyone else for functions like exit/write/read/etc. BSDs on the other hand didn't pointlessly renumber things. So we'd need to find a way to define the ordinals in libc/sysv/syscalls.sh twice for Linux. The same goes for other ISAs too. Especially MIPS. For the Linux Kernel alone, syscall magic numbers and data structure layouts are totally different, and that's likely the case for other ISAs on other operating systems too. Probably because ISA code historically got contributed to open source by the companies that made the chips. Ulrich Drepper wrote an amusing essay on the subject some years back.
Don't scrub PATH variable since Clang needs it
2026-11-08 17:19:47 -10:00 · 2021-02-20 15:58:48 -08:00 · 2021-02-20 12:54:13 -08:00 · 2021-02-20 12:39:39 -08:00 · 2021-02-20 10:45:55 -08:00 · 2021-02-19 23:03:34 -08:00
9181 changed files with 31553 additions and 60059 deletions
@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [jart]
@@ -0,0 +1,69 @@
+{
+	"configurations": [
+		{
+			"name": "Linux",
+			"includePath": [
+				"${workspaceFolder}"
+			],
+			"cStandard": "c11",
+			"cppStandard": "c++11",
+			"compilerPath": "${workspaceFolder}/o/third_party/gcc/bin/x86_64-linux-musl-gcc",
+			"forcedInclude": ["${workspaceFolder}/.vscode/vscode.h"],
+			"defines": [
+				"libcesque=",
+				"pureconst=",
+				"paramsnonnull(x)=",
+				"alignas(x)",
+				"alignof(x)",
+				"artificial=",
+				"nodiscard=",
+				"mayalias=",
+				"forceinline=",
+				"forcealign(x)=",
+				"scanfesque(x)=",
+				"strftimeesque(x)=",
+				"wontreturn=",
+				"textreal=",
+				"mallocesque=",
+				"callocesque=",
+				"vallocesque=",
+				"reallocesque=",
+				"strlenesque=",
+				"memcpyesque=",
+				"hasatleast=",
+				"noinline=",
+				"textexit=",
+				"returnstwice=",
+				"textwindows=",
+				"privileged=",
+				"compatfn=",
+				"noinstrument=",
+				"nodebuginfo=",
+				"interruptfn=",
+				"optimizespeed=",
+				"forcealignargpointer=",
+				"noasan=",
+				"noubsan=",
+				"testonly=",
+				"donothing=",
+				"nosideeffect=",
+				"unreachable=",
+				"thatispacked=",
+				"nothrow=",
+				"nocallback=",
+				"relegated=",
+				"hidden=",
+				"textstartup=",
+				"initarray=",
+				"returnsnonnull=",
+				"returnspointerwithnoaliases=",
+				"printfesque(x)=",
+				"attributeallocsize(x)=",
+				"returnsaligned(x)=",
+				"attributeallocalign(x)=",
+				"nullterminated(x)="
+			]
+		}
+	],
+	"version": 4
+}
@@ -0,0 +1,160 @@
+#define __VSCODE_INTELLISENSE__ 1
+#include "libc/integral/normalize.inc"
+
+#if 0
+#define __VSCODE_INTELLISENSE__ 1
+#define __BIGGEST_ALIGNMENT__   1
+#define __CHAR_MAX__            0x7F
+#define __SCHAR_MAX__           __CHAR_MAX__
+#define __SHRT_MAX__            0x7FFF
+#define __INT_MAX__             0x7FFFFFFF
+#define __LONG_MAX__            0x7FFFFFFFFFFFFFFF
+#define __LONG_LONG_MAX__       __LONG_MAX__
+#define __CHAR_MIN__            -((__CHAR_MAX__) + 1)
+#define __SHRT_MIN__            -((__SHRT_MAX__) + 1)
+#define __INT_MIN__             -((__INT_MAX__) + 1)
+#define __LONG_MIN__            -((__LONG_MAX__) + 1)
+#define __LONG_LONG_MIN__       -((__LONG_LONG_MAX__) + 1)
+#define __UCHAR_MAX__           0xFF
+#define __USHRT_MAX__           0xFFFF
+#define __UINT_MAX__            0xFFFFFFFF
+#define __ULONG_MAX__           0xFFFFFFFFFFFFFFFF
+#define __SIZE_MAX__            __ULONG_MAX__
+#define __SSIZE_MAX__           __LONG_MAX__
+#define __UINTPTR_MAX__         __SIZE_MAX__
+#define __INTPTR_MAX__          __SSIZE_MAX__
+#define __WCHAR_MAX__           __UINT_MAX__
+#define __PTRDIFF_MAX__         __UINTPTR_MAX__
+#define __INTMAX_MAX__          __ULONG_MAX__
+#define __SIZEOF_POINTER__      8
+#define __SIZEOF_SHORT__        2
+#define __SIZEOF_INT__          4
+#define __SIZEOF_LONG__         8
+#define __SIZEOF_LONG_LONG__    8
+#define __SIZEOF_PTRDIFF_T__    8
+#define __SIZEOF_SIZE_T__       8
+#define __SIZEOF_WCHAR_T__      4
+#define __SIZEOF_WINT_T__       4
+#define __SIZEOF_FLOAT__        4
+#define __SIZEOF_FLOAT128__     16
+#define __SIZEOF_DOUBLE__       8
+#define __SIZEOF_FLOAT80__      10
+#define __SIZEOF_LONG_DOUBLE__  16
+#define __FLT_MAX__             1
+#define __DBL_MAX__             1
+
+#define __INT_LEAST8_TYPE__   signed char
+#define __INT_LEAST16_TYPE__  signed short
+#define __INT_LEAST32_TYPE__  signed int
+#define __INT_LEAST64_TYPE__  signed long long
+#define __UINT_LEAST8_TYPE__  unsigned char
+#define __UINT_LEAST16_TYPE__ unsigned short
+#define __UINT_LEAST32_TYPE__ unsigned int
+#define __UINT_LEAST64_TYPE__ unsigned long long
+
+#define __UINT8_MAX__  __UCHAR_MAX__
+#define __UINT16_MAX__ __USHRT_MAX__
+#define __UINT32_MAX__ __UINT_MAX__
+#define __UINT64_MAX__ __ULONG_MAX__
+
+#define __INT8_MAX__  __CHAR_MAX__
+#define __INT16_MAX__ __SHRT_MAX__
+#define __INT32_MAX__ __INT_MAX__
+#define __INT64_MAX__ __LONG_MAX__
+
+#define ATEXIT_MAX 1
+#define STACKSIZE  0x10000
+#define ARG_MAX    255
+#define OPEN_MAX   0x7FFF
+#define CHAR_BIT   7
+#define NSIG       1
+#define NULL       (0)
+#define false 0
+#define true (!(false))
+#define COSMOPOLITAN_C_START_
+#define COSMOPOLITAN_C_END_
+#define PAGESIZE    0x1000
+#define BIGPAGESIZE 0x10000
+#define NAME_MAX    255
+
+#define SWITCHEROO(...) 0
+
+extern unsigned g_loglevel;
+
+typedef void * va_list;
+
+#define va_start(...) 0
+#define va_end(...)   0
+#define va_arg(x, y)  (y)(0)
+
+typedef signed char int8_t;
+typedef signed short int16_t;
+typedef signed int int32_t;
+#define int64_t       long long
+#define int128_t      int64_t
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+typedef unsigned long long uint128_t;
+
+typedef int errno_t;
+typedef uint64_t size_t;
+typedef unsigned long long ssize_t;
+typedef uint64_t uintptr_t;
+typedef long long intptr_t;
+
+typedef unsigned long long uintmax_t;
+typedef long long intmax_t;
+
+typedef uint32_t bool32;
+
+#ifndef __cplusplus
+typedef uint8_t bool;
+typedef uint16_t char16_t;
+typedef uint32_t char32_t;
+#endif /* __cplusplus */
+
+typedef char32_t wint_t;
+typedef char32_t wchar_t;
+typedef struct { int ax, dx; } axdx_t;
+
+/* duplicate and replace xmmintrin.internal.h to fix it for IntelliSense
+ * SEE: <> */
+
+#define _Vector_size(x) __attribute__((__vector_size__(x)))
+
+#define IMAGE_BASE_VIRTUAL 0x400000
+#define __SIGACTION(...)   (0)
+#define VEIL(x, y)         (y)
+#define STATIC_YOINK(x)
+#define BUFSIZ                1
+#define FRAMESIZE             0x10000
+#define PATH_MAX              252
+#define concat(x, y, z)       0
+#define CONCAT(a, b, c, d, e) 0
+#define shuffle(...)          0
+#define reverse(x, y)         0
+#define autotype(x)           intptr_t
+
+#define _Generic_(...) (void*)(0)
+#define _Generic(...) _Generic_
+#define _Alignas(...)
+#define _Section(...)
+
+#define offsetof(x, y)   0
+#define INITIALIZER(...) struct _dummy
+#define __far
+#define tinystrstr(...) 0
+#define BENCHLOOP(...)  0
+
+#ifdef __hook
+#undef __hook
+#endif /* __hook */
+
+#ifdef UriKeyval
+#undef UriKeyval
+#endif /* UriKeyval */
+
+#define _Static_assert(...) 0
+#endif /* 0 */
@@ -52,7 +52,7 @@
 #
 # TROUBLESHOOTING
 #
-#   make -j8 -O SILENT=0 o//examples/hello.com
+#   make -j8 -O V=1 o//examples/hello.com
 #   make o//examples/life.elf -pn |& less
 #   etc.
 #
@@ -61,7 +61,7 @@
 #   build/config.mk

 SHELL         = /bin/sh
-HOSTS        ?= freebsd openbsd rhel7 rhel5 xnu win7 win10
+HOSTS        ?= freebsd openbsd netbsd rhel7 rhel5 xnu win7 win10
 SANITY       := $(shell build/sanitycheck $$PPID)
 GNUMAKEFLAGS += --output-sync

@@ -82,18 +82,19 @@ o:	o/$(MODE)/ape		\

 PKGS =

-include ~/.cosmo.mk				#──No.1
+-include ~/.cosmo.mk
 include build/functions.mk			#─┐
-include build/definitions.mk			# ├──meta
-include build/config.mk				# │
-include build/rules.mk				# │
+include build/definitions.mk			# ├──META
+include build/config.mk				# │  You can build
+include build/rules.mk				# │  You can topologically order
 include build/online.mk				# │
 include libc/stubs/stubs.mk			#─┘
 include libc/nexgen32e/nexgen32e.mk		#─┐
-include libc/intrin/intrin.mk			# │
-include libc/linux/linux.mk			# │
-include libc/math/math.mk			# ├──metal
-include libc/tinymath/tinymath.mk		# │
+include libc/sysv/sysv.mk			# ├──SYSTEM SUPPORT
+include libc/nt/nt.mk				# │  You can do math
+include libc/intrin/intrin.mk			# │  You can use the stack
+include libc/linux/linux.mk			# │  You can manipulate arrays
+include libc/tinymath/tinymath.mk		# │  You can issue raw system calls
 include third_party/compiler_rt/compiler_rt.mk	# │
 include libc/bits/bits.mk			# │
 include libc/str/str.mk				# │
@@ -101,26 +102,21 @@ include third_party/xed/xed.mk			# │
 include third_party/zlib/zlib.mk		# │
 include libc/elf/elf.mk				# │
 include ape/lib/apelib.mk			# │
-include ape/ape.mk				#─┘
-include libc/sysv/sysv.mk			#─┐
-include libc/nt/nt.mk				# ├──system
-include libc/fmt/fmt.mk				# │
-include libc/rand/rand.mk			#─┘
+include ape/ape.mk				# │
+include libc/fmt/fmt.mk				#─┘
 include libc/calls/calls.mk			#─┐
-include libc/runtime/runtime.mk			# ├──systems
-include libc/crt/crt.mk				# │
+include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
+include libc/crt/crt.mk				# │  You can issue system calls
+include libc/rand/rand.mk			# │
 include libc/unicode/unicode.mk			# │
-include third_party/dlmalloc/dlmalloc.mk	# │
-include libc/mem/mem.mk				# │
-include libc/ohmyplus/ohmyplus.mk		# │
-include libc/zipos/zipos.mk			# │
-include third_party/gdtoa/gdtoa.mk		# │
+include third_party/dlmalloc/dlmalloc.mk	#─┘
+include libc/mem/mem.mk				#─┐
+include libc/ohmyplus/ohmyplus.mk		# ├──DYNAMIC RUNTIME
+include libc/zipos/zipos.mk			# │  You can now use stdio
+include third_party/gdtoa/gdtoa.mk		# │  You can finally call malloc()
 include libc/time/time.mk			# │
 include libc/alg/alg.mk				# │
-include libc/calls/hefty/hefty.mk		# │
 include libc/stdio/stdio.mk			# │
-include third_party/f2c/f2c.mk			# │
-include third_party/blas/blas.mk		# │
 include net/net.mk				# │
 include libc/log/log.mk				# │
 include dsp/core/core.mk			# │
@@ -133,11 +129,10 @@ include third_party/musl/musl.mk		# │
 include third_party/getopt/getopt.mk		# │
 include libc/libc.mk				#─┘
 include libc/sock/sock.mk			#─┐
-include dsp/tty/tty.mk				# ├──online
-include libc/dns/dns.mk				# │
+include dsp/tty/tty.mk				# ├──ONLINE RUNTIME
+include libc/dns/dns.mk				# │  You can communicate with the network
 include libc/crypto/crypto.mk			# │
 include net/http/http.mk			#─┘
-include third_party/lemon/lemon.mk
 include third_party/duktape/duktape.mk
 include third_party/regex/regex.mk
 include third_party/third_party.mk
@@ -151,7 +146,6 @@ include third_party/chibicc/test/test.mk
 include tool/build/emucrt/emucrt.mk
 include tool/build/emubin/emubin.mk
 include tool/build/build.mk
-include tool/calc/calc.mk
 include tool/decode/lib/decodelib.mk
 include tool/decode/decode.mk
 include tool/hash/hash.mk
@@ -160,7 +154,6 @@ include tool/viz/viz.mk
 include tool/tool.mk
 include test/libc/alg/test.mk
 include test/libc/tinymath/test.mk
-include test/libc/math/test.mk
 include test/libc/intrin/test.mk
 include test/libc/mem/test.mk
 include test/libc/nexgen32e/test.mk
@@ -201,35 +194,36 @@ include test/test.mk
 OBJS	= $(foreach x,$(PKGS),$($(x)_OBJS))
 SRCS	= $(foreach x,$(PKGS),$($(x)_SRCS))
 HDRS	= $(foreach x,$(PKGS),$($(x)_HDRS))
+INCS	= $(foreach x,$(PKGS),$($(x)_INCS))
 BINS	= $(foreach x,$(PKGS),$($(x)_BINS))
 TESTS	= $(foreach x,$(PKGS),$($(x)_TESTS))
 CHECKS	= $(foreach x,$(PKGS),$($(x)_CHECKS))

 bins:	$(BINS)
 check:	$(CHECKS)
-test:	$(TESTS)
+test:	$(TESTS) all
 depend:	o/$(MODE)/depend
 tags:	TAGS HTAGS

 o/$(MODE)/.x:
-	@$(MKDIR) $(@D) && touch $@
+	@mkdir -p $(@D) && touch $@

 o/$(MODE)/srcs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(SRCS),$(file >>$@,$(x)))

-o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS),$(dir $(x))))
-	$(file >$@) $(foreach x,$(HDRS),$(file >>$@,$(x)))
+o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
+	$(file >$@) $(foreach x,$(HDRS) $(INCS),$(file >>$@,$(x)))

-o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt $(SRCS) $(HDRS)
-	@build/mkdeps -o $@ -r o/$(MODE)/ o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
+o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt $(SRCS) $(HDRS) $(INCS)
+	@$(COMPILE) -AMKDEPS $(MKDEPS) -o $@ -r o/$(MODE)/ o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt

 TAGS:	o/$(MODE)/srcs.txt $(SRCS)
 	@rm -f $@
-	@ACTION=TAGS TARGET=$@ build/do $(TAGS) $(TAGSFLAGS) -L $< -o $@
+	@$(COMPILE) -ATAGS -T$@ $(TAGS) $(TAGSFLAGS) -L $< -o $@

 HTAGS:	o/$(MODE)/hdrs.txt $(HDRS)
 	@rm -f $@
-	@ACTION=TAGS TARGET=$@ build/do build/htags -L $< -o $@
+	@$(COMPILE) -ATAGS -T$@ build/htags -L $< -o $@

 loc: o/$(MODE)/tool/build/summy.com
 	find -name \*.h -or -name \*.c -or -name \*.S | \
@@ -253,7 +247,6 @@ COSMOPOLITAN_OBJECTS =		\
 	APE_LIB			\
 	THIRD_PARTY_MUSL	\
 	LIBC_STDIO		\
-	LIBC_CALLS_HEFTY	\
 	THIRD_PARTY_REGEX	\
 	LIBC_ALG		\
 	LIBC_MEM		\
@@ -322,7 +315,7 @@ o/cosmopolitan.h:				\
 		o/$(MODE)/tool/build/rollup.com	\
 		libc/integral/normalize.inc	\
 		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS))
-	@ACTION=ROLLUP TARGET=$@ build/do $^ >$@
+	@$(COMPILE) -AROLLUP -T$@ $^ >$@

 o/cosmopolitan.html:							\
 		o/$(MODE)/third_party/chibicc/chibicc.com.dbg		\
@@ -331,6 +324,14 @@ o/cosmopolitan.html:							\
 		-fno-common -include libc/integral/normalize.inc -o $@	\
 		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))

+$(SRCS):					\
+	libc/integral/normalize.inc		\
+	libc/integral/c.inc			\
+	libc/integral/cxx.inc			\
+	libc/integral/cxxtypescompat.inc	\
+	libc/integral/lp64arg.inc		\
+	libc/integral/lp64.inc
+
 # UNSPECIFIED PREREQUISITES TUTORIAL
 #
 # A build rule must exist for all files that make needs to consider in
@@ -353,6 +354,7 @@ o/cosmopolitan.html:							\
 ~/.cosmo.mk:
 $(SRCS):
 $(HDRS):
+$(INCS):
 .DEFAULT:
 	@echo >&2
 	@echo NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@ >&2
@@ -1,11 +1,13 @@
+![Cosmopolitan Honeybadger](usr/share/img/honeybadger.png)
+
 # Cosmopolitan

 [Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C
 a build-once run-anywhere language, like Java, except it doesn't need an
-interpreter or virtual machine. Instead, it reconfigures stock GCC to
-output a POSIX-approved polyglot format that runs natively on Linux +
-Mac + Windows + FreeBSD + OpenBSD + BIOS with the best possible
-performance and the tiniest footprint imaginable.
+interpreter or virtual machine. Instead, it reconfigures stock GCC and
+Clang to output a POSIX-approved polyglot format that runs natively on
+Linux + Mac + Windows + FreeBSD + OpenBSD + NetBSD + BIOS with the best
+possible performance and the tiniest footprint imaginable.

 ## Background

@@ -16,25 +18,33 @@ libc](https://justine.lol/cosmopolitan/index.html) website. We also have

 ## Getting Started

-Here's how to get started with the freestanding hermetically-sealed
-monolithic source repository:
+If you're doing your development work on Linux or BSD then you need just
+five files to get started:

 ```sh
-tar xf cosmopolitan-0.1.tar.gz  # see our releases page
-cd cosmo
-make -j12
-o//examples/hello.com
-```
-
-Here's how to get started with the amalgamated binaries, which let you
-bring your own build system:
-
-```sh
-unzip cosmopolitan-amalgamated-0.1.zip  # see our releases page
-echo 'main() { printf("hello world\n"); }' >hello.c
-gcc -g -O -static -fno-pie -no-pie -mno-red-zone -nostdlib -nostdinc \
-  -o hello.com.dbg hello.c -Wl,--gc-sections -Wl,-z,max-page-size=0x1000 -fuse-ld=bfd \
-  -Wl,-T,ape.lds -include cosmopolitan.h crt.o ape.o cosmopolitan.a
-objcopy -SO binary hello.com.dbg hello.com
+wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-0.2.zip
+unzip cosmopolitan-amalgamation-0.2.zip
+printf 'main() { printf("hello world\\n"); }\n' >hello.c
+gcc -g -O -static -nostdlib -nostdinc -fno-pie -no-pie -mno-red-zone \
+  -o hello.com.dbg hello.c -fuse-ld=bfd -Wl,-T,ape.lds \
+  -include cosmopolitan.h crt.o ape.o cosmopolitan.a
+objcopy -S -O binary hello.com.dbg hello.com
 ./hello.com
 ```
+
+If you're developing on Windows or MacOS 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 can also be compiled from source on any Linux distro.
+
+```sh
+wget https://justine.lol/cosmopolitan/cosmopolitan-0.2.tar.gz
+tar xf cosmopolitan-0.2.tar.gz  # see releases page
+cd cosmopolitan-0.2
+make -j16
+o//examples/hello.com
+find o -name \*.com | xargs ls -rShal | less
+```
@@ -36,7 +36,7 @@
  entails two steps: (1) create a .com.dbg binary w/ Linux toolchain and
  then (2) unwrap the .com binary embedded within:

-    objcopy -SO binary input.com.dbg output.com
+    objcopy -S -O binary input.com.dbg output.com

  Both executables will work fine, but only the .com format is portable.

@@ -176,26 +176,12 @@
 #ifdef __LINKER__
 #include "ape/macros.internal.h"
 #include "ape/config.h"
+#include "libc/dce.h"
 #include "libc/nt/pedef.internal.h"
 #include "libc/zip.h"

 ENTRY(_start)

-/* Plans real memory solution at linktime. */
-MEMORY {
-  PageZero :    org = 0x0000000000000000,  len = 0x0000000000001000
-  RealBss :     org = XLM_BASE_REAL,       len = XLM_SIZE
-  RealProgram : org = IMAGE_BASE_REAL,     len = 0x0000000000010000 - IMAGE_BASE_REAL
-  RealScratch : org = REAL_SCRATCH_AREA,   len = REAL_STACK_FRAME - REAL_SCRATCH_AREA
-  RealStack :   org = REAL_STACK_FRAME,    len = 0x0000000000010000
-  EbdaMemory :  org = 0x0000000000080000,  len = 0x0000000000020000
-  VideoMemory : org = 0x00000000000a0000,  len = 0x0000000000020000
-  Romz :        org = 0x00000000000c0000,  len = 0x0000000000030000
-  BiosMemory :  org = 0x00000000000f0000,  len = 0x0000000000010000
-  SmallCode :   org = IMAGE_BASE_PHYSICAL, len = 0x0000000040000000 - IMAGE_BASE_PHYSICAL
-  ZipData :     org = 0x0000000040000000,  len = 0x0000000040000000
-}
-
 PHDRS {
  Head PT_LOAD FLAGS(5);
  Rom PT_LOAD FLAGS(5);
@@ -215,38 +201,40 @@ SECTIONS {

    /* Real Mode */
    KEEP(*(.head))
-    . += 1;

    /* Executable & Linkable Format */
-    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 1);
+    . = ALIGN(__SIZEOF_POINTER__);
+    HIDDEN(ape_phdrs = .);
    KEEP(*(.elf.phdrs))
-    HIDDEN(.Lape.phdrs.end = .);
-    . += 1;
+    HIDDEN(ape_phdrs_end = .);
+    HIDDEN(ape_phdrs32 = .);
+    KEEP(*(.elf.phdrs32))
+    HIDDEN(ape_phdrs32_end = .);

    /* OpenBSD */
-    . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 1);
-    HIDDEN(.Lape.note = .);
+    . = ALIGN(__SIZEOF_POINTER__);
+    HIDDEN(ape_note = .);
    KEEP(*(.note.openbsd.ident))
-    HIDDEN(.Lape.note.end = .);
-    . += 1;
+    KEEP(*(.note.netbsd.ident))
+    HIDDEN(ape_note_end = .);

    /* Portable Executable */
    KEEP(*(.pe.header))
-    HIDDEN(.Lape.pe.sections = .);
+    HIDDEN(ape_pe_sections = .);
    KEEP(*(.pe.sections))
-    HIDDEN(.Lape.pe.sections_end = .);
+    HIDDEN(ape_pe_sections_end = .);
    . += 1;

    /* Mach-O */
    KEEP(*(.macho))
    . = ALIGN(__SIZEOF_POINTER__);
-    HIDDEN(.Lape.macho.end = .);
+    HIDDEN(ape_macho_end = .);
    . += 1;

    KEEP(*(.ape.pad.head))
-    . = ALIGN(4096); /* alignments only mandatory when impossible otherwise */
+    . = ALIGN(SupportsWindows() ? PAGESIZE : 16);
    HIDDEN(_ehead = .);
-  } AT>SmallCode :Head
+  } :Head

 /*BEGIN: nt addressability guarantee */

@@ -261,10 +249,10 @@ SECTIONS {
 /*END: realmode addressability guarantee */

    /* Normal Code */
-    *(.start)
+    KEEP(*(.start))
    KEEP(*(.initprologue))
    KEEP(*(SORT_BY_NAME(.init.*)))
-    KEEP(*(SORT_NONE(.init)))
+    KEEP(*(.init))
    KEEP(*(.initepilogue))
    KEEP(*(.pltprologue))
    *(.plt)
@@ -288,44 +276,26 @@ SECTIONS {
    *(.text .stub .text.*)
    KEEP(*(SORT_BY_NAME(.sort.text.*)))

-    /* Won't support NX bit DRM for tiny executables */
-    HIDDEN(.Lape.piro.align = ABSOLUTE(. > APE_PIRO_THRESHOLD ? 0x1000 : 8));
-
-    /* Code that musn't be mapped in production */
    KEEP(*(.ape.pad.test));
-    . = ALIGN(.Lape.piro.align);
    HIDDEN(__test_start = .);
    *(.test.unlikely)
    *(.test .test.*)

    /* Privileged code invulnerable to magic */
    KEEP(*(.ape.pad.privileged));
-    . = ALIGN(.Lape.piro.align);
    HIDDEN(__privileged_start = .);
    HIDDEN(__test_end = .);
    . += 1;
    *(.privileged)
+    HIDDEN(__privileged_end = .);

 /*BEGIN: Read Only Data */

    KEEP(*(.ape.pad.rodata));
-    . = ALIGN(.Lape.piro.align);
-    . += 1;

-    /* Nonspecific Read-Only Data */
    *(.rodata .rodata.*)
-    . += 1;
-
-    /* Undefined Behavior Sanitizer Types */
-    HIDDEN(__ubsan_types_start = .);
    *(.ubsan.types)
-    HIDDEN(__ubsan_types_end = .);
-    . += 1;
-
-    /* Undefined Behavior Sanitizer Data */
-    HIDDEN(__ubsan_data_start = .);
    *(.ubsan.data)
-    HIDDEN(__ubsan_data_end = .);

    /* Unit Test & Fixture Registry */

@@ -337,12 +307,28 @@ SECTIONS {
    KEEP(*(.comment))
    KEEP(*(.commentepilogue))
 #endif
-
+ 
    /* Windows DLL Import Directory */
    KEEP(*(.idata.ro));
    KEEP(*(SORT_BY_NAME(.idata.ro.*)))
    . += 1;

+    . = ALIGN(__SIZEOF_POINTER__);
+    PROVIDE_HIDDEN(__init_array_start = .);
+    KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*)
+           SORT_BY_INIT_PRIORITY(.ctors.*)))
+    KEEP(*(.ctors))
+    KEEP(*(.init_array))
+    KEEP(*(.preinit_array))
+    PROVIDE_HIDDEN(__init_array_end = .);
+
+    . = ALIGN(__SIZEOF_POINTER__);
+    PROVIDE_HIDDEN(__fini_array_start = .);
+    KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*)
+           SORT_BY_INIT_PRIORITY(.dtors.*)))
+    KEEP(*(.dtors))
+    PROVIDE_HIDDEN(__fini_array_end = .);
+
    /* Encoded Data Structures w/ Linear Initialization Order */
    KEEP(*(.initroprologue))
    KEEP(*(SORT_BY_NAME(.initro.*)))
@@ -350,13 +336,12 @@ SECTIONS {
    KEEP(*(SORT_BY_NAME(.sort.rodata.*)))

    KEEP(*(.ape.pad.text))
-    HIDDEN(.Lape.data.align = ABSOLUTE(PAGESIZE));
-    . = ALIGN(.Lape.data.align);
+    . = ALIGN(PAGESIZE);
    HIDDEN(_etext = .);
    PROVIDE_HIDDEN(etext = .);
 /*END: Read Only Data (only needed for initialization) */
 /*END: Read Only Data */
-  } AT>SmallCode :Rom
+  } :Rom

  .data . : {
 /*BEGIN: Read/Write Data */
@@ -374,42 +359,21 @@ SECTIONS {
    KEEP(*(.gotpltepilogue))

 /*BEGIN: Post-Initialization Read-Only */
-    . = ALIGN(.Lape.piro.align);
-    HIDDEN(__piro_start = .);
-
-    QUAD(IMAGE_BASE_VIRTUAL);
-
-    PROVIDE_HIDDEN(__init_array_start = .);
-    KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*)
-           SORT_BY_INIT_PRIORITY(.ctors.*)))
-    KEEP(*(SORT_NONE(.ctors)))
-    KEEP(*(SORT_NONE(.init_array)))
-    KEEP(*(SORT_NONE(.preinit_array)))
-    PROVIDE_HIDDEN(__init_array_end = .);
-
-    . += 1;
    . = ALIGN(__SIZEOF_POINTER__);
-    PROVIDE_HIDDEN(__fini_array_start = .);
-    KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*)
-           SORT_BY_INIT_PRIORITY(.dtors.*)))
-    KEEP(*(SORT_NONE(.dtors)))
-    PROVIDE_HIDDEN(__fini_array_end = .);
-
    KEEP(*(SORT_BY_NAME(.piro.relo.sort.*)))
    PROVIDE_HIDDEN(__relo_end = .);
+    . = ALIGN(__SIZEOF_POINTER__);
    KEEP(*(SORT_BY_NAME(.piro.data.sort.*)))
    KEEP(*(.piro.pad.data))
-    . = ALIGN(.Lape.data.align);
+    . = ALIGN(PAGESIZE);
    HIDDEN(_edata = .);
    PROVIDE_HIDDEN(edata = .);
-  } AT>SmallCode :Ram
+  } :Ram

  .bss . : {
    KEEP(*(SORT_BY_NAME(.piro.bss.init.*)))
    *(.piro.bss)
    KEEP(*(SORT_BY_NAME(.piro.bss.sort.*)))
-    . += 1;
-    . = ALIGN(.Lape.piro.align);
    HIDDEN(__piro_end = .);
 /*END: Post-Initialization Read-Only */

@@ -428,13 +392,16 @@ SECTIONS {
    . = ALIGN(0x10000); /* for brk()/sbrk() allocation */
    HIDDEN(_end = .);
    PROVIDE_HIDDEN(end = .);
-  } AT>SmallCode :Ram
+  } :Ram

 /*END: nt addressability guarantee */
 /*END: bsd addressability guarantee */
 /*END: linux addressability guarantee */
 /*END: xnu addressability guarantee */

+  .shstrtab            : { *(.shstrtab) }
+  .strtab              : { *(.strtab) }
+  .symtab              : { *(.symtab) }
  .stab              0 : { *(.stab) }
  .stabstr           0 : { *(.stabstr) }
  .stab.excl         0 : { *(.stab.excl) }
@@ -467,85 +434,101 @@ SECTIONS {
  .GCC.command.line  0 : { *(.GCC.command.line) }

  /DISCARD/ : {
+    *(__mcount_loc)
    *(.discard)
    *(.yoink)
    *(.*)
  }
 }

-PFSTUB8(.Lape.elf.entry, _start);
-PFSTUB8(.Lape.elf.phoff, RVA(ape.phdrs));
-PFSTUB8(.Lape.elf.shoff, 0);
-PFSTUB4(.Lape.elf.phnum, (.Lape.phdrs.end - ape.phdrs) / 56);
-PFSTUB4(.Lape.elf.shnum, 0);
-PFSTUB4(.Lape.elf.shstrndx, 0);
-SHSTUB2(.Lape.macho.dd.skip, RVA(ape.macho) / 8);
-SHSTUB2(.Lape.macho.dd.count, (.Lape.macho.end - ape.macho) / 8);
-PFSTUB4(.Lape.pe.offset, ape.pe - ape.mz);
+PFSTUB8(ape_elf_entry, _start);
+PFSTUB8(ape_elf_phoff, RVA(ape_phdrs));
+PFSTUB8(ape_elf_shoff, 0);
+PFSTUB4(ape_elf_phnum, (ape_phdrs_end - ape_phdrs) / 56);
+PFSTUB4(ape_elf_shnum, 0);
+PFSTUB4(ape_elf_shstrndx, 0);

-HIDDEN(.Lape.pe.optsz = .Lape.pe.sections - (ape.pe + 24));
-HIDDEN(.Lape.pe.shnum = (.Lape.pe.sections_end - .Lape.pe.sections) / 40);
-HIDDEN(.Lidata.idtsize = idata.idtend - idata.idt);
-HIDDEN(.Lidata.iatsize = idata.iatend - idata.iat);
+PFSTUB4(ape_elf32_entry, _start32);
+PFSTUB4(ape_elf32_phoff, RVA(ape_phdrs32));
+PFSTUB4(ape_elf32_shoff, 0);
+PFSTUB4(ape_elf32_phnum, (ape_phdrs32_end - ape_phdrs32) / 32);
+PFSTUB4(ape_elf32_shnum, 0);
+PFSTUB4(ape_elf32_shstrndx, 0);

-HIDDEN(.Lape.rom.offset = 0);
-HIDDEN(.Lape.rom.vaddr = ADDR(.head));
-HIDDEN(.Lape.rom.paddr = LOADADDR(.head));
-HIDDEN(.Lape.rom.filesz = LOADADDR(.data) - .Lape.rom.paddr);
-HIDDEN(.Lape.rom.memsz = ADDR(.data) - ADDR(.head));
-HIDDEN(.Lape.rom.align = 0x1000);
-HIDDEN(.Lape.rom.rva = RVA(.Lape.rom.vaddr));
+HIDDEN(__privileged_addr = ROUNDDOWN(__privileged_start, PAGESIZE)); 
+HIDDEN(__privileged_size = (ROUNDUP(__privileged_end, PAGESIZE) -
+                            ROUNDDOWN(__privileged_start, PAGESIZE))); 

-HIDDEN(.Lape.ram.offset = .Lape.rom.offset + .Lape.rom.filesz);
-HIDDEN(.Lape.ram.vaddr = ADDR(.data));
-HIDDEN(.Lape.ram.paddr = LOADADDR(.data));
-HIDDEN(.Lape.ram.filesz = LOADADDR(.bss) - LOADADDR(.data));
-HIDDEN(.Lape.ram.memsz = ADDR(.bss) + SIZEOF(.bss) - .Lape.ram.vaddr);
-HIDDEN(.Lape.ram.align = 0x1000);
-HIDDEN(.Lape.ram.rva = RVA(.Lape.ram.vaddr));
+HIDDEN(ape_rom_offset = 0);
+HIDDEN(ape_rom_vaddr = ADDR(.head));
+HIDDEN(ape_rom_paddr = LOADADDR(.head));
+HIDDEN(ape_rom_filesz = LOADADDR(.data) - ape_rom_paddr);
+HIDDEN(ape_rom_memsz = ADDR(.data) - ADDR(.head));
+HIDDEN(ape_rom_align = PAGESIZE);
+HIDDEN(ape_rom_rva = RVA(ape_rom_vaddr));

-HIDDEN(.Lape.note.offset = .Lape.rom.offset + (.Lape.note - .Lape.rom.vaddr));
-HIDDEN(.Lape.note.vaddr = .Lape.note);
-HIDDEN(.Lape.note.paddr = .Lape.rom.paddr + .Lape.note.offset);
-HIDDEN(.Lape.note.filesz = .Lape.note.end - .Lape.note);
-HIDDEN(.Lape.note.memsz = .Lape.note.filesz);
-HIDDEN(.Lape.note.align = __SIZEOF_POINTER__);
+HIDDEN(ape_ram_offset = ape_rom_offset + ape_rom_filesz);
+HIDDEN(ape_ram_vaddr = ADDR(.data));
+HIDDEN(ape_ram_paddr = LOADADDR(.data));
+HIDDEN(ape_ram_filesz = LOADADDR(.bss) - LOADADDR(.data));
+HIDDEN(ape_ram_memsz = ADDR(.bss) + SIZEOF(.bss) - ape_ram_vaddr);
+HIDDEN(ape_ram_align = PAGESIZE);
+HIDDEN(ape_ram_rva = RVA(ape_ram_vaddr));

-HIDDEN(.Lape.text.offset = .Lape.rom.offset + LOADADDR(.text) - .Lape.rom.paddr);
-HIDDEN(.Lape.text.paddr = LOADADDR(.text));
-HIDDEN(.Lape.text.vaddr = ADDR(.text));
-HIDDEN(.Lape.text.filesz = SIZEOF(.text));
-HIDDEN(.Lape.text.memsz = SIZEOF(.text));
-HIDDEN(.Lape.text.align = 4096);
-HIDDEN(.Lape.text.rva = RVA(.Lape.text.vaddr));
+HIDDEN(ape_note_offset = ape_rom_offset + (ape_note - ape_rom_vaddr));
+HIDDEN(ape_note_vaddr = ape_note);
+HIDDEN(ape_note_paddr = ape_rom_paddr + ape_note_offset);
+HIDDEN(ape_note_filesz = ape_note_end - ape_note);
+HIDDEN(ape_note_memsz = ape_note_filesz);
+HIDDEN(ape_note_align = __SIZEOF_POINTER__);

-HIDDEN(.Lape.data.offset = .Lape.ram.offset + LOADADDR(.data) - .Lape.ram.paddr);
-HIDDEN(.Lape.data.paddr = LOADADDR(.data));
-HIDDEN(.Lape.data.vaddr = ADDR(.data));
-HIDDEN(.Lape.data.filesz = SIZEOF(.data));
-HIDDEN(.Lape.data.memsz = SIZEOF(.data));
-HIDDEN(.Lape.data.align = 0x1000);
-HIDDEN(.Lape.data.rva = RVA(.Lape.data.vaddr));
+HIDDEN(ape_text_offset = ape_rom_offset + LOADADDR(.text) - ape_rom_paddr);
+HIDDEN(ape_text_paddr = LOADADDR(.text));
+HIDDEN(ape_text_vaddr = ADDR(.text));
+HIDDEN(ape_text_filesz = SIZEOF(.text));
+HIDDEN(ape_text_memsz = SIZEOF(.text));
+HIDDEN(ape_text_align = PAGESIZE);
+HIDDEN(ape_text_rva = RVA(ape_text_vaddr));

-HIDDEN(.Lape.bss.offset = .Lape.ram.offset + LOADADDR(.bss) - .Lape.ram.paddr);
-HIDDEN(.Lape.bss.paddr = LOADADDR(.bss));
-HIDDEN(.Lape.bss.vaddr = ADDR(.bss));
-HIDDEN(.Lape.bss.filesz = 0);
-HIDDEN(.Lape.bss.memsz = SIZEOF(.bss));
-HIDDEN(.Lape.bss.align = .Lape.data.align);
+HIDDEN(ape_data_offset = ape_ram_offset + LOADADDR(.data) - ape_ram_paddr);
+HIDDEN(ape_data_paddr = LOADADDR(.data));
+HIDDEN(ape_data_vaddr = ADDR(.data));
+HIDDEN(ape_data_filesz = SIZEOF(.data));
+HIDDEN(ape_data_memsz = SIZEOF(.data));
+HIDDEN(ape_data_align = PAGESIZE);
+HIDDEN(ape_data_rva = RVA(ape_data_vaddr));

-/* Program Loader Auto-Tune */
+HIDDEN(ape_bss_offset = ape_ram_offset + LOADADDR(.bss) - ape_ram_paddr);
+HIDDEN(ape_bss_paddr = LOADADDR(.bss));
+HIDDEN(ape_bss_vaddr = ADDR(.bss));
+HIDDEN(ape_bss_filesz = 0);
+HIDDEN(ape_bss_memsz = SIZEOF(.bss));
+HIDDEN(ape_bss_align = PAGESIZE);
+
+#if SupportsXnu()
+SHSTUB2(ape_macho_dd_skip, RVA(ape_macho) / 8);
+SHSTUB2(ape_macho_dd_count, (ape_macho_end - ape_macho) / 8);
+#endif
+
+#if SupportsWindows()
+PFSTUB4(ape_pe_offset, ape_pe - ape_mz);
+HIDDEN(ape_pe_optsz = ape_pe_sections - (ape_pe + 24));
+HIDDEN(ape_pe_shnum = (ape_pe_sections_end - ape_pe_sections) / 40);
+HIDDEN(ape_idata_idtsize = ape_idata_idtend - ape_idata_idt);
+HIDDEN(ape_idata_iatsize = ape_idata_iatend - ape_idata_iat);
+HIDDEN(v_ntsubsystem = (DEFINED(GetMessage)
+                        ? kNtImageSubsystemWindowsGui
+                        : kNtImageSubsystemWindowsCui));
+#endif
+
+#if SupportsMetal()
 HIDDEN(v_ape_realsectors =
           MIN(REAL_SCRATCH_AREA - IMAGE_BASE_REAL,
               ROUNDUP(RVA(_edata), 4096)) / 512);
 HIDDEN(v_ape_realpages = v_ape_realsectors / (4096 / 512));
 HIDDEN(v_ape_highsectors =
           (ROUNDUP(RVA(_edata), 512) / 512) - v_ape_realsectors);
-
-/* Windows NT Auto-Subsystem Embedding */
-HIDDEN(v_ntsubsystem = (DEFINED(GetMessage)
-                        ? kNtImageSubsystemWindowsGui
-                        : kNtImageSubsystemWindowsCui));
+#endif

 /* ZIP End of Central Directory header */
 #define ZIPCONST(NAME, VAL) HIDDEN(NAME = DEFINED(__zip_start) ? VAL : 0);
@@ -554,7 +537,8 @@ ZIPCONST(v_zip_cdirsize, __zip_end - __zip_start);
 ZIPCONST(v_zip_records, v_zip_cdirsize / kZipCdirHdrLinkableSize);
 ZIPCONST(v_zip_commentsize, _edata - __zip_end - kZipCdirHdrMinSize);

-/* Generates deterministic ID for Mach-O. */
+#if SupportsXnu()
+/* Generates deterministic ID. */
 #define PHI 0x9e3779b9925d4c17
 #define XOR(X,Y) ((X | Y) - (X & Y))
 #define XORSHIFT(X,Y)    \
@@ -567,85 +551,89 @@ ZIPCONST(v_zip_commentsize, _edata - __zip_end - kZipCdirHdrMinSize);
  X = (X + (Y >> 020) & 0xFF) * PHI; \
  X = (X + (Y >> 030) & 0xFF) * PHI
 #define CHURN(X)        \
-  XORSHIFT(uuid1_, X); \
-  KMH(uuid1_, X);      \
-  XORSHIFT(uuid2_, X); \
-  KMH(uuid2_, X)
-
-HIDDEN(uuid1_ = 88172645463325252);
-HIDDEN(uuid2_ = 88172645463325252);
-
-CHURN(.Lape.bss.align);
-CHURN(.Lape.bss.filesz);
-CHURN(.Lape.bss.memsz);
-CHURN(.Lape.bss.offset);
-CHURN(.Lape.bss.paddr);
-CHURN(.Lape.data.align);
-CHURN(.Lape.data.filesz);
-CHURN(.Lape.data.memsz);
-CHURN(.Lape.data.offset);
-CHURN(.Lape.data.paddr);
-CHURN(.Lape.data.rva);
-CHURN(.Lape.data.vaddr);
-CHURN(.Lape.elf.entry);
-CHURN(.Lape.elf.phnum);
-CHURN(.Lape.elf.phoff);
-CHURN(.Lape.elf.shnum);
-CHURN(.Lape.elf.shoff);
-CHURN(.Lape.elf.shstrndx);
-CHURN(.Lape.macho.end);
-CHURN(.Lape.note);
-CHURN(.Lape.note.align);
-CHURN(.Lape.note.end);
-CHURN(.Lape.note.filesz);
-CHURN(.Lape.note.memsz);
-CHURN(.Lape.note.offset);
-CHURN(.Lape.note.paddr);
-CHURN(.Lape.note.vaddr);
-CHURN(.Lape.pe.offset);
-CHURN(.Lape.pe.optsz);
-CHURN(.Lape.pe.sections);
-CHURN(.Lape.pe.sections_end);
-CHURN(.Lape.pe.shnum);
-CHURN(.Lape.phdrs.end);
-CHURN(.Lape.ram.align);
-CHURN(.Lape.ram.filesz);
-CHURN(.Lape.ram.memsz);
-CHURN(.Lape.ram.offset);
-CHURN(.Lape.ram.paddr);
-CHURN(.Lape.ram.rva);
-CHURN(.Lape.ram.vaddr);
-CHURN(.Lape.rom.align);
-CHURN(.Lape.rom.filesz);
-CHURN(.Lape.rom.memsz);
-CHURN(.Lape.rom.offset);
-CHURN(.Lape.rom.paddr);
-CHURN(.Lape.rom.rva);
-CHURN(.Lape.rom.vaddr);
-CHURN(.Lape.text.align);
-CHURN(.Lape.text.filesz);
-CHURN(.Lape.text.memsz);
-CHURN(.Lape.text.offset);
-CHURN(.Lape.text.paddr);
-CHURN(.Lape.text.rva);
-CHURN(.Lape.text.vaddr);
+  XORSHIFT(ape_uuid1, X); \
+  KMH(ape_uuid1, X);      \
+  XORSHIFT(ape_uuid2, X); \
+  KMH(ape_uuid2, X)
+HIDDEN(ape_uuid1 = 88172645463325252);
+HIDDEN(ape_uuid2 = 88172645463325252);
+CHURN(ape_bss_align);
+CHURN(ape_bss_filesz);
+CHURN(ape_bss_memsz);
+CHURN(ape_bss_offset);
+CHURN(ape_bss_paddr);
+CHURN(ape_data_filesz);
+CHURN(ape_data_memsz);
+CHURN(ape_data_offset);
+CHURN(ape_data_paddr);
+CHURN(ape_data_rva);
+CHURN(ape_data_vaddr);
+CHURN(ape_elf_entry);
+CHURN(ape_elf_phnum);
+CHURN(ape_elf_phoff);
+CHURN(ape_elf_shnum);
+CHURN(ape_elf_shoff);
+CHURN(ape_elf_shstrndx);
+CHURN(ape_macho_end);
+CHURN(ape_note);
+CHURN(ape_note_align);
+CHURN(ape_note_end);
+CHURN(ape_note_filesz);
+CHURN(ape_note_memsz);
+CHURN(ape_note_offset);
+CHURN(ape_note_paddr);
+CHURN(ape_note_vaddr);
+CHURN(ape_ram_align);
+CHURN(ape_ram_filesz);
+CHURN(ape_ram_memsz);
+CHURN(ape_ram_offset);
+CHURN(ape_ram_paddr);
+CHURN(ape_ram_rva);
+CHURN(ape_ram_vaddr);
+CHURN(ape_rom_align);
+CHURN(ape_rom_filesz);
+CHURN(ape_rom_memsz);
+CHURN(ape_rom_offset);
+CHURN(ape_rom_paddr);
+CHURN(ape_rom_rva);
+CHURN(ape_rom_vaddr);
+CHURN(ape_text_align);
+CHURN(ape_text_filesz);
+CHURN(ape_text_memsz);
+CHURN(ape_text_offset);
+CHURN(ape_text_paddr);
+CHURN(ape_text_rva);
+CHURN(ape_text_vaddr);
 CHURN(ADDR(.bss));
-CHURN(WinMain);
 CHURN(_start);
-CHURN(ape.macho);
-CHURN(ape.mz);
-CHURN(ape.pe);
-CHURN(ape.phdrs);
+CHURN(ape_phdrs);
+#if SupportsMetal()
 CHURN(v_ape_realsectors);
+#endif
+#if SupportsXnu()
+CHURN(ape_macho);
+#endif
+#if SupportsWindows()
+CHURN(ape_mz);
+CHURN(ape_pe);
+CHURN(ape_pe_offset);
+CHURN(ape_pe_optsz);
+CHURN(ape_pe_sections);
+CHURN(ape_pe_sections_end);
+CHURN(ape_pe_shnum);
+CHURN(ape_phdrs_end);
+CHURN(WinMain);
+#endif /* SupportsWindows() */
+#endif /* SupportsXnu() */

-ASSERT(ape.mz == IMAGE_BASE_VIRTUAL, "linker panic");
+ASSERT(DEFINED(ape_mz) ? ape_mz == IMAGE_BASE_VIRTUAL : 1, "linker panic");
 ASSERT((DEFINED(__init_bss_end) ? __init_bss_end : 0) % __SIZEOF_POINTER__ == 0,
       "__init_bss misalign");
 ASSERT(((DEFINED(__init_rodata_end) ? __init_rodata_end : 0) %
        __SIZEOF_POINTER__ == 0),
       "__init_rodata misalign");

-ASSERT((!DEFINED(ape.grub) ? 1 : RVA(ape.grub) < 8192),
+ASSERT((!DEFINED(ape_grub) ? 1 : RVA(ape_grub) < 8192),
       "grub stub needs to be in first 8kb of image");

 ASSERT(DEFINED(_start) || DEFINED(_start16),
@@ -657,7 +645,7 @@ ASSERT(!DEFINED(_start16) || REAL(_end) < 65536,
 /* Let's not be like Knight Capital. */
 /* NOCROSSREFS_TO(.test .text) */

-/* ASSERT(ape_sysv_start == .Lape.text.vaddr, */
+/* ASSERT(ape_sysv_start == ape_text_vaddr, */
 /*        "ape_sysv_start() must be first in .text"); */

 #endif /* __LINKER__ */
@@ -20,24 +20,27 @@ APE =	$(APE_DEPS)			\
 	o/$(MODE)/ape/ape.lds

 APELINK =				\
-	ACTION=LINK.ape 		\
-	$(MKDIR) $(@D) &&		\
+	$(COMPILE)			\
+	-ALINK.ape			\
 	$(LINK)				\
 	$(LINKARGS)			\
-	$(OUTPUT_OPTION) &&		\
-	$(STRIP)			\
-	-X $@ &&			\
-	$(GZ)				\
-	$(ZFLAGS)			\
-	-f $@.map
+	$(OUTPUT_OPTION)

 APE_FILES := $(wildcard ape/*.*)
 APE_HDRS = $(filter %.h,$(APE_FILES))
+APE_INCS = $(filter %.inc,$(APE_FILES))
 APE_SRCS = $(filter %.S,$(APE_FILES))
 APE_OBJS = $(APE_SRCS:%.S=o/$(MODE)/%.o)
 APE_DEPS = $(APE_LIB)
 APE_CHECKS = $(APE_HDRS:%=o/%.ok)

+o/$(MODE)/ape/ape.lds:			\
+		ape/ape.lds		\
+		ape/config.h		\
+		ape/macros.internal.h	\
+		libc/dce.h		\
+		libc/zip.h
+
 o/ape/idata.inc:			\
 		ape/idata.internal.h	\
 		ape/relocations.h
@@ -22,15 +22,15 @@
 #include "ape/relocations.h"
 /* clang-format off */

-/	Links function from external DLL.
-/
-/	This embeds a function pointer in the binary. The NT Executive
-/	fills its value before control is handed off to the program.
-/
-/	@note	only ELF toolchains are powerful enough to use this
-/	@see	libc/nt/master.sh
-/	@see	ape/ape.lds
-/	@see	winimp
+//	Links function from external DLL.
+//
+//	This embeds a function pointer in the binary. The NT Executive
+//	fills its value before control is handed off to the program.
+//
+//	@note	only ELF toolchains are powerful enough to use this
+//	@see	libc/nt/master.sh
+//	@see	ape/ape.lds
+//	@see	winimp
 .macro	.imp	dll:req fn:req actual:req hint
 	.dll	\dll
 	.section .piro.data.sort.iat.2.\dll\().2.\actual,"aw",@progbits
@@ -63,10 +63,10 @@
 	.previous
 .endm

-/	Defines DLL import.
-/	@note	this is an implementation detail of .imp
+//	Defines DLL import.
+//	@note	this is an implementation detail of .imp
 .macro	.dll	name:req
-  .section .idata.ro.idt.2.\name,"aG",\name,comdat
+  .section .idata.ro.idt.2.\name,"aG",@progbits,\name,comdat
 	.equ	.Lidata.idt.\name,.
 	.long	RVA(idata.ilt.\name)		# ImportLookupTable
 	.long	0				# TimeDateStamp
@@ -76,7 +76,7 @@
 	.type	.Lidata.idt.\name,@object
 	.size	.Lidata.idt.\name,.-.Lidata.idt.\name
  .previous
-  .section .idata.ro.ilt.\name\().1,"aG",\name,comdat
+  .section .idata.ro.ilt.\name\().1,"aG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
 	.type	idata.ilt.\name,@object
 idata.ilt.\name:
@@ -84,15 +84,15 @@ idata.ilt.\name:
 	...
 	decentralized content
 	...
-	*/.section .idata.ro.ilt.\name\().3,"aG",\name,comdat
+	*/.section .idata.ro.ilt.\name\().3,"aG",@progbits,\name,comdat
 	.quad	0
  .previous
-  .section .idata.ro.hnt.\name\().1,"aG",\name,comdat
+  .section .idata.ro.hnt.\name\().1,"aG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
 	.type	idata.hnt.\name,@object
 	.equ	idata.hnt.\name,.
  .previous
-  .section .piro.data.sort.iat.2.\name\().1,"awG",\name,comdat
+  .section .piro.data.sort.iat.2.\name\().1,"awG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
 	.type	idata.iat.\name,@object
 idata.iat.\name:
@@ -100,7 +100,7 @@ idata.iat.\name:
 	...
 	decentralized content
 	...
-	*/.section .piro.data.sort.iat.2.\name\().3,"awG",\name,comdat
+	*/.section .piro.data.sort.iat.2.\name\().3,"awG",@progbits,\name,comdat
 	.quad	0
  .previous
  .section .rodata.str1.1,"aSM",@progbits,1
@@ -19,8 +19,13 @@ APE_LIB_A_OBJS =					\
 	$(APE_LIB_A_SRCS_S:%.S=o/$(MODE)/%.o)		\
 	$(APE_LIB_A_SRCS_C:%.c=o/$(MODE)/%.o)

+APE_LIB_A_DIRECTDEPS =					\
+	LIBC_NEXGEN32E					\
+	LIBC_INTRIN					\
+	LIBC_STR					\
+	LIBC_STUBS
+
 APE_LIB_A_CHECKS = $(APE_LIB_A_HDRS:%=o/$(MODE)/%.ok)
-APE_LIB_A_DIRECTDEPS = LIBC_STR LIBC_NEXGEN32E LIBC_STUBS
 APE_LIB_A_DEPS = $(call uniq,$(foreach x,$(APE_LIB_A_DIRECTDEPS),$($(x))))

 $(APE_LIB_A): ape/lib/ $(APE_LIB_A).pkg $(APE_LIB_A_OBJS)
@@ -22,11 +22,11 @@
 .source	__FILE__
 .code16

-/	Resets personal computer.
-/
-/	@param	di drive number, e.g. A:\ is 0x00, C:\ is 0x80
-/	@mode	real
-/	@noreturn
+//	Resets personal computer.
+//
+//	@param	di drive number, e.g. A:\ is 0x00, C:\ is 0x80
+//	@mode	real
+//	@noreturn
 bootdr:	push	%bp
 	mov	%sp,%bp
 	mov	%di,%dx
@@ -28,7 +28,7 @@
 	.hidden	e820map
 	.type	e820map,@object
 	.size	e820map,XLM_E820_SIZE
-	e820map = ape.xlm + XLM_E820
+	e820map = ape_xlm + XLM_E820

 	.globl	e820map_xlm
 	.hidden	e820map_xlm
@@ -28,7 +28,7 @@
 	.hidden	g_ptsp
 	.type	g_ptsp,@object
 	.size	g_ptsp,XLM_PAGE_TABLE_STACK_POINTER_SIZE
-	g_ptsp = ape.xlm + XLM_PAGE_TABLE_STACK_POINTER
+	g_ptsp = ape_xlm + XLM_PAGE_TABLE_STACK_POINTER

 	.globl	g_ptsp_xlm
 	.hidden	g_ptsp_xlm
@@ -28,7 +28,7 @@
 	.hidden	kBiosDataArea
 	.type	kBiosDataArea,@object
 	.size	kBiosDataArea,XLM_BIOS_DATA_AREA_SIZE
-	kBiosDataArea = ape.xlm + XLM_BIOS_DATA_AREA
+	kBiosDataArea = ape_xlm + XLM_BIOS_DATA_AREA

 	.globl	kBiosDataAreaXlm
 	.hidden	kBiosDataAreaXlm
@@ -17,11 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "ape/lib/pc.h"
-#include "libc/bits/bits.h"

 textreal void pageunmap(int64_t vaddr) {
  uint64_t *entry;
  entry = __getpagetableentry(vaddr, 3, &g_pml4t, &g_ptsp_xlm);
  *entry &= ~PAGE_V;
-  invlpg(vaddr);
+  asm volatile("invlpg\t(%0)" : /* no outputs */ : "r"(vaddr) : "memory");
 }
@@ -63,49 +63,49 @@
 #define FPU_C2 0b0000000000000010000000000
 #define FPU_C3 0b0000000000100000000000000

-#define CR0_PE (1u << 0)  /* protected mode enabled */
-#define CR0_MP (1u << 1)  /* monitor coprocessor */
-#define CR0_EM (1u << 2)  /* no x87 fpu present if set */
-#define CR0_TS (1u << 3)  /* task switched x87 */
-#define CR0_ET (1u << 4)  /* extension type 287 or 387 */
-#define CR0_NE (1u << 5)  /* enable x87 error reporting */
-#define CR0_WP (1u << 16) /* write protect read-only pages @pl0 */
-#define CR0_AM (1u << 18) /* alignment mask */
-#define CR0_NW (1u << 29) /* global write-through cache disable */
-#define CR0_CD (1u << 30) /* global cache disable */
-#define CR0_PG (1u << 31) /* paging enabled */
+#define CR0_PE 0x01       /* protected mode enabled */
+#define CR0_MP 0x02       /* monitor coprocessor */
+#define CR0_EM 0x04       /* no x87 fpu present if set */
+#define CR0_TS 0x08       /* task switched x87 */
+#define CR0_ET 0x10       /* extension type 287 or 387 */
+#define CR0_NE 0x20       /* enable x87 error reporting */
+#define CR0_WP 0x00010000 /* write protect read-only pages @pl0 */
+#define CR0_AM 0x00040000 /* alignment mask */
+#define CR0_NW 0x20000000 /* global write-through cache disable */
+#define CR0_CD 0x40000000 /* global cache disable */
+#define CR0_PG 0x80000000 /* paging enabled */

-#define CR4_VME        (1u << 0)  /* virtual 8086 mode extension */
-#define CR4_PVI        (1u << 1)  /* protected mode virtual interrupts */
-#define CR4_TSD        (1u << 2)  /* time stamp disable (rdtsc) */
-#define CR4_DE         (1u << 3)  /* debugging extensions */
-#define CR4_PSE        (1u << 4)  /* page size extension */
-#define CR4_PAE        (1u << 5)  /* physical address extension */
-#define CR4_MCE        (1u << 6)  /* machine check exception */
-#define CR4_PGE        (1u << 7)  /* page global enabled */
-#define CR4_OSFXSR     (1u << 9)  /* enable SSE and fxsave/fxrestor */
-#define CR4_OSXMMEXCPT (1u << 10) /* enable unmasked SSE exceptions */
-#define CR4_LA57       (1u << 12) /* enable level-5 paging */
-#define CR4_VMXE       (1u << 13) /* enable VMX operations */
-#define CR4_SMXE       (1u << 14) /* enable SMX operations */
-#define CR4_FSGSBASE   (1u << 16) /* enable *FSBASE and *GSBASE instructions */
-#define CR4_PCIDE      (1u << 17) /* enable process-context identifiers */
-#define CR4_OSXSAVE    (1u << 18) /* enable XSAVE */
+#define CR4_VME        0x01       /* virtual 8086 mode extension */
+#define CR4_PVI        0x02       /* protected mode virtual interrupts */
+#define CR4_TSD        0x04       /* time stamp disable (rdtsc) */
+#define CR4_DE         0x08       /* debugging extensions */
+#define CR4_PSE        0x10       /* page size extension */
+#define CR4_PAE        0x20       /* physical address extension */
+#define CR4_MCE        0x40       /* machine check exception */
+#define CR4_PGE        0x80       /* page global enabled */
+#define CR4_OSFXSR     0x0200     /* enable SSE and fxsave/fxrestor */
+#define CR4_OSXMMEXCPT 0x0400     /* enable unmasked SSE exceptions */
+#define CR4_LA57       0x1000     /* enable level-5 paging */
+#define CR4_VMXE       0x2000     /* enable VMX operations */
+#define CR4_SMXE       0x4000     /* enable SMX operations */
+#define CR4_FSGSBASE   0x00010000 /* enable *FSBASE and *GSBASE instructions */
+#define CR4_PCIDE      0x00020000 /* enable process-context identifiers */
+#define CR4_OSXSAVE    0x00040000 /* enable XSAVE */

-#define XCR0_X87       (1u << 0)
-#define XCR0_SSE       (1u << 1)
-#define XCR0_AVX       (1u << 2)
-#define XCR0_BNDREG    (1u << 3)
-#define XCR0_BNDCSR    (1u << 4)
-#define XCR0_OPMASK    (1u << 5)
-#define XCR0_ZMM_HI256 (1u << 6)
-#define XCR0_HI16_ZMM  (1u << 7)
+#define XCR0_X87       0x01
+#define XCR0_SSE       0x02
+#define XCR0_AVX       0x04
+#define XCR0_BNDREG    0x08
+#define XCR0_BNDCSR    0x10
+#define XCR0_OPMASK    0x20
+#define XCR0_ZMM_HI256 0x40
+#define XCR0_HI16_ZMM  0x80

-#define EFER     0xC0000080 /* extended feature enable register */
-#define EFER_SCE (1u << 0)  /* system call extensions */
-#define EFER_LME (1u << 8)  /* long mode enable */
-#define EFER_LMA (1u << 10) /* long mode active */
-#define EFER_NXE (1u << 11) /* no-execute enable */
+#define EFER     0xc0000080 /* extended feature enable register */
+#define EFER_SCE 0x01       /* system call extensions */
+#define EFER_LME 0x0100     /* long mode enable */
+#define EFER_LMA 0x0400     /* long mode active */
+#define EFER_NXE 0x0800     /* no-execute enable */

 #define GDT_REAL_CODE   8
 #define GDT_REAL_DATA   16
@@ -1,3 +1,21 @@
+/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
+│vi: set et ft=asm ts=8 sw=8 fenc=utf-8                                     :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
 #ifndef APE_MACROS_H_
 #define APE_MACROS_H_
 #include "libc/macros.h"
@@ -8,9 +26,16 @@
 * @fileoverview Macros relevant to αcτµαlly pδrταblε εxεcµταblε.
 */

-/	Calls near (i.e. pc+pcrel<64kB) FUNCTION.
-/	@mode	long,legacy,real
-/	@cost	9 bytes overhead
+//	Calls function in real mode.
+//	It's needed because LLVM 8 LLD doesn't support R_X86_64_PC16.
+	.macro	call16 name:req
+	mov	$REAL(\name),%ax
+	call	*%ax
+	.endm
+
+//	Calls near (i.e. pc+pcrel<64kB) FUNCTION.
+//	@mode	long,legacy,real
+//	@cost	9 bytes overhead
 .macro	rlcall	function:req
 	.byte	0x50                   	# push %[er]ax
 	.byte	0xb8,0,0		# mov $?,%[e]ax
@@ -25,8 +50,8 @@
 912:
 .endm

-/	Loads far (i.e. <1mb) abs constexpr ADDRESS into ES:DI+EDX+RDX.
-/	@mode	long,legacy,real
+//	Loads far (i.e. <1mb) abs constexpr ADDRESS into ES:DI+EDX+RDX.
+//	@mode	long,legacy,real
 .macro	movesdi	address:req
 	.byte	0xbf			# mov $0x????xxxx,%[e]di
 	.short	\address>>4
@@ -39,8 +64,8 @@
 297:	
 .endm

-/	Loads 16-bit CONSTEXPR into Qw-register w/ optional zero-extend.
-/	@mode	long,legacy,real
+//	Loads 16-bit CONSTEXPR into Qw-register w/ optional zero-extend.
+//	@mode	long,legacy,real
 .macro	bbmov	constexpr:req abcd abcd.hi:req abcd.lo:req
 .ifnb	\abcd
  .if	(\constexpr)<128 && (\constexpr)>=0
@@ -52,8 +77,8 @@
 	movb	$(\constexpr)&0xff,\abcd.lo
 .endm

-/	Compares 16-bit CONSTEXPR with Qw-register.
-/	@mode	long,legacy,real
+//	Compares 16-bit CONSTEXPR with Qw-register.
+//	@mode	long,legacy,real
 .macro	bbcmp	constexpr:req abcd.hi:req abcd.lo:req
 	cmpb	$(\constexpr)>>8&0xff,\abcd.hi
 	jnz	387f
@@ -61,8 +86,8 @@
 387:
 .endm

-/	Adds 16-bit CONSTEXPR to Qw-register.
-/	@mode	long,legacy,real
+//	Adds 16-bit CONSTEXPR to Qw-register.
+//	@mode	long,legacy,real
 .macro	bbadd	constexpr:req abcd.hi:req abcd.lo:req
 	addb	$(\constexpr)&0xff,\abcd.lo
 .if	(\constexpr) != 0
@@ -70,8 +95,8 @@
 .endif
 .endm

-/	Subtracts 16-bit CONSTEXPR from Qw-register.
-/	@mode	long,legacy,real
+//	Subtracts 16-bit CONSTEXPR from Qw-register.
+//	@mode	long,legacy,real
 .macro	bbsub	constexpr:req abcd.hi:req abcd.lo:req
 	subb	$(\constexpr)&0xff,\abcd.lo
 .if	(\constexpr) != 0
@@ -79,8 +104,8 @@
 .endif
 .endm

-/	Ands Qw-register with 16-bit CONSTEXPR.
-/	@mode	long,legacy,real
+//	Ands Qw-register with 16-bit CONSTEXPR.
+//	@mode	long,legacy,real
 .macro	bband	constexpr:req abcd.hi:req abcd.lo:req
 .if	((\constexpr)&0xff) != 0xff || ((\constexpr)>>8&0xff) == 0xff
 	andb	$(\constexpr)&0xff,\abcd.lo
@@ -90,8 +115,8 @@
 .endif
 .endm

-/	Ors Qw-register with 16-bit CONSTEXPR.
-/	@mode	long,legacy,real
+//	Ors Qw-register with 16-bit CONSTEXPR.
+//	@mode	long,legacy,real
 .macro	bbor	constexpr:req abcd.hi:req abcd.lo:req
 .if	((\constexpr)&0xff) != 0 || ((\constexpr)>>8&0xff) != 0
 	orb	$(\constexpr)&0xff,\abcd.lo
@@ -101,8 +126,8 @@
 .endif
 .endm

-/	Performs ACTION only if in real mode.
-/	@mode	long,legacy,real
+//	Performs ACTION only if in real mode.
+//	@mode	long,legacy,real
 .macro	rlo	clobber:req action:vararg
 990:	mov	$0,\clobber
 	.if	.-990b!=3
@@ -117,10 +142,10 @@
 	.endif
 .endm

-/	Initializes real mode stack.
-/	The most holiest of holy code.
-/	@mode	real
-/	@see	www.pcjs.org/pubs/pc/reference/intel/8086/
+//	Initializes real mode stack.
+//	The most holiest of holy code.
+//	@mode	real
+//	@see	www.pcjs.org/pubs/pc/reference/intel/8086/
 .macro	rlstack	seg:req addr:req
 	cli
 	mov	\seg,%ss
@@ -128,7 +153,7 @@
 	sti
 .endm

-/	Symbolic Linker-Defined Binary Content.
+//	Symbolic Linker-Defined Binary Content.
 .macro	.stub	name:req kind:req default type=@object
 .ifnb	\default
  .equ	\name,\default
@@ -139,17 +164,17 @@
 .hidden	\name
 .endm

-/	Symbolic Linker-Defined Binary-Encoded-Bourne Content.
-/	@param	units is the number of encoded 32-bit values to insert,
-/		e.g. \000 can be encoded as 0x3030305c.
-.macro	.shstub	name:req units:req
+//	Symbolic Linker-Defined Binary-Encoded-Bourne Content.
+//	@param	units is the number of encoded 32-bit values to insert,
+//		e.g. \000 can be encoded as 0x3030305c.
+.macro	.shstub	name:req num:req
 ss	\name,0
- .if	\units>1
+ .if	\num>1
  ss	\name,1
-   .if	\units>2
+   .if	\num>2
    ss	\name,2
    ss	\name,3
-    .if	\units>4
+    .if	\num>4
     ss	\name,4
     ss	\name,5
     ss	\name,6
@@ -166,8 +191,8 @@
 #elif defined(__LINKER__)

 #define BCX_NIBBLE(X) ((((X)&0xf) > 0x9) ? ((X)&0xf) + 0x37 : ((X)&0xf) + 0x30)
-#define BCX_OCTET(X) ((BCX_NIBBLE((X) >> 4) << 8) | (BCX_NIBBLE((X) >> 0) << 0))
-#define BCX_INT16(X) ((BCX_OCTET((X) >> 8) << 16) | (BCX_OCTET((X) >> 0) << 0))
+#define BCX_OCTET(X)  ((BCX_NIBBLE((X) >> 4) << 8) | (BCX_NIBBLE((X) >> 0) << 0))
+#define BCX_INT16(X)  ((BCX_OCTET((X) >> 8) << 16) | (BCX_OCTET((X) >> 0) << 0))
 #define BCXSTUB(SYM, X)                      \
  HIDDEN(SYM##_bcx0 = BCX_INT16((X) >> 48)); \
  HIDDEN(SYM##_bcx1 = BCX_INT16((X) >> 32)); \
@@ -1,53 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-#
-# OVERVIEW
-#
-#   Cosmopolitan Archiver
-#
-# DESCRIPTION
-#
-#   This goes 100x faster than ar and ranlib.
-#
-# EXAMPLE
-#
-#   build/archive rcsD library.a foo.o ...
-
-MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit
-# if [ -x "o/$MODE/tool/build/ar.com" ]; then
-#   set -- "o/$MODE/tool/build/ar.com" "$@"
-# else
-if [ ! -x o/build/bootstrap/ar.com ]; then
-  mkdir -p o/build/bootstrap &&
-  cp -f build/bootstrap/ar.com o/build/bootstrap/ar.com.$$ &&
-  mv -f o/build/bootstrap/ar.com.$$ o/build/bootstrap/ar.com || exit
-fi
-set -- o/build/bootstrap/ar.com "$@"
-# fi
-OUT=$3
-
-printf "$LOGFMT" "${ACTION:-ARCHIVE.a}" "$OUT" >&2
-# if [ "$SILENT" = "0" ]; then
-#   # some of these windows nt archives are quite huge
-#   COLUMNS=${COLUMNS:-80}
-#   COLUMNS=$((COLUMNS - 4))
-#   printf "%s\n" "$*" |
-#     /usr/bin/fold -s -w $COLUMNS |
-#     sed -e '1bb' -e 's/^/  /' -e ':b' -e '$b' -e 's/$/ \\/' >&2
-# else
-#   printf "$LOGFMT" "${ACTION:-ARCHIVE.a}" "$OUT" >&2
-# fi
-
-REASON=failed
-trap REASON=interrupted INT
-
-"$@" >/dev/null && exit
-
-if [ "$TERM" = "dumb" ]; then
-  f='%s %s\r\n\r\n'
-else
-  f='\033[91m%s\033[39m \033[94m%s\033[39m\r\n\r\n'
-fi
-printf "$f" "archive $REASON:" "$*" >&2
-exit 1
@@ -1,50 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-#
-# OVERVIEW
-#
-#   GNU Assembler Veneer
-#
-# DESCRIPTION
-#
-#   This script wraps normal assembler commands that're transparently
-#   passed-through. It adds ephemeral logging and directory creation.
-#
-# EXAMPLE
-#
-#   TARGET=program build/assemble as -o program program.o
-#
-# SEE ALSO
-#
-#   https://justine.storage.googleapis.com/perm/as.pdf
-
-if [ ! -d o/third_party/gcc ]; then
-  third_party/gcc/unbundle.sh
-fi
-
-export LC_ALL=C
-MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit
-
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
-  printf "$LOGFMT" "${ACTION:-OBJECTIFY.s}" "$TARGET" >&2
-fi
-
-if [ "$TARGET" ]; then
-  TARGETDIR="${TARGET%/*}"
-  if [ "$TARGETDIR" != "$TARGET" ] && [ ! -d "$TARGETDIR" ]; then
-    $MKDIR "$TARGETDIR" || exit 2
-  fi
-fi
-
-"$@" && exit
-
-if [ "$TERM" = "dumb" ]; then
-  f='%s %s\r\n\r\n'
-else
-  f='\033[91m%s\033[39m \033[94m%s\033[39m\r\n\r\n'
-fi
-printf "$f" "assemble failed:" "$*" >&2
-exit 1
@@ -1,284 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-#
-# OVERVIEW
-#
-#   GNU/LLVM Compiler Frontend Frontend
-#
-# DESCRIPTION
-#
-#   This wrapper script filters out certain flags so the compiler won't
-#   whine, and passes extra information to the preprocessor.
-#
-# EXAMPLE
-#
-#   build/compile cc -o program program.c
-
-if [ ! -d o/third_party/gcc ]; then
-  third_party/gcc/unbundle.sh
-fi
-
-if [ "$1" = "clang-10" ]; then
-  if ! command -v clang-10 >/dev/null; then
-    shift
-    set -- o/third_party/gcc/bin/x86_64-linux-musl-gcc "$@"
-  fi
-fi
-
-if [ "$1" = "clang++-10" ]; then
-  if ! command -v clang++-10 >/dev/null; then
-    shift
-    set -- o/third_party/gcc/bin/x86_64-linux-musl-g++ "$@"
-  fi
-fi
-
-export LC_ALL=C
-MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit
-
-GZME=
-PLAT="${1%% *}"
-FDIAGNOSTIC_COLOR=
-CCNAME=${CCNAME:-gcc}
-CCVERSION=${CCVERSION:-4}
-COUNTERMAND=
-
-# The GNU Compiler Collection passes a lot of CFLAGS to the preprocessor
-# (which we call CCFLAGS) but it should pass more; and we do just that.
-NOPG=0
-FIRST=1
-OUTARG=0
-INVISIBLE=0
-for x; do
-  if [ $FIRST -eq 1 ]; then
-    set --
-    FIRST=0
-  fi
-  if [ $OUTARG -eq 1 ]; then
-    OUTARG=0
-    OUT="$x"
-  fi
-  case "$x" in
-    -o)
-      set -- "$@" "$x"
-      OUTARG=1
-      ;;
-    -w)
-      set -- "$@" "$x" -D__W__
-      ;;
-    -x-no-pg)
-      NOPG=1
-      ;;
-    -pg)
-      if [ $NOPG -eq 0 ] && [ $INVISIBLE -eq 0 ]; then
-        set -- "$@" "$x" -D__PG__  # @see libc/macros.h
-      fi
-      ;;
-    -mfentry)
-      if [ $NOPG -eq 0 ] && [ $INVISIBLE -eq 0 ]; then
-        set -- "$@" "$x" -D__MFENTRY__
-      fi
-      ;;
-    -fomit-frame-pointer)
-      INVISIBLE=1
-      set -- "$@" "$x"
-      ;;
-    -mno-vzeroupper)
-      set -- "$@" "$x" -Wa,-msse2avx -D__MNO_VZEROUPPER__
-      ;;
-    -fsanitize=undefined)
-      set -- "$@" "$x" -D__FSANITIZE_UNDEFINED__
-      COUNTERMAND="$COUNTERMAND -fno-data-sections"  # sqlite.o
-      ;;
-    -mnop-mcount)
-      if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 6 ]; then
-        set -- "$@" "$x" -D__MNOP_MCOUNT__
-      fi
-      ;;
-    -mrecord-mcount)
-      if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 6 ]; then
-        set -- "$@" "$x" -D__MRECORD_MCOUNT__
-      fi
-      ;;
-    -fsanitize=implicit*integer*)
-      if ! [ "$CCNAME" = "gcc" ]; then
-        set -- "$@" "$x"
-      fi
-      ;;
-    -f*sanitize*|-gz*|-*stack-protector*|-fvect-cost*|-mstringop*)
-      if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 6 ]; then
-        set -- "$@" "$x"
-      fi
-      ;;
-    -freorder-blocks-and-partition|-fstack-clash-protection)
-      if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 8 ]; then
-        set -- "$@" "$x"
-      fi
-      ;;
-    -fdiagnostic-color=*)
-      FDIAGNOSTIC_COLOR=$x
-      ;;
-    -fopt-info*=*.optinfo)
-      if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 9 ]; then
-        GZME="$GZME ${x##*=}"
-        set -- "$@" "$x"
-      fi
-      ;;
-    -R*)                         # e.g. clang's -Rpass-missed=all
-      if [ "${PLAT#*clang}" != "${PLAT}" ]; then
-        set -- "$@" "$x"
-      fi
-      ;;
-    -fsave-optimization-record)  # clang only
-      if [ "${PLAT#*clang}" != "${PLAT}" ]; then
-        set -- "$@" "$x"
-      fi
-      ;;
-    *)
-      set -- "$@" "$x"
-      ;;
-  esac
-done
-if [ -z "$FDIAGNOSTIC_COLOR" ] && [ "$TERM" != "dumb" ]; then
-  FDIAGNOSTIC_COLOR=-fdiagnostics-color=always
-fi
-
-if [ "${PLAT#*clang}" != "${PLAT}" ]; then
-  FIRST=1
-  for x; do
-    # clang's assembler isn't complete yet
-    if [ $FIRST -eq 1 ]; then
-      set --                                \
-          "$x"                              \
-          -fno-integrated-as                \
-          -Wno-unused-command-line-argument \
-          -Wno-incompatible-pointer-types-discards-qualifiers
-      FIRST=0
-      continue
-    fi
-    TRAPV= # clang handles -f{,no-}{trap,wrap}v weird
-    # removes flags clang whines about
-    case "$x" in
-      -gstabs) ;;
-      -ftrapv) ;;
-      -ffixed-*) ;;
-      -fcall-saved*) ;;
-      -fsignaling-nans) ;;
-      -fcx-limited-range) ;;
-      -fno-fp-int-builtin-inexact) ;;
-      -Wno-unused-but-set-variable) ;;
-      -Wunsafe-loop-optimizations) ;;
-      -mdispatch-scheduler) ;;
-      -ftracer) ;;
-      -frounding-math) ;;
-      -fmerge-constants) ;;
-      -fmodulo-sched) ;;
-      -msse2avx)
-        set -- "$@" -Wa,-msse2avx
-        ;;
-      -fopt-info-vec) ;;
-      -fopt-info-vec-missed) ;;
-      -fmodulo-sched-allow-regmoves) ;;
-      -fgcse-*) ;;
-      -freschedule-modulo-scheduled-loops) ;;
-      -freschedule-modulo-scheduled-loops) ;;
-      -fipa-pta) ;;
-      -fsched2-use-superblocks) ;;
-      -fbranch-target-load-optimize) ;;
-      -fdelete-dead-exceptions) ;;
-      -funsafe-loop-optimizations) ;;
-      -fcall-used*) ;;
-      -mmitigate-rop) ;;
-      -mnop-mcount) ;;
-      -fno-align-jumps) ;;
-      -fno-align-labels) ;;
-      -fno-align-loops) ;;
-      -fivopts) ;;
-      -fschedule-insns) ;;
-      -fno-semantic-interposition) ;;
-      -mno-fentry) ;;
-      -f*shrink-wrap) ;;
-      -f*schedule-insns2) ;;
-      -fvect-cost-model=*) ;;
-      -fsimd-cost-model=*) ;;
-      -fversion-loops-for-strides) ;;
-      -fopt-info*) ;;
-      -f*var-tracking-assignments) ;;
-      -femit-struct-debug-baseonly) ;;
-      -ftree-loop-vectorize) ;;
-      -gdescribe-dies) ;;
-      -flimit-function-alignment) ;;
-      -ftree-loop-im) ;;
-      -fno-instrument-functions) ;;
-      -fstack-clash-protection) ;;
-      -mstringop-strategy=*) ;;
-      -mpreferred-stack-boundary=*) ;;
-      -*stack-protector*) ;;  # clang requires segmented memory for this
-      -f*gnu-unique) ;;
-      -Wframe-larger-than=*) ;;
-      -f*whole-program) ;;
-      -Wa,--size-check=*) ;;
-      -Wa,--listing*) ;;
-      -mfpmath=sse+387) ;;
-      -Wa,--noexecstack) ;;
-      -freg-struct-return) ;;
-      -mcall-ms2sysv-xlogues) ;;
-      -mno-vzeroupper)
-        set -- "$@" -mllvm -x86-use-vzeroupper=0
-        ;;
-      -Wa,-a*)
-        x="${x#*=}"
-        if [ "$x" ] && [ -p "$x" ]; then
-          printf '' >"$x"
-        fi
-        ;;
-      *)
-        set -- "$@" "$x"
-        ;;
-    esac
-  done
-  set -- "$@" -fno-stack-protector
-else
-  # removes flags only clang supports
-  FIRST=1
-  for x; do
-    if [ $FIRST -eq 1 ]; then
-      set --
-      FIRST=0
-    fi
-    case "$x" in
-      -Oz) set -- "$@" -Os ;;
-      *) set -- "$@" "$x" ;;
-    esac
-  done
-fi
-
-set -- "$@" -no-canonical-prefixes $FDIAGNOSTIC_COLOR $COUNTERMAND
-
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
-  printf "$LOGFMT" "${ACTION:-COMPILE}" "${TARGET:-$OUT}" >&2
-fi
-
-OUTDIR="${OUT%/*}"
-if [ "$OUTDIR" != "$OUT" ] && [ ! -d "$OUTDIR" ]; then
-  $MKDIR "$OUTDIR" || exit 2
-fi
-
-REASON=failed
-trap REASON=interrupted INT
-
-if "$@"; then
-  for f in $GZME; do
-    if GZ=${GZ:-$(command -v gzip)}; then
-      if [ -f "$f" ]; then
-        build/actuallynice $GZ $ZFLAGS -qf $f &
-      fi
-    fi
-  done
-  exit 0
-fi
-
-printf "\n$LOGFMT" "$CCNAME $CCVERSION: compile $REASON:" "$*" >&2
-exit 1
@@ -20,8 +20,6 @@ CONFIG_CCFLAGS +=		\
 TARGET_ARCH ?=			\
 	-msse3

-RAGELFLAGS ?= -G2
-
 endif

 # Optimized Mode
@@ -48,8 +46,6 @@ CONFIG_CCFLAGS +=		\
 TARGET_ARCH ?=			\
 	-march=native

-RAGELFLAGS ?= -G2
-
 endif

 # Release Mode
@@ -73,8 +69,6 @@ CONFIG_CCFLAGS +=		\
 	$(BACKTRACES)		\
 	-O2

-RAGELFLAGS = -G2
-
 endif

 # Debug Mode
@@ -94,15 +88,12 @@ CONFIG_CPPFLAGS +=		\
 CONFIG_CCFLAGS +=		\
 	$(BACKTRACES)		\
 	$(FTRACE)		\
-	-fno-inline
+	-O2

 CONFIG_COPTS +=			\
 	$(SECURITY_BLANKETS)	\
 	$(SANITIZER)

-CONFIG_COPTS +=			\
-	-ftrapv
-
 TARGET_ARCH ?=			\
 	-msse3

@@ -122,24 +113,149 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
-
 ifeq ($(MODE), tiny)
-
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY
-
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-
 TARGET_ARCH ?=			\
 	-msse3
+endif

+# Linux-Only Tiny Mode
+#
+#   - `make MODE=tiny`
+#   - No checks
+#   - No asserts
+#   - No canaries
+#   - No paranoia
+#   - No avx hooks
+#   - No backtraces
+#   - No portability
+#   - No algorithmics
+#   - YOLO
+ifeq ($(MODE), tinylinux)
+CONFIG_CPPFLAGS +=		\
+	-DTINY			\
+	-DNDEBUG		\
+	-DTRUSTWORTHY		\
+	-DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS +=		\
+	-Os			\
+	-fno-align-functions	\
+	-fno-align-jumps	\
+	-fno-align-labels	\
+	-fno-align-loops
+TARGET_ARCH ?=			\
+	-msse3
+endif
+
+# Linux+BSD Tiny Mode
+#
+#   - `make MODE=tiny`
+#   - No apple
+#   - No checks
+#   - No asserts
+#   - No canaries
+#   - No paranoia
+#   - No microsoft
+#   - No avx hooks
+#   - No backtraces
+#   - No algorithmics
+#   - YOLO
+ifeq ($(MODE), tinylinuxbsd)
+CONFIG_CPPFLAGS +=		\
+	-DTINY			\
+	-DNDEBUG		\
+	-DTRUSTWORTHY		\
+	-DSUPPORT_VECTOR=113
+CONFIG_CCFLAGS +=		\
+	-Os			\
+	-fno-align-functions	\
+	-fno-align-jumps	\
+	-fno-align-labels	\
+	-fno-align-loops
+TARGET_ARCH ?=			\
+	-msse3
+endif
+
+# Unix Tiny Mode
+#
+#   - `make MODE=tiny`
+#   - No checks
+#   - No asserts
+#   - No canaries
+#   - No paranoia
+#   - No microsoft
+#   - No avx hooks
+#   - No backtraces
+#   - No algorithmics
+#   - YOLO
+ifeq ($(MODE), tinysysv)
+CONFIG_CPPFLAGS +=		\
+	-DTINY			\
+	-DNDEBUG		\
+	-DTRUSTWORTHY		\
+	-DSUPPORT_VECTOR=121
+CONFIG_CCFLAGS +=		\
+	-Os			\
+	-fno-align-functions	\
+	-fno-align-jumps	\
+	-fno-align-labels	\
+	-fno-align-loops
+TARGET_ARCH ?=			\
+	-msse3
+endif
+
+# Tiny Metallic Unix Mode
+#
+#   - `make MODE=tiny`
+#   - No checks
+#   - No asserts
+#   - No canaries
+#   - No paranoia
+#   - No microsoft
+#   - No avx hooks
+#   - No backtraces
+#   - No algorithmics
+#   - YOLO
+ifeq ($(MODE), tinynowin)
+CONFIG_CPPFLAGS +=		\
+	-DTINY			\
+	-DNDEBUG		\
+	-DTRUSTWORTHY		\
+	-DSUPPORT_VECTOR=251
+CONFIG_CCFLAGS +=		\
+	-Os			\
+	-fno-align-functions	\
+	-fno-align-jumps	\
+	-fno-align-labels	\
+	-fno-align-loops
+TARGET_ARCH ?=			\
+	-msse3
+endif
+
+# LLVM Mode
+ifeq ($(MODE), llvm)
+TARGET_ARCH ?= -msse3
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2
+AS = clang
+CC = clang
+CXX = clang++
+CXXFILT = llvm-c++filt
+LD = ld.lld
+NM = llvm-nm
+GCC = clang
+STRIP = llvm-strip
+OBJCOPY = llvm-objcopy
+OBJDUMP = llvm-objdump
+ADDR2LINE = llvm-addr2line
 endif

 # ANSI Mode
@@ -13,8 +13,8 @@
 #
 #   When tuning the variables below, please note they're interpreted in
 #   the strictest sense. For example, we don't pass CFLAGS to gcc if we
-#   know it's compiling a .S file. This allows our `make SILENT=0` logs
-#   to be succinct and informative, at the cost of being less forgiving.
+#   know it's compiling a .S file.  This enables our `make V=0` logging
+#   to be succinct and informative at the cost of being less forgiving.
 #
 #   Further note that link order is equally unforgiving in repositories
 #   of this scale. We approach that by over-specifying dependencies, in
@@ -42,14 +42,12 @@
 #     ASFLAGS      assembler flags (don't use -Wa, frontend prefix)
 #     TARGET_ARCH  microarchitecture flags (e.g. -march=native)

-DD ?= /bin/dd
-CP ?= /bin/cp -f
-RM ?= /bin/rm -f
-SED ?= /bin/sed
-MKDIR ?= /bin/mkdir -p
+V ?= 1
+LC_ALL = C
+SOURCE_DATE_EPOCH = 0
+
 TAGS ?= /usr/bin/ctags  # emacs source builds or something breaks it
 ARFLAGS = rcsD
-SILENT ?= 1
 ZFLAGS ?=
 XARGS ?= xargs -P4 -rs8000
 NICE ?= build/actuallynice
@@ -59,12 +57,15 @@ CLANG = clang-10
 FC = gfortran  #/opt/cross9f/bin/x86_64-linux-musl-gfortran

 # see build/compile, etc. which run third_party/gcc/unbundle.sh
+AR = build/bootstrap/ar.com
+PKG = build/bootstrap/package.com
+MKDEPS = build/bootstrap/mkdeps.com
+ZIPOBJ = build/bootstrap/zipobj.com
 AS = o/third_party/gcc/bin/x86_64-linux-musl-as
 CC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
 CXX = o/third_party/gcc/bin/x86_64-linux-musl-g++
 CXXFILT = o/third_party/gcc/bin/x86_64-linux-musl-c++filt
 LD = o/third_party/gcc/bin/x86_64-linux-musl-ld.bfd
-AR = build/archive
 NM = o/third_party/gcc/bin/x86_64-linux-musl-nm
 GCC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
 STRIP = o/third_party/gcc/bin/x86_64-linux-musl-strip
@@ -75,43 +76,29 @@ ADDR2LINE = o/third_party/gcc/bin/x86_64-linux-musl-addr2line
 COMMA := ,
 PWD := $(shell pwd)
 IMAGE_BASE_VIRTUAL ?= 0x400000
+HELLO := $(shell build/hello)
 TMPDIR := $(shell build/findtmp)
-LOGFMT := $(shell build/getlogfmt)
-CCNAME := $(shell build/getccname $(CC))
-CCVERSION := $(shell build/getccversion $(CC))
-BLAH1 := $(shell build/zipobj 2>/dev/null)
-BLAH2 := $(shell build/package 2>/dev/null)
+COMPILE := $(shell build/getcompile) -V$(shell build/getccversion $(CC))

 export ADDR2LINE
-export OBJDUMP
-export CCNAME
-export CCVERSION
-export CP
-export DD
-export GZ
-export IMAGE_BASE_VIRTUAL
-export LOGFMT
-export MKDIR
+export LC_ALL
 export MODE
-export RM
-export SED
-export SILENT
+export SOURCE_DATE_EPOCH
 export TMPDIR
-export ZFLAGS
+export V

 FTRACE =								\
 	-pg

 SANITIZER =								\
 	-fsanitize=leak							\
-	-fsanitize=undefined						\
-	-fsanitize=implicit-signed-integer-truncation			\
-	-fsanitize=implicit-integer-sign-change
+	-fsanitize=address

 NO_MAGIC =								\
 	-mno-fentry							\
 	-fno-stack-protector						\
-	-fno-sanitize=all
+	-fno-sanitize=all						\
+	-fwrapv

 OLD_CODE =								\
 	-fno-strict-aliasing						\
@@ -153,8 +140,7 @@ MATHEMATICAL =								\
 DEFAULT_CPPFLAGS =							\
 	-DIMAGE_BASE_VIRTUAL=$(IMAGE_BASE_VIRTUAL)			\
 	-nostdinc							\
-	-iquote -							\
-	-iquote .
+	-iquote.

 DEFAULT_CFLAGS =							\
 	-std=gnu2x
@@ -180,15 +166,14 @@ DEFAULT_LDFLAGS =							\
 	-m elf_x86_64							\
 	--gc-sections							\
 	--build-id=none							\
-	--cref -Map=$@.map						\
 	--no-dynamic-linker						\
-	-z max-page-size=0x1000						\
-	-Ttext-segment=$(IMAGE_BASE_VIRTUAL)
+	-z max-page-size=0x1000

 ZIPOBJ_FLAGS =								\
 	 -b$(IMAGE_BASE_VIRTUAL)

 ASONLYFLAGS =								\
+	-c								\
 	-g								\
 	--debug-prefix-map="$(PWD)"=

@@ -272,8 +257,8 @@ COMPILE.F.flags = $(cc.flags) $(cpp.flags) $(copt.flags) $(f.flags)
 COMPILE.i.flags = $(cc.flags) $(copt.flags) $(c.flags)
 COMPILE.ii.flags = $(cc.flags) $(copt.flags) $(cxx.flags)
 LINK.flags = $(DEFAULT_LDFLAGS) $(CONFIG_LDFLAGS) $(LDFLAGS)
-OBJECTIFY.c.flags = $(OBJECTIFY.S.flags) $(c.flags)
-OBJECTIFY.cxx.flags = $(OBJECTIFY.S.flags) $(cxx.flags)
+OBJECTIFY.c.flags = $(OBJECTIFY.S.flags) $(copt.flags) $(c.flags)
+OBJECTIFY.cxx.flags = $(OBJECTIFY.S.flags) $(copt.flags) $(cxx.flags)
 OBJECTIFY.s.flags = $(ASONLYFLAGS) $(s.flags)
 OBJECTIFY.S.flags = $(copt.flags) $(cc.flags) $(o.flags) $(cpp.flags) $(S.flags)
 OBJECTIFY.f.flags = $(copt.flags) $(cc.flags) $(o.flags) $(copt.flags) $(S.flags) $(f.flags)
@@ -294,10 +279,9 @@ OBJECTIFY.c = $(CC) $(OBJECTIFY.c.flags) -c
 OBJECTIFY.cxx = $(CXX) $(OBJECTIFY.cxx.flags) -c
 PREPROCESS = $(CC) $(PREPROCESS.flags)
 PREPROCESS.lds = $(CC) $(PREPROCESS.lds.flags)
-LINK = build/link $(LD) $(LINK.flags)
+LINK = $(LD) $(LINK.flags)
 ELF = o/libc/elf/elf.lds
-ELFLINK = ACTION=LINK.elf $(LINK) $(LINKARGS) $(OUTPUT_OPTION)
-ARCHIVE = $(AR) $(ARFLAGS)
+ELFLINK = $(COMPILE) -ALINK.elf $(LINK) $(LINKARGS) $(OUTPUT_OPTION)
 LINKARGS = $(patsubst %.lds,-T %.lds,$(call uniqr,$(LD.libs) $(filter-out %.pkg,$^)))
 LOLSAN = build/lolsan -b $(IMAGE_BASE_VIRTUAL)

@@ -315,6 +299,11 @@ OBJECTIFY.greg.c =							\
 	-fno-sanitize=all						\
 	-c

+OBJECTIFY.i386.c =							\
+	$(OBJECTIFY.c)							\
+	-m32								\
+	-wrapper build/i386ify.sh
+
 OBJECTIFY.ansi.c = $(CC) $(OBJECTIFY.c.flags) -ansi -Wextra -Werror -pedantic-errors -c
 OBJECTIFY.c99.c = $(CC) $(OBJECTIFY.c.flags) -std=c99 -Wextra -Werror -pedantic-errors -c
 OBJECTIFY.c11.c = $(CC) $(OBJECTIFY.c.flags) -std=c11 -Wextra -Werror -pedantic-errors -c
@@ -1,55 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-#
-# OVERVIEW
-#
-#   Generic Command Runner
-#
-# DESCRIPTION
-#
-#   This does auto mkdir and ephemeral logging.
-#
-# EXAMPLE
-#
-#   build/do PROG [ARGS...]
-
-MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit
-
-# Ensure directory creation if -o PATH flag is passed.
-OUT="$TARGET"
-FIRST=1
-OUTARG=0
-for x; do
-  if [ $FIRST -eq 1 ]; then
-    set --
-    FIRST=0
-  elif [ $OUTARG -eq 1 ]; then
-    OUTARG=0
-    OUT="$x"
-  fi
-  case "$x" in
-    -o)
-      OUTARG=1
-      ;;
-    -o*)
-      OUT=${x#-o}
-      ;;
-  esac
-  set -- "$@" "$x"
-done
-if [ "$OUT" ]; then
-  OUTDIR="${OUT%/*}"
-  if [ "$OUTDIR" != "$OUT" ] && [ ! -d "$OUTDIR" ]; then
-    $MKDIR "$OUTDIR" || exit 2
-  fi
-fi
-
-# Log command.
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
-  printf "$LOGFMT" "${ACTION:-BUILD}" "$TARGET" >&2
-fi
-
-exec "$@"
@@ -13,7 +13,5 @@
 #   environment variable. Many programs use it under the hood, e.g. gcc,
 #   so it grants many small performance improvements.

-MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit
-
-$MKDIR o/tmp
+mkdir -p o/tmp
 echo o/tmp
@@ -1,46 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-#
-# OVERVIEW
-#
-#   Compiler Name Discovery
-#
-# DESCRIPTION
-#
-#   Cosmopolitan itself may be built using either GCC and Clang, and our
-#   build irons out many of the differences between the two. This script
-#   determines which one's in play, which is nontrivial, since they tend
-#   to call themselves so many different names.
-
-if [ ! -d o/third_party/gcc ]; then
-  third_party/gcc/unbundle.sh
-fi
-
-set -e
-
-SPECIAL_TEXT=$(
-  $1 --version |
-    sed -n '
-        /chibicc/ {
-          i\
-chibicc
-          q
-        }
-        /Free Software/ {
-          i\
-gcc
-          q
-        }
-        /clang/ {
-          i\
-clang
-          q
-        }
-      ')
-
-if [ -z "$SPECIAL_TEXT" ]; then
-  echo gcc
-else
-  printf '%s\n' "$SPECIAL_TEXT"
-fi
@@ -0,0 +1,12 @@
+#!/bin/sh
+#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
+#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+
+if ! [ o/build/bootstrap/compile.com -nt build/bootstrap/compile.com ]; then
+  mkdir -p o/build/bootstrap/
+  cp -f build/bootstrap/compile.com o/build/bootstrap/compile.$$.com
+  o/build/bootstrap/compile.$$.com -n
+  mv -f o/build/bootstrap/compile.$$.com o/build/bootstrap/compile.com
+fi
+
+echo o/build/bootstrap/compile.com
@@ -1,33 +0,0 @@
-#!/usr/bin/env bash
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-#
-# OVERVIEW
-#
-#   Printf Logger Initializer
-#
-# DESCRIPTION
-#
-#   This program is invoked once by build/definitions.mk to choose the
-#   most appropriate format string when logging command invocations.
-
-if [ "$SILENT" = "0" ]; then
-  printf "''"
-else
-  W1=15
-  if [ "$TERM" = "dumb" ]; then  # e.g. emacs' dismal tty
-    if [ "$COLUMNS" = "" ]; then
-      if TPUT=$(command -v tput); then
-        COLUMNS=$("$TPUT" cols)
-      else
-        COLUMNS=80
-      fi
-    fi
-    COLUMNS=$((COLUMNS - 1))
-    W2=$((COLUMNS - W1))
-    printf '%%-%ds%%-%ds\\r' "$W1" "$W2"
-  else
-    echo ♥cosmo >&2
-    printf '\\033[F\\033[K%%-%ds%%s\\r\\n' "$W1"
-  fi
-fi
@@ -0,0 +1,20 @@
+#!/bin/sh
+#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
+#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+#
+# SYNOPSIS
+#
+#   HELLO BUILD
+#
+# OVERVIEW
+#
+#   We generate a line at the start of each Makefile run, because if we
+#   use `make V=0` mode then the terminal logging trick we use in
+#   tool/build/compile.c will delete the previous line, and we'd rather
+#   have that line not be the bash prompt that ran make.
+#
+#   This script is also useful for giving us an indicator each time the
+#   build restarts itself from scratch, which can happen in cases like
+#   when dependencies need to be regenerated by tool/build/mkdeps.c
+
+echo ♥cosmo >&2
@@ -0,0 +1,35 @@
+#!/bin/sh
+#
+# SYNOPSIS
+#
+#   gcc -m32 -wrapper build/i386ify.sh -c -o foo.o foo.c
+#
+# OVERVIEW
+#
+#   Compiles 32-bit code inside 64-bit ELF objects.
+
+if [ "${1##*/}" = as ]; then
+  FIRST=0
+  for x; do
+    if [ $FIRST -eq 0 ]; then
+      set --
+      FIRST=1
+    fi
+    if [ "$x" = "--32" ]; then
+      continue
+    fi
+    if [ "${x##*.}" = s ]; then
+      {
+        printf "\t.section .yoink\n"
+        printf "\tnopl\t_start32\n"
+        printf "\t.previous\n"
+        printf "\t.code32\n"
+        cat "$x"
+      } >"$x".tmp
+      mv -f "$x".tmp "$x"
+    fi
+    set -- "$@" "$x"
+  done
+fi
+
+exec "$@"
@@ -1,66 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-#
-# OVERVIEW
-#
-#   GNU Linker Veneer
-#
-# DESCRIPTION
-#
-#   This script wraps normal linker commands that're transparently
-#   passed-through. It adds ephemeral logging and directory creation.
-#
-# EXAMPLE
-#
-#   build/linker ld -o program program.o
-
-if [ ! -d o/third_party/gcc ]; then
-  third_party/gcc/unbundle.sh
-fi
-
-export LC_ALL=C  # very important for ld
-MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit
-
-OUT=
-FIRST=1
-OUTARG=0
-for x; do
-  if [ $FIRST -eq 1 ]; then
-    set --
-    FIRST=0
-  elif [ $OUTARG -eq 1 ]; then
-    OUTARG=0
-    OUT="$x"
-  fi
-  case "$x" in
-    -o)
-      OUTARG=1
-      ;;
-  esac
-  set -- "$@" "$x"
-done
-
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
-  printf "$LOGFMT" "${ACTION:-LINK.elf}" "$OUT" >&2
-fi
-
-OUTDIR="${OUT%/*}"
-if [ "$OUTDIR" != "$OUT" ] && [ ! -d "$OUTDIR" ]; then
-  $MKDIR "$OUTDIR" || exit 2
-fi
-
-REASON=failed
-trap REASON=interrupted INT
-
-"$@" && exit
-
-if [ "$TERM" = "dumb" ]; then
-  f='%s %s\r\n\r\n'
-else
-  f='\033[91m%s\033[39m \033[94m%s\033[39m\r\n\r\n'
-fi
-printf "$f" "link $REASON:" "$*" >&2
-exit 1
@@ -1,22 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-
-if [ -x "o/$MODE/tool/build/mkdeps.com" ]; then
-  set -- "o/$MODE/tool/build/mkdeps.com" "$@"
-else
-  if [ ! -x o/build/bootstrap/mkdeps.com ]; then
-    mkdir -p o/build/bootstrap &&
-    cp -a build/bootstrap/mkdeps.com \
-       o/build/bootstrap/mkdeps.com || exit
-  fi
-  set -- o/build/bootstrap/mkdeps.com "$@"
-fi
-
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
-  printf "$LOGFMT" "${ACTION:-MKDEPS}" "$3" >&2
-fi
-
-exec "$@"
@@ -1,22 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-#
-# OVERVIEW
-#
-#   GNU Disassembly Veneer
-#
-# DESCRIPTION
-#
-#   This script wraps normal objdump commands that're transparently
-#   passed-through.
-#
-# EXAMPLE
-#
-#   build/objdump -xd o/tiny/examples/life.com.dbg
-
-if [ ! -d o/third_party/gcc ]; then
-  third_party/gcc/unbundle.sh
-fi
-
-exec o/third_party/gcc/bin/x86_64-linux-musl-objdump "$@"
@@ -23,9 +23,8 @@
 #   - tool/build/runitd.c

 .PRECIOUS: o/$(MODE)/%.com.ok
-o/$(MODE)/%.com.ok:					\
-		o/$(MODE)/tool/build/runit.com.dbg	\
-		o/$(MODE)/tool/build/runitd.com		\
+o/$(MODE)/%.com.ok:				\
+		o/$(MODE)/tool/build/runit.com	\
+		o/$(MODE)/tool/build/runitd.com	\
 		o/$(MODE)/%.com
-	@ACTION=TEST TARGET=$@ build/do $^ $(HOSTS)
-	@touch $@
+	@$(COMPILE) -ATEST -tT$@ $^ $(HOSTS)
@@ -1,33 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-
-if [ "$TOOL_BUILD_PACKAGE" ]; then
-  set -- "$TOOL_BUILD_PACKAGE" "$@"
-else
-  if [ -x "o/tool/build/package.com.dbg" ]; then
-    set -- "o/tool/build/package.com.dbg" "$@"
-  else
-    MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit
-    CP=${CP:-$(command -v cp) -f} || exit
-    if [ ! -x o/build/bootstrap/package.com ]; then
-      $MKDIR o/build/bootstrap &&
-        $CP -a build/bootstrap/package.com \
-            o/build/bootstrap/package.com || exit
-    fi
-    set -- o/build/bootstrap/package.com "$@"
-  fi
-fi
-
-printf "$LOGFMT" "${ACTION:-PACKAGE}" "$3" >&2
-# if [ "$SILENT" = "0" ]; then
-#   COLUMNS=${COLUMNS:-80}
-#   COLUMNS=$((COLUMNS - 4))
-#   printf "%s\n" "$*" |
-#     /usr/bin/fold -s -w $COLUMNS |
-#     sed -e '1bb' -e 's/^/  /' -e ':b' -e '$b' -e 's/$/ \\/' >&2
-# else
-#   printf "$LOGFMT" "${ACTION:-PACKAGE}" "$3" >&2
-# fi
-
-exec "$@"
@@ -16,73 +16,68 @@

 MAKEFLAGS += --no-builtin-rules

-o/%.a:; @$(ARCHIVE) $@ $^
-o/%.o: %.s; @TARGET=$@ build/assemble $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
-o/%.o: o/%.s; @TARGET=$@ build/assemble $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
-o/%.s: %.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/%.s: o/%.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/%.i: %.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/%.o: %.S; @ACTION=OBJECTIFY.S build/compile $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
-o/%.o: o/%.S; @ACTION=OBJECTIFY.S build/compile $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
-o/%.s: %.i; @ACTION=COMPILE.i build/compile $(COMPILE.i) $(OUTPUT_OPTION) $<
-o/%.s: o/%.i; @ACTION=COMPILE.i build/compile $(COMPILE.i) $(OUTPUT_OPTION) $<
-o/%.o: %.cc; @ACTION=OBJECTIFY.cxx build/compile $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-o/%.o: o/%.cc; @ACTION=OBJECTIFY.cxx build/compile $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-o/%.lds: %.lds; @ACTION=PREPROCESS build/compile $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
-o/%.inc: %.h; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) -D__ASSEMBLER__ -P $<
-o/%.pkg:; @build/package $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) $(filter %.o,$^)
-o/%.h.ok: %.h; @ACTION=CHECK.h build/compile $(COMPILE.c) -x c -g0 -o $@ $<
-o/%.h.okk: %.h; @ACTION=CHECK.h build/compile $(COMPILE.cxx) -x c++ -g0 -o $@ $<
-o/%.greg.o: %.greg.c; @ACTION=OBJECTIFY.greg build/compile $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
-o/%.zip.o: o/%; @build/zipobj $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+o/%.a:                             ; @$(COMPILE) -AARCHIVE -T$@ $(AR) $(ARFLAGS) $@ $^
+o/%.o: %.s                         ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/%.o: o/%.s                       ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/%.s: %.S                         ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/%.s: o/%.S                       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/%.i: %.S                         ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/%.o: %.S                         ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/%.o: o/%.S                       ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/%.s: %.i                         ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/%.s: o/%.i                       ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/%.o: %.cc                        ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/%.o: o/%.cc                      ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/%.lds: %.lds                     ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
+o/%.inc: %.h                       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) -D__ASSEMBLER__ -P $<
+o/%.pkg:                           ; @$(COMPILE) -APACKAGE -T$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) $(filter %.o,$^)
+o/%.h.ok: %.h                      ; @$(COMPILE) -ACHECK.h $(COMPILE.c) -x c -g0 -o $@ $<
+o/%.h.okk: %.h                     ; @$(COMPILE) -ACHECK.h $(COMPILE.cxx) -x c++ -g0 -o $@ $<
+o/%.greg.o: %.greg.c               ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/%.zip.o: o/%                     ; @$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<

-o/$(MODE)/%.a:; @$(ARCHIVE) $@ $^
-o/$(MODE)/%: o/$(MODE)/%.dbg; @ACTION=OBJCOPY TARGET=$@ build/do $(OBJCOPY) -SO binary $< $@
-o/$(MODE)/%.o: %.s; @TARGET=$@ build/assemble $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: o/$(MODE)/%.s; @TARGET=$@ build/assemble $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.s: %.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.s: o/$(MODE)/%.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: %.c; @ACTION=OBJECTIFY.c build/compile $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: %.f; @ACTION=OBJECTIFY.f build/compile $(OBJECTIFY.f) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: %.F; @ACTION=OBJECTIFY.F build/compile $(OBJECTIFY.F) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: o/$(MODE)/%.c; @ACTION=OBJECTIFY.c build/compile $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.ss: %.c; @ACTION=COMPILE.c build/compile $(COMPILE.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.ss: o/$(MODE)/%.c; @ACTION=OBJECTIFY.s build/compile $(COMPILE.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.i: %.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.i: %.c; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.i: %.cc; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.i: o/$(MODE)/%.c; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.h: %.c; @ACTION=AMALGAMATE build/compile $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
-o/$(MODE)/%.h: o/$(MODE)/%.c; @ACTION=AMALGAMATE build/compile $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
-o/$(MODE)/%.o: %.S; @ACTION=OBJECTIFY.S build/compile $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: o/$(MODE)/%.S; @ACTION=OBJECTIFY.S build/compile $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.s: %.i; @ACTION=COMPILE.i build/compile $(COMPILE.i) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.s: o/$(MODE)/%.i; @ACTION=COMPILE.i build/compile $(COMPILE.i) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: %.cc; @ACTION=OBJECTIFY.cxx build/compile $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.o: o/$(MODE)/%.cc; @ACTION=OBJECTIFY.cxx build/compile $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.lds: %.lds; @ACTION=PREPROCESS build/compile $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.h.ok: %.h; @ACTION=CHECK.h build/compile $(COMPILE.c) -x c -g0 -o $@ $<
-o/$(MODE)/%.h.okk: %.h; @ACTION=CHECK.h build/compile $(COMPILE.cxx) -x c++ -g0 -o $@ $<
-o/$(MODE)/%.o: %.greg.c; @ACTION=OBJECTIFY.greg build/compile $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.greg.o: %.greg.c; @ACTION=OBJECTIFY.greg build/compile $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.ansi.o: %.ansi.c; @ACTION=OBJECTIFY.ansi build/compile $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.ansi.o: %.c; @ACTION=OBJECTIFY.ansi build/compile $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.c99.o: %.c99.c; @ACTION=OBJECTIFY.c99 build/compile $(OBJECTIFY.c99.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.c11.o: %.c11.c; @ACTION=OBJECTIFY.c11 build/compile $(OBJECTIFY.c11.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.c2x.o: %.c2x.c; @ACTION=OBJECTIFY.c2x build/compile $(OBJECTIFY.c2x.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.initabi.o: %.initabi.c; @ACTION=OBJECTIFY.init build/compile $(OBJECTIFY.initabi.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.ncabi.o: %.ncabi.c; @ACTION=OBJECTIFY.nc build/compile $(OBJECTIFY.ncabi.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.real.o: %.c; @ACTION=OBJECTIFY.real build/compile $(OBJECTIFY.real.c) $(OUTPUT_OPTION) $<
-o/$(MODE)/%.runs: o/$(MODE)/%; @ACTION=CHECK.runs TARGET=$< build/runcom $< $(TESTARGS) && touch $@
-o/$(MODE)/%.pkg:; @build/package $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) $(filter %.o,$^)
-o/$(MODE)/%.zip.o: %; @build/zipobj $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.a:                     ; @$(COMPILE) -AARCHIVE -T$@ $(AR) $(ARFLAGS) $@ $^
+o/$(MODE)/%: o/$(MODE)/%.dbg       ; @$(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -S -O binary $< $@
+o/$(MODE)/%.o: %.s                 ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.s       ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: %.S                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: o/$(MODE)/%.S       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.c                 ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.f                 ; @$(COMPILE) -AOBJECTIFY.f $(OBJECTIFY.f) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.F                 ; @$(COMPILE) -AOBJECTIFY.F $(OBJECTIFY.F) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.c       ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ss: %.c                ; @$(COMPILE) -ACOMPILE.c $(COMPILE.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ss: o/$(MODE)/%.c      ; @$(COMPILE) -AOBJECTIFY.s $(COMPILE.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.S                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.c                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.cc                ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: o/$(MODE)/%.c       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.h: %.c                 ; @$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
+o/$(MODE)/%.h: o/$(MODE)/%.c       ; @$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
+o/$(MODE)/%.o: %.S                 ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.S       ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: %.i                 ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: o/$(MODE)/%.i       ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.cc                ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.cc      ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.lds: %.lds             ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.h.ok: %.h              ; @$(COMPILE) -ACHECK.h $(COMPILE.c) -x c -g0 -o $@ $<
+o/$(MODE)/%.h.okk: %.h             ; @$(COMPILE) -ACHECK.h $(COMPILE.cxx) -x c++ -g0 -o $@ $<
+o/$(MODE)/%.o: %.greg.c            ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i386.o: %.i386.c       ; @$(COMPILE) -AOBJECTIFY.i386 $(OBJECTIFY.i386.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.greg.o: %.greg.c       ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ansi.o: %.ansi.c       ; @$(COMPILE) -AOBJECTIFY.ansi $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ansi.o: %.c            ; @$(COMPILE) -AOBJECTIFY.ansi $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c99.o: %.c99.c         ; @$(COMPILE) -AOBJECTIFY.c99 $(OBJECTIFY.c99.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c11.o: %.c11.c         ; @$(COMPILE) -AOBJECTIFY.c11 $(OBJECTIFY.c11.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c2x.o: %.c2x.c         ; @$(COMPILE) -AOBJECTIFY.c2x $(OBJECTIFY.c2x.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.initabi.o: %.initabi.c ; @$(COMPILE) -AOBJECTIFY.init $(OBJECTIFY.initabi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ncabi.o: %.ncabi.c     ; @$(COMPILE) -AOBJECTIFY.nc $(OBJECTIFY.ncabi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.real.o: %.c            ; @$(COMPILE) -AOBJECTIFY.real $(OBJECTIFY.real.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.runs: o/$(MODE)/%      ; @$(COMPILE) -ACHECK -tT$@ $< $(TESTARGS)
+o/$(MODE)/%.pkg:                   ; @$(COMPILE) -APACKAGE -T$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) $(filter %.o,$^)
+o/$(MODE)/%.zip.o: %               ; @$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%-gcc.asm: %.c           ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
+o/$(MODE)/%-clang.asm: %.c         ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@

-o/$(MODE)/%-gcc.asm: %.c; @ACTION=OBJECTIFY.c build/compile $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
 o/$(MODE)/%-clang.asm: CC = $(CLANG)
-o/$(MODE)/%-clang.asm: %.c; @ACTION=OBJECTIFY.c build/compile $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@
-o/$(MODE)/%-gcc.asm: %.f; @ACTION=OBJECTIFY.f build/compile $(OBJECTIFY.f) -S -g0 $(OUTPUT_OPTION) $<
-o/$(MODE)/%-clang.asm: CC = $(CLANG)
-o/$(MODE)/%-clang.asm: %.f; @ACTION=OBJECTIFY.f build/compile $(OBJECTIFY.f) -S -g0 $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@
-o/$(MODE)/%-gcc.asm: %.F; @ACTION=OBJECTIFY.F build/compile $(OBJECTIFY.F) -S -g0 $(OUTPUT_OPTION) $<
-o/$(MODE)/%-clang.asm: CC = $(CLANG)
-o/$(MODE)/%-clang.asm: %.F; @ACTION=OBJECTIFY.F build/compile $(OBJECTIFY.F) -S -g0 $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@
@@ -1,10 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-
-DD=${DD:-$(command -v dd)} || exit
-$DD if="$1" of="$1.bak" bs=4096 count=1 conv=notrunc 2>/dev/null
-"$@"
-rc=$?
-$DD if="$1.bak" of="$1" bs=4096 count=1 conv=notrunc 2>/dev/null
-exit $rc
@@ -1,51 +0,0 @@
-#!/bin/sh
-#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
-#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
-
-MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit
-CP=${CP:-$(command -v cp) -f} || exit
-SED=${SED:-$(command -v sed)} || exit
-
-MODE=
-
-OUT=
-FIRST=1
-OUTARG=0
-for x; do
-  if [ $FIRST -eq 1 ]; then
-    set --
-    FIRST=0
-  elif [ $OUTARG -eq 1 ]; then
-    OUTARG=0
-    OUT="$x"
-  fi
-  case "$x" in
-    -o)
-      OUTARG=1
-      ;;
-  esac
-  set -- "$@" "$x"
-done
-OUTDIR="${OUT%/*}"
-if [ "$OUTDIR" != "$OUT" ] && [ ! -d "$OUTDIR" ]; then
-  $MKDIR "$OUTDIR" || exit 2
-fi
-
-if [ -x "o/$MODE/tool/build/zipobj.com.dbg" ]; then
-  set -- "o/$MODE/tool/build/zipobj.com.dbg" "$@"
-else
-  if [ ! -x o/build/bootstrap/zipobj.com ]; then
-    $MKDIR o/build/bootstrap &&
-    $CP -a build/bootstrap/zipobj.com \
-       o/build/bootstrap/zipobj.com || exit
-  fi
-  set -- o/build/bootstrap/zipobj.com "$@"
-fi
-
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
-  printf "$LOGFMT" "${ACTION:-ZIPOBJ}" "$3" >&2
-fi
-
-exec "$@"
@@ -24,8 +24,10 @@ DSP_CORE_A_CHECKS =				\
 	$(DSP_CORE_A_HDRS:%=o/$(MODE)/%.ok)

 DSP_CORE_A_DIRECTDEPS =				\
-	LIBC_NEXGEN32E				\
+	LIBC_INTRIN				\
 	LIBC_MEM				\
+	LIBC_NEXGEN32E				\
+	LIBC_STR				\
 	LIBC_TINYMATH				\
 	LIBC_STUBS

@@ -57,12 +59,6 @@ o/$(MODE)/dsp/core/det3.o:			\
 		OVERRIDE_CFLAGS +=		\
 			-ffast-math

-# ifeq (,$(MODE))
-# $(DSP_CORE_OBJS):				\
-# 		OVERRIDE_CFLAGS +=		\
-# 			-fsanitize=address
-# endif
-
 DSP_CORE_LIBS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)))
 DSP_CORE_SRCS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_SRCS))
 DSP_CORE_HDRS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_HDRS))
@@ -6,7 +6,7 @@
 /**
 * Divides integer in half w/ rounding.
 */
-#define HALF(X) (((X) + 1) / (2 / TYPE_INTEGRAL(typeof(X))))
+#define HALF(X) (((X) + 1) / 2)

 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_DSP_CORE_HALF_H_ */
@@ -20,18 +20,18 @@

 #define BIAS 0x84

-/	Encodes audio sample with µ-Law.
-/
-/	This is both the highest quality and most widely supported
-/	telephony codec, whose use was phased out in the 2000's in
-/	favor of cost-saving GSM audio compression that was so bad
-/	consumers were willing to pay more cash, for the privilege
-/	of saving telcos even more money w/ text messaging. Mu Law
-/	reduces PCM data to half its original size, by diminishing
-/	audio bands not vocalized by human voice.
-/
-/	@param	%edi is pcm sample
-/	@return	%eax is uint8_t encoded sample
+//	Encodes audio sample with µ-Law.
+//
+//	This is both the highest quality and most widely supported
+//	telephony codec, whose use was phased out in the 2000's in
+//	favor of cost-saving GSM audio compression that was so bad
+//	consumers were willing to pay more cash, for the privilege
+//	of saving telcos even more money w/ text messaging. Mu Law
+//	reduces PCM data to half its original size, by diminishing
+//	audio bands not vocalized by human voice.
+//
+//	@param	%edi is pcm sample
+//	@return	%eax is uint8_t encoded sample
 mulaw:	.leafprologue
 	.profilable
 	mov	$BIAS,%eax
@@ -19,11 +19,11 @@
 #include "libc/macros.h"
 .align	16

-/	Mixes audio.
-/
-/	@param	rdi is # aligned int16[16] sample chunks to process
-/	@param	rsi points to aligned pcm s16le input/output memory
-/	@param	rdx points to aligned pcm s16le [0..1] input memory
+//	Mixes audio.
+//
+//	@param	rdi is # aligned int16[16] sample chunks to process
+//	@param	rsi points to aligned pcm s16le input/output memory
+//	@param	rdx points to aligned pcm s16le [0..1] input memory
 sad16x8n:
 	.leafprologue
 	.profilable
@@ -30,6 +30,7 @@ DSP_SCALE_A_DIRECTDEPS =			\
 	LIBC_MEM				\
 	LIBC_NEXGEN32E				\
 	LIBC_RUNTIME				\
+	LIBC_STR				\
 	LIBC_STUBS				\
 	LIBC_STUBS				\
 	LIBC_TIME				\
@@ -30,7 +30,7 @@
 static int ttysetcursor(int fd, bool visible) {
  struct NtConsoleCursorInfo ntcursor;
  char code[8] = "\e[?25l";
-  if (isterminalinarticulate()) return 0;
+  if (IsTerminalInarticulate()) return 0;
  if (visible) code[5] = 'h';
  if (SupportsWindows()) {
    GetConsoleCursorInfo(GetStdHandle(kNtStdOutputHandle), &ntcursor);
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/macros.h"

-/	TODO(jart): write me
+//	TODO(jart): write me

 	movdqa	a,%xmm0
 	mpsadbw $0,inv,%xmm0
@@ -72,6 +72,7 @@ void ttyquantsetup(enum TtyQuantizationAlgorithm, enum TtyQuantizationChannels,
 extern char *ttyraster(char *, const struct TtyRgb *, size_t, size_t,
                       struct TtyRgb, struct TtyRgb);

+#ifndef ttyquant
 #define ttyquant()    (&g_ttyquant_)
 #define TTYQUANT()    VEIL("r", &g_ttyquant_)
 #define rgb2tty(...)  (ttyquant()->rgb2tty(__VA_ARGS__))
@@ -81,6 +82,7 @@ extern char *ttyraster(char *, const struct TtyRgb *, size_t, size_t,
 #define setbg(...)    (ttyquant()->setbg(__VA_ARGS__))
 #define setfg(...)    (ttyquant()->setfg(__VA_ARGS__))
 #define setbgfg(...)  (ttyquant()->setbgfg(__VA_ARGS__))
+#endif /* ttyquant */

 forceinline bool ttyeq(struct TtyRgb x, struct TtyRgb y) {
  return x.r == y.r && x.g == y.g && x.b == y.b;
@@ -59,12 +59,6 @@ o/$(MODE)/dsp/tty/ttyraster.o:			\
 		OVERRIDE_CFLAGS +=		\
 			$(MATHEMATICAL)

-# ifeq (,$(MODE))
-# $(DSP_TTY_OBJS):				\
-# 		OVERRIDE_CFLAGS +=		\
-# 			-fsanitize=address
-# endif
-
 DSP_TTY_LIBS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)))
 DSP_TTY_SRCS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)_SRCS))
 DSP_TTY_HDRS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)_HDRS))
@@ -19,12 +19,12 @@
 #include "libc/macros.h"
 .source	__FILE__

-/	Returns index of minimum uint16 in array.
-/
-/	@param	rdi points to nonempty array
-/	@param	rsi is item count divisible by 16
-/	@note	needs avx2 (haswell+)
-windex$avx2:
+//	Returns index of minimum uint16 in array.
+//
+//	@param	rdi points to nonempty array
+//	@param	rsi is item count divisible by 16
+//	@note	needs avx2 (haswell+)
+windex_avx2:
 	push	%rbp
 	mov	%rsp,%rbp
 	.profilable
@@ -64,7 +64,7 @@ windex$avx2:
 5:	vzeroupper
 	leave
 	ret
-	.endfn	windex$avx2,globl
+	.endfn	windex_avx2,globl

 	.rodata.cst32
 .Lidx:	.short	0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
@@ -19,7 +19,7 @@
 #include "dsp/tty/tty.h"
 #include "libc/assert.h"

-unsigned windex$k8(short *a, size_t n) {
+unsigned windex_k8(short *a, size_t n) {
  unsigned short min, res, i;
  res = 0;
  min = a[0];
@@ -19,12 +19,12 @@
 #include "libc/macros.h"
 .source	__FILE__

-/	Returns index of minimum positive int16 in array.
-/
-/	@param	rdi points to nonempty array
-/	@param	esi is 16-byte aligned 8+ / 8 multiple array item count
-/	@note	needs sse4 (nehalem+)
-windex$sse4:
+//	Returns index of minimum positive int16 in array.
+//
+//	@param	rdi points to nonempty array
+//	@param	esi is 16-byte aligned 8+ / 8 multiple array item count
+//	@note	needs sse4 (nehalem+)
+windex_sse4:
 	push	%rbp
 	mov	%rsp,%rbp
 	.profilable
@@ -54,7 +54,7 @@ windex$sse4:
 	movzwl	-32(%rbp,%rax,2),%eax
 	leave
 	ret
-	.endfn	windex$sse4,globl
+	.endfn	windex_sse4,globl

 	.rodata.cst16
 .Lidx:	.short	0,1,2,3,4,5,6,7
@@ -20,21 +20,21 @@
 #include "libc/macros.h"
 .source	__FILE__

-/	Dispatches to fastest windex() implementation.
+//	Dispatches to fastest windex() implementation.
 	.initbss 300,_init_windex
 windex:	.quad	0
 	.endobj	windex,globl
 	.previous

 	.init.start 300,_init_windex
-	ezlea	windex$avx2,ax
+	ezlea	windex_avx2,ax
 #if !X86_NEED(AVX2)
-	ezlea	windex$sse4,dx
+	ezlea	windex_sse4,dx
 	testb	X86_HAVE(AVX2)+kCpuids(%rip)
 	cmovz	%rdx,%rax
-#endif /* AVX */
+#endif /* AVX2 */
 #if !X86_NEED(SSE4_2)
-	ezlea	windex$k8,dx
+	ezlea	windex_k8,dx
 	testb	X86_HAVE(SSE4_2)+kCpuids(%rip)
 	cmovz	%rdx,%rax
 #endif /* SSE4 */
@@ -8,7 +8,7 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/calls/calls.h"
-#include "libc/calls/hefty/copyfile.h"
+#include "libc/calls/copyfile.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/fmt.h"
@@ -48,6 +48,6 @@ int main(int argc, char *argv[]) {
  for (int i = 0; i < min(64, argc); ++i) g_log.x()[i] += argc;
  printf("%p %d %d %d\n", (void *)(intptr_t)g_log.x(), g_log.x()[0],
         g_log.x()[0], g_log.x()[0]);
-  delete x;
+  delete[] x;
  return 0;
 }
@@ -86,9 +86,9 @@ int main(int argc, char *argv[]) {
               "movd\t%rax,%xmm14\n\t"
               "mov\t$0xffffffffffffffff,%rax\n\t"
               "movd\t%rax,%xmm15\n\t"
-               "fldpi\n\t");
-
-  res = *(int *)(intptr_t)boo / boo;
+               "fldpi\n\t"
+               "xor\t%eax,%eax\n\t"
+               "div\t%eax\n\t");

  return res;
 }
@@ -0,0 +1,106 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/bits/safemacros.h"
+#include "libc/dns/dns.h"
+#include "libc/fmt/conv.h"
+#include "libc/fmt/fmt.h"
+#include "libc/log/check.h"
+#include "libc/log/log.h"
+#include "libc/macros.h"
+#include "libc/runtime/gc.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sock/sock.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/af.h"
+#include "libc/sysv/consts/ai.h"
+#include "libc/sysv/consts/ipproto.h"
+#include "libc/sysv/consts/shut.h"
+#include "libc/sysv/consts/sock.h"
+#include "libc/x/x.h"
+#include "net/http/uri.h"
+
+/**
+ * @fileoverview Downloads HTTP URL to stdout.
+ *
+ *     make -j8 o//examples/curl.com
+ *     o//examples/curl.com http://justine.lol/ape.html
+ */
+
+int main(int argc, char *argv[]) {
+  int sock;
+  ssize_t rc;
+  unsigned long need;
+  struct UriSlice path;
+  size_t i, got, toto, msglen;
+  char buf[1500], host[256], port[7];
+  const char *url, *msg, *pathstr, *crlfcrlf, *contentlength;
+  struct UriSlice us[16];
+  struct Uri u = {.segs.p = us, .segs.n = ARRAYLEN(us)};
+  struct addrinfo *addr, *addrs;
+  struct addrinfo hints = {.ai_family = AF_INET,
+                           .ai_socktype = SOCK_STREAM,
+                           .ai_protocol = IPPROTO_TCP,
+                           .ai_flags = AI_NUMERICSERV};
+  if (argc != 2) {
+    fprintf(stderr, "USAGE: %s URL\n", argv[0]);
+    exit(1);
+  }
+  url = argv[1];
+  CHECK_NE(-1, uriparse(&u, url, strlen(url)), "BAD URL: %`'s", url);
+  CHECK_EQ(kUriSchemeHttp, urischeme(u.scheme, url));
+  urislice2cstr(host, sizeof(host), u.host, url, "127.0.0.1");
+  urislice2cstr(port, sizeof(port), u.port, url, "80");
+  path = uripath(&u);
+  pathstr = path.n ? url + path.i : "/";
+  msg = gc(xstrcat("GET ", pathstr,
+                   " HTTP/1.1\r\n"
+                   "Host: ",
+                   host,
+                   "\r\n"
+                   "Connection: close\r\n"
+                   "Content-Length: 0\r\n"
+                   "Accept: text/plain; */*\r\n"
+                   "Accept-Encoding: identity\r\n"
+                   "User-Agent: github.com/jart/cosmopolitan\r\n"
+                   "\r\n"));
+  msglen = strlen(msg);
+  CHECK_EQ(EAI_SUCCESS, getaddrinfo(host, port, &hints, &addrs));
+  for (addr = addrs; addr; addr = addr->ai_next) {
+    CHECK_NE(-1, (sock = socket(addr->ai_family, addr->ai_socktype,
+                                addr->ai_protocol)));
+    CHECK_NE(-1, connect(sock, addr->ai_addr, addr->ai_addrlen));
+    CHECK_EQ(msglen, write(sock, msg, msglen));
+    shutdown(sock, SHUT_WR);
+    buf[0] = '\0';
+    CHECK_NE(-1, (rc = read(sock, buf, sizeof(buf))));
+    got = rc;
+    CHECK(startswith(buf, "HTTP/1.1 200"), "%`'.*s", got, buf);
+    CHECK_NOTNULL((crlfcrlf = memmem(buf, got, "\r\n\r\n", 4)));
+    need = strtol((char *)firstnonnull(
+                      memmem(buf, crlfcrlf - buf, "\r\nContent-Length: ", 18),
+                      firstnonnull(memmem(buf, crlfcrlf - buf,
+                                          "\r\ncontent-length: ", 18),
+                                   "\r\nContent-Length: -1")) +
+                      18,
+                  NULL, 10);
+    got = MIN(got - (crlfcrlf + 4 - buf), need);
+    CHECK_EQ(got, write(1, crlfcrlf + 4, got));
+    for (toto = got; toto < need; toto += got) {
+      CHECK_NE(-1, (rc = read(sock, buf, sizeof(buf))));
+      if (!(got = rc)) exit(18);
+      got = MIN(got, need - toto);
+      CHECK_EQ(got, write(1, buf, got));
+    }
+    close(sock);
+    break;
+  }
+  return 0;
+}
@@ -28,11 +28,7 @@ EXAMPLES_COMS =							\
 	$(EXAMPLES_MAINS_C:%.c=o/$(MODE)/%.com)			\
 	$(EXAMPLES_MAINS_CC:%.cc=o/$(MODE)/%.com)

-EXAMPLES_ELFS =							\
-	$(EXAMPLES_OBJS:%.o=%.elf)
-
 EXAMPLES_BINS =							\
-	$(EXAMPLES_ELFS)					\
 	$(EXAMPLES_COMS)					\
 	$(EXAMPLES_COMS:%=%.dbg)

@@ -44,11 +40,10 @@ EXAMPLES_DIRECTDEPS =						\
 	LIBC_ALG						\
 	LIBC_BITS						\
 	LIBC_CALLS						\
-	LIBC_CALLS_HEFTY					\
+	LIBC_DNS						\
 	LIBC_FMT						\
 	LIBC_INTRIN						\
 	LIBC_LOG						\
-	LIBC_LOG_ASAN						\
 	LIBC_MEM						\
 	LIBC_NEXGEN32E						\
 	LIBC_NT_KERNEL32					\
@@ -70,6 +65,7 @@ EXAMPLES_DIRECTDEPS =						\
 	LIBC_UNICODE						\
 	LIBC_X							\
 	LIBC_ZIPOS						\
+	NET_HTTP						\
 	THIRD_PARTY_COMPILER_RT					\
 	THIRD_PARTY_DLMALLOC					\
 	THIRD_PARTY_GDTOA					\
@@ -100,21 +96,6 @@ o/$(MODE)/examples/%.com.dbg:					\
 		$(APE)
 	@$(APELINK)

-o/$(MODE)/examples/%.elf:					\
-		$(EXAMPLES_DEPS)				\
-		$(THIRD_PARTY_DUKTAPE)				\
-		o/$(MODE)/examples/%.o				\
-		$(CRT)						\
-		$(ELF)
-	@$(ELFLINK)
-
-o/$(MODE)/examples/tiny-raw-linux-tutorial.elf:			\
-		o/$(MODE)/examples/tiny-raw-linux-tutorial.o	\
-		$(ELF)
-	@$(ELFLINK) -N -z max-page-size=0x10
-
-$(EXAMPLES_OBJS): examples/examples.mk
-
 o/$(MODE)/examples/hellojs.com.dbg:				\
 		$(EXAMPLES_DEPS)				\
 		$(THIRD_PARTY_DUKTAPE)				\
@@ -146,13 +127,11 @@ o/$(MODE)/examples/nesemu1.com.dbg:				\
 		$(APE)
 	@$(APELINK)

-usr/share/dict/words: usr/share/dict/words.gz
-	@$(MKDIR) $(dir $@)
-	@$(GZ) $(ZFLAGS) -d <$< >$@
+$(EXAMPLES_OBJS): examples/examples.mk

-o/$(MODE)/examples/ugh.ok: o/$(MODE)/examples/wut.com
-	$<
-	touch $@
+usr/share/dict/words: usr/share/dict/words.gz
+	@mkdir -p $(@D)
+	@$(GZ) $(ZFLAGS) -d <$< >$@

 .PHONY: o/$(MODE)/examples
 o/$(MODE)/examples:						\
@@ -9,20 +9,8 @@
 #endif
 #include "libc/calls/calls.h"
 #include "libc/str/str.h"
-#include "libc/sysv/consts/fileno.h"
-
-#define kMessage "hello \e[1mworld\e[0m\r\n"

 int main() {
-  /*
-   * Cosmopolitan "Hello World" using system calls.
-   *
-   * Another Cosmopolitan best practice is to use the standard symbolic
-   * names for file descriptors 0, 1, and 2. This is a good idea because
-   * on Windows the numbers are actually different. Because Cosmopolitan
-   * is a zero-emulation library, we address that problem by turning
-   * traditional #define's into variables, which the runtime determines
-   * automatically.
-   */
-  return write(STDOUT_FILENO, kMessage, strlen(kMessage)) != -1 ? 0 : 1;
+  write(1, "hello world\n", 12);
+  return 0;
 }
@@ -10,6 +10,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/log/check.h"
+#include "libc/log/log.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/gc.h"
 #include "libc/sysv/consts/o.h"
@@ -39,6 +40,7 @@ int main(int argc, char *argv[]) {
  struct stat st;
  const char *code;
  duk_context *ctx;
+  showcrashreports();
  ctx = duk_create_heap_default();
  duk_push_c_function(ctx, NativePrint, DUK_VARARGS);
  duk_put_global_string(ctx, "NativePrint");
@@ -47,7 +49,7 @@ int main(int argc, char *argv[]) {

  CHECK_NE(-1, (fd = open("zip:examples/hello.js", O_RDONLY)));
  CHECK_NE(-1, fstat(fd, &st));
-  CHECK_NOTNULL((code = gc(malloc(st.st_size))));
+  CHECK_NOTNULL((code = gc(calloc(1, st.st_size + 1))));
  CHECK_EQ(st.st_size, read(fd, code, st.st_size));
  CHECK_NE(-1, close(fd));

@@ -0,0 +1,19 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/str/str.h"
+
+char kTenFour[10] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4};
+
+int main32(int argc, char *argv[]) {
+  return argc;
+  if (memset(argv[0], 4, 10) != argv[0]) return 1;
+  if (memcmp(argv[0], kTenFour, 10)) return 2;
+  return 0;
+}
@@ -1378,7 +1378,6 @@ void initEditor(void) {
 }

 int main(int argc, char **argv) {
-  showcrashreports();
  if (argc != 2) {
    fprintf(stderr, "Usage: kilo <filename>\n");
    exit(1);
@@ -154,7 +154,6 @@ static bool resized_;
 static size_t vtsize_;
 static bool artifacts_;
 static long tyn_, txn_;
-static const char* ffplay_;
 static struct Frame vf_[2];
 static struct Audio audio_;
 static const char* inputfn_;
@@ -1685,6 +1684,7 @@ int PlayGame(const char* romfile, const char* opt_tasfile) {
  FILE* fp;
  int devnull;
  int pipefds[2];
+  const char* ffplay;
  inputfn_ = opt_tasfile;

  if (!(fp = fopen(romfile, "rb"))) {
@@ -1701,7 +1701,7 @@ int PlayGame(const char* romfile, const char* opt_tasfile) {

  // open speaker
  // todo: this needs plenty of work
-  if ((ffplay_ = commandvenv("FFPLAY", "ffplay"))) {
+  if ((ffplay = commandvenv("FFPLAY", "ffplay"))) {
    devnull = open("/dev/null", O_WRONLY | O_CLOEXEC);
    pipe2(pipefds, O_CLOEXEC);
    if (!(playpid_ = vfork())) {
@@ -1713,7 +1713,7 @@ int PlayGame(const char* romfile, const char* opt_tasfile) {
      dup2(pipefds[0], 0);
      dup2(devnull, 1);
      dup2(devnull, 2);
-      execv(ffplay_, (char* const*)args);
+      execv(ffplay, (char* const*)args);
      abort();
    }
    close(pipefds[0]);
@@ -41,6 +41,7 @@ EXAMPLES_PACKAGE_OBJS =					\
 # Note that linking stubs is always a good idea due to synthetic code.
 EXAMPLES_PACKAGE_DIRECTDEPS =				\
 	EXAMPLES_PACKAGE_LIB				\
+	LIBC_INTRIN					\
 	LIBC_STDIO					\
 	LIBC_STUBS					\
 	LIBC_TINYMATH
@@ -70,6 +70,7 @@ EXAMPLES_PACKAGE_LIB_A_CHECKS =					\
 # Note that linking stubs is always a good idea due to synthetic code.
 EXAMPLES_PACKAGE_LIB_A_DIRECTDEPS =				\
 	LIBC_STDIO						\
+	LIBC_INTRIN						\
 	LIBC_NEXGEN32E						\
 	LIBC_STUBS

@@ -1,13 +1,13 @@
 #include "libc/macros.h"

-/	Example assembly function.
-/
-/	@note	param agnostic
-/	@note	we love stack frames
-/		easiest way to do backtraces
-/		somehow they usually make code faster
-/		it's convention for keeping stack 16-byte aligned
-/		cpus still devote much to pushing & popping b/c i386
+//	Example assembly function.
+//
+//	@note	param agnostic
+//	@note	we love stack frames
+//		easiest way to do backtraces
+//		somehow they usually make code faster
+//		it's convention for keeping stack 16-byte aligned
+//		cpus still devote much to pushing & popping b/c i386
 MyAsm:	push	%rbp
 	mov	%rsp,%rbp
 	call	MyPrint2
@@ -7,7 +7,6 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/bits/progn.internal.h"
 #include "libc/log/log.h"
 #include "libc/macros.h"
 #include "libc/runtime/runtime.h"
@@ -66,11 +65,10 @@ int main(int argc, char *argv[], char **envp) {
  for (i = 0; i < ARRAYLEN(kAuxiliaryValues); ++i) {
    key = *kAuxiliaryValues[i].id;
    val = getauxval(key);
-    printf(PROGN(stpcpy(stpcpy(stpcpy(fmt, "%16s[%p] = "),
-                               kAuxiliaryValues[i].fmt),
-                        "  # %s\n"),
-                 fmt),
-           kAuxiliaryValues[i].name, key, val, kAuxiliaryValues[i].description);
+    stpcpy(stpcpy(stpcpy(fmt, "%16s[%p] = "), kAuxiliaryValues[i].fmt),
+           "  # %s\n");
+    printf(fmt, kAuxiliaryValues[i].name, key, val,
+           kAuxiliaryValues[i].description);
  }
  printf("\nSpecial Directories:\n");
  printf(" ☼ kTmpPath = %`'s\n", kTmpPath);
@@ -0,0 +1,34 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/fmt/conv.h"
+#include "libc/stdio/stdio.h"
+
+/**
+ * @fileoverview Prints sequence of numbers.
+ */
+
+int main(int argc, char *argv[]) {
+  long a, b, i;
+  switch (argc) {
+    case 2:
+      a = 1;
+      b = strtol(argv[1], NULL, 0);
+      break;
+    case 3:
+      a = strtol(argv[1], NULL, 0);
+      b = strtol(argv[2], NULL, 0);
+      break;
+    default:
+      return 1;
+  }
+  for (i = a; i <= b; ++i) {
+    printf("%ld\n", i);
+  }
+}
@@ -0,0 +1,18 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/stat.h"
+
+int main(int argc, char *argv[]) {
+  struct stat st;
+  st.st_size = -1;
+  stat(argv[1], &st);
+  return st.st_size;
+}
@@ -1,58 +0,0 @@
-/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.h"
-
-/	Tiny Raw Linux Binary Tutorial
-/	
-/	i.e. how to not use cosmopolitan runtimes at all
-/	     cosmopolitan basically abstracts this
-/	     except for all major platforms
-/	
-/	  make o//examples/raw-linux-hello.elf
-/	  o/examples/raw-linux-hello.elf # about 6kb
-/	
-/	Next try C but with fancy build tuning
-/	
-/	  make -j8 -O                             \
-/	    MODE=tiny                             \
-/	    LDFLAGS+=-s                           \
-/	    CPPFLAGS+=-DIM_FEELING_NAUGHTY        \
-/	    CPPFLAGS+=-DSUPPORT_VECTOR=0b00000001 \
-/	    o/tiny/examples/hello2.elf
-/	  o/tiny/examples/hello2.elf # about 8kb
-/
-/	@param	rsp is [n,argv₀..argvₙ₋₁,0,envp₀..,0,auxv₀..,0,..]
-/	@see	also glibc static binaries which start at 800kb!!!
-/	@see	also go where interfaces sadly disempower ld prune
-/	@see	also the stl where bad linkage is due to tech debt
-/	@note	libc/elf/elf.lds can be tinier with page align off
-/	@note	gas is more powerful than nasm due to rms notation
-/	@noreturn
-_start:	mov	$12,%rdx			# arg no. 3 is length
-	getstr	"hello world\n",%rsi,%esi	# arg no. 2 is memory
-	mov	$1,%edi				# arg no. 1 is stdout
-	mov	$1,%eax				# write()
-	syscall					# libc/sysv/syscalls.sh
-	mov	$0,%edi				# arg no. 1 is success status
-	mov	$0xE7,%eax			# exit_group()
-	syscall					# context switch
-0:	rep nop					# basic blockading
-	jmp	0b
-	.endfn	_start,globl
-	.source	__FILE__
@@ -0,0 +1,29 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/calls/calls.h"
+#include "libc/errno.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+
+/**
+ * @fileoverview Command for updating timestamps on files.
+ */
+
+int main(int argc, char *argv[]) {
+  int i;
+  for (i = 1; i < argc; ++i) {
+    if (touch(argv[i], 0644) == -1) {
+      fprintf(stderr, "ERROR: %s: %s\n", argv[i], strerror(errno));
+      exit(1);
+    }
+  }
+  return 0;
+}
@@ -11,12 +11,31 @@
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
+#include "libc/sysv/errfuns.h"
 #include "third_party/xed/x86.h"

 /**
 * @fileoverview x86 instruction length decoder by way of hex pipe.
 */

+int fgethex(FILE *f) {
+  int o, t = -1;
+  while (!((o = fgetc(f)) & ~0xFF)) {
+    switch (t) {
+      case -1:
+        t = isxdigit(o) ? hextoint(o) : -1;
+        break;
+      default:
+        if (isxdigit(o)) {
+          return t * 16 + hextoint(o);
+        }
+        break;
+    }
+  }
+  if (t >= 0) return einval();
+  return -1;
+}
+
 int main(int argc, char *argv[argc]) {
  unsigned c, i, j, l;
  enum XedError err;
@@ -42,9 +61,8 @@ int main(int argc, char *argv[argc]) {
    l = xedd.length;
    if (l <= 0 || l > i) abort();
    for (j = 0; j < l; ++j) {
-      if (fputhex(buf[j], stdout) == -1) {
-        return errno;
-      }
+      fputc("0123456789ABCDEF"[(buf[j] & 0xf0) >> 4], stdout);
+      fputc("0123456789ABCDEF"[(buf[j] & 0x0f) >> 0], stdout);
    }
    putchar('\n');
    memcpy(&buf[0], &buf[l], i -= l);
@@ -8,6 +8,7 @@ LIBC_ALG = $(LIBC_ALG_A_DEPS) $(LIBC_ALG_A)
 LIBC_ALG_A = o/$(MODE)/libc/alg/alg.a
 LIBC_ALG_A_FILES := $(wildcard libc/alg/*)
 LIBC_ALG_A_HDRS = $(filter %.h,$(LIBC_ALG_A_FILES))
+LIBC_ALG_A_INCS = $(filter %.inc,$(LIBC_ALG_A_FILES))
 LIBC_ALG_A_SRCS_S = $(filter %.S,$(LIBC_ALG_A_FILES))
 LIBC_ALG_A_SRCS_C = $(filter %.c,$(LIBC_ALG_A_FILES))

@@ -51,6 +52,7 @@ o/$(MODE)/libc/alg/critbit0.o:			\
 LIBC_ALG_LIBS = $(foreach x,$(LIBC_ALG_ARTIFACTS),$($(x)))
 LIBC_ALG_SRCS = $(foreach x,$(LIBC_ALG_ARTIFACTS),$($(x)_SRCS))
 LIBC_ALG_HDRS = $(foreach x,$(LIBC_ALG_ARTIFACTS),$($(x)_HDRS))
+LIBC_ALG_INCS = $(foreach x,$(LIBC_ALG_ARTIFACTS),$($(x)_INCS))
 LIBC_ALG_CHECKS = $(foreach x,$(LIBC_ALG_ARTIFACTS),$($(x)_CHECKS))
 LIBC_ALG_OBJS = $(foreach x,$(LIBC_ALG_ARTIFACTS),$($(x)_OBJS))
 $(LIBC_ALG_OBJS): $(BUILD_FILES) libc/alg/alg.mk
@@ -4,30 +4,12 @@
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
-#if 0
-/**
- * @fileoverview Cosmopolitan Array List.
- *
- * This is a generically-typed ArrayList<T> template which follows a
- * duck-typing philosophy like Python, exporting an interface paradigm
- * similar to Go, that's implicitly defined by way of macros like Lisp.
- *
- *     struct MyArrayList {
- *       size_t i;  // current item count
- *       size_t n;  // current item capacity
- *       T *p;      // pointer to array (initially NULL)
- *     };
- *
- * Any struct with those fields can be used. It's also very important
- * that other data structures, which reference items in an arraylist, do
- * so using indices rather than pointers, since realloc() can relocate.
- *     
- * @see libc/mem/grow.c
- */
-#endif
+
+/* TOOD(jart): DELETE */

 #define append(ARRAYLIST, ITEM) concat((ARRAYLIST), (ITEM), 1)

+#ifndef concat
 #define concat(ARRAYLIST, ITEM, COUNT)                                      \
  ({                                                                        \
    autotype(ARRAYLIST) List = (ARRAYLIST);                                 \
@@ -37,12 +19,13 @@
    size_t Idx = List->i;                                                   \
    if (Idx + Count < List->n || __grow(&List->p, &List->n, SizE, Count)) { \
      memcpy(&List->p[Idx], Item, SizE *Count);                             \
-      atomic_store(&List->i, Idx + Count);                                  \
+      List->i = Idx + Count;                                                \
    } else {                                                                \
      Idx = -1UL;                                                           \
    }                                                                       \
    (ssize_t)(Idx);                                                         \
  })
+#endif /* concat */

 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_LIBC_ALG_ARRAYLIST_H_ */
@@ -10,6 +10,7 @@ COSMOPOLITAN_C_START_
 #define APPEND(LIST_P, LIST_I, LIST_N, ITEM) \
  CONCAT(LIST_P, LIST_I, LIST_N, ITEM, 1)

+#ifndef CONCAT
 #define CONCAT(LIST_P, LIST_I, LIST_N, ITEM, COUNT)                     \
  ({                                                                    \
    autotype(LIST_P) ListP = (LIST_P);                                  \
@@ -31,6 +32,7 @@ COSMOPOLITAN_C_START_
    }                                                                   \
    Entry;                                                              \
  })
+#endif /* CONCAT */

 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
@@ -11,6 +11,7 @@
 * @return pointer to start of array
 * @see ARRAYLEN()
 */
+#ifndef reverse
 #define reverse(ARRAY, COUNT)              \
  ({                                       \
    autotype(&(ARRAY)[0]) Array = (ARRAY); \
@@ -26,6 +27,7 @@
    }                                      \
    Array;                                 \
  })
+#endif /* reverse */

 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_LIBC_ALG_REVERSE_H_ */
@@ -11,6 +11,7 @@
 * @param n is the number of items in A
 * @see ARRAYLEN()
 */
+#ifndef shuffle
 #define shuffle(R, A, n)                      \
  do {                                        \
    autotype(A) Array = (A);                  \
@@ -18,6 +19,7 @@
      xchg(&Array[i], &Array[R() % (i + 1)]); \
    }                                         \
  } while (0)
+#endif /* shuffle */

 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_LIBC_RAND_SHUFFLE_H_ */
@@ -0,0 +1,47 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/bits/bits.h"
+#include "libc/macros.h"
+#include "libc/str/str.h"
+
+/**
+ * Atomically loads value.
+ *
+ * This macro is intended to prevent things like compiler load tearing
+ * optimizations.
+ */
+intptr_t(atomic_load)(void *p, size_t n) {
+  intptr_t x = 0;
+  switch (n) {
+    case 1:
+      __builtin_memcpy(&x, p, 1);
+      return x;
+    case 2:
+      __builtin_memcpy(&x, p, 2);
+      return x;
+    case 4:
+      __builtin_memcpy(&x, p, 4);
+      return x;
+    case 8:
+      __builtin_memcpy(&x, p, 8);
+      return x;
+    default:
+      return 0;
+  }
+}
@@ -0,0 +1,46 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/bits/bits.h"
+#include "libc/macros.h"
+#include "libc/str/str.h"
+
+/**
+ * Atomically stores value.
+ *
+ * This macro is intended to prevent things like compiler store tearing
+ * optimizations.
+ */
+intptr_t(atomic_store)(void *p, intptr_t x, size_t n) {
+  switch (n) {
+    case 1:
+      __builtin_memcpy(p, &x, 1);
+      return x;
+    case 2:
+      __builtin_memcpy(p, &x, 2);
+      return x;
+    case 4:
+      __builtin_memcpy(p, &x, 4);
+      return x;
+    case 8:
+      __builtin_memcpy(p, &x, 8);
+      return x;
+    default:
+      return 0;
+  }
+}
@@ -13,17 +13,19 @@ extern const uint8_t kReverseBits[256];

 uint32_t gray(uint32_t) pureconst;
 uint32_t ungray(uint32_t) pureconst;
-
 uint8_t bitreverse8(uint8_t) libcesque pureconst;
 uint16_t bitreverse16(uint16_t) libcesque pureconst;
 uint32_t bitreverse32(uint32_t) libcesque pureconst;
 uint64_t bitreverse64(uint64_t) libcesque pureconst;
-
 unsigned long roundup2pow(unsigned long) libcesque pureconst;
 unsigned long roundup2log(unsigned long) libcesque pureconst;
 unsigned long rounddown2pow(unsigned long) libcesque pureconst;
-
 unsigned long hamming(unsigned long, unsigned long) pureconst;
+intptr_t lockxchg(void *, void *, size_t);
+bool cmpxchg(void *, intptr_t, intptr_t, size_t);
+bool lockcmpxchg(void *, intptr_t, intptr_t, size_t);
+intptr_t atomic_load(void *, size_t);
+intptr_t atomic_store(void *, intptr_t, size_t);

 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § bits » no assembly required                               ─╬─│┼
@@ -70,38 +72,6 @@ unsigned long hamming(unsigned long, unsigned long) pureconst;
   (uint64_t)((unsigned char *)(S))[6] << 010 | \
   (uint64_t)((unsigned char *)(S))[7] << 000)

-#define read16le(S)                            \
-  ({                                           \
-    unsigned char *Str = (unsigned char *)(S); \
-    READ16LE(Str);                             \
-  })
-#define read32le(S)                            \
-  ({                                           \
-    unsigned char *Str = (unsigned char *)(S); \
-    READ32LE(Str);                             \
-  })
-#define read64le(S)                            \
-  ({                                           \
-    unsigned char *Str = (unsigned char *)(S); \
-    READ64LE(Str);                             \
-  })
-
-#define read16be(S)                            \
-  ({                                           \
-    unsigned char *Str = (unsigned char *)(S); \
-    READ16BE(Str);                             \
-  })
-#define read32be(S)                            \
-  ({                                           \
-    unsigned char *Str = (unsigned char *)(S); \
-    READ32BE(Str);                             \
-  })
-#define read64be(S)                            \
-  ({                                           \
-    unsigned char *Str = (unsigned char *)(S); \
-    READ64BE(Str);                             \
-  })
-
 #define WRITE16LE(P, V)             \
  do {                              \
    uint8_t *Ple = (uint8_t *)(P);  \
@@ -165,6 +135,7 @@ unsigned long hamming(unsigned long, unsigned long) pureconst;
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § bits » some assembly required                             ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__)

 /*
 * Constraints for virtual machine flags.
@@ -263,12 +234,10 @@ unsigned long hamming(unsigned long, unsigned long) pureconst;
 * @return LOCALVAR[0]
 * @see xchg()
 */
-#define lockxchg(MEMORY, LOCALVAR)                                             \
-  ({                                                                           \
-    _Static_assert(                                                            \
-        __builtin_types_compatible_p(typeof(*(MEMORY)), typeof(*(LOCALVAR)))); \
-    asm("xchg\t%0,%1" : "+%m"(*(MEMORY)), "+r"(*(LOCALVAR)));                  \
-    *(LOCALVAR);                                                               \
+#define lockxchg(MEMORY, LOCALVAR)                            \
+  ({                                                          \
+    asm("xchg\t%0,%1" : "+%m"(*(MEMORY)), "+r"(*(LOCALVAR))); \
+    *(LOCALVAR);                                              \
  })

 /**
@@ -311,47 +280,6 @@ unsigned long hamming(unsigned long, unsigned long) pureconst;
    DidIt;                                                                    \
  })

-/**
- * Gets value of extended control register.
- */
-#define xgetbv(xcr_register_num)                               \
-  ({                                                           \
-    unsigned hi, lo;                                           \
-    asm("xgetbv" : "=d"(hi), "=a"(lo) : "c"(cr_register_num)); \
-    (uint64_t) hi << 32 | lo;                                  \
-  })
-
-/**
- * Reads model-specific register.
- * @note programs running as guests won't have authorization
- */
-#define rdmsr(msr)                                         \
-  ({                                                       \
-    uint32_t lo, hi;                                       \
-    asm volatile("rdmsr" : "=a"(lo), "=d"(hi) : "c"(msr)); \
-    (uint64_t) hi << 32 | lo;                              \
-  })
-
-/**
- * Writes model-specific register.
- * @note programs running as guests won't have authorization
- */
-#define wrmsr(msr, val)                           \
-  do {                                            \
-    uint64_t val_ = (val);                        \
-    asm volatile("wrmsr"                          \
-                 : /* no outputs */               \
-                 : "c"(msr), "a"((uint32_t)val_), \
-                   "d"((uint32_t)(val_ >> 32)));  \
-  } while (0)
-
-/**
- * Tells CPU page tables changed for virtual address.
- * @note programs running as guests won't have authorization
- */
-#define invlpg(MEM) \
-  asm volatile("invlpg\t(%0)" : /* no outputs */ : "r"(MEM) : "memory")
-
 #define IsAddressCanonicalForm(P)                             \
  ({                                                          \
    intptr_t p2 = (intptr_t)(P);                              \
@@ -402,6 +330,17 @@ unsigned long hamming(unsigned long, unsigned long) pureconst;
    OldBit;                                                    \
  })

+#else
+#define cmpxchg(MEM, CMP, VAL) \
+  cmpxchg(MEM, (intptr_t)(CMP), (intptr_t)(VAL), sizeof(*(MEM)))
+#define lockcmpxchg(MEM, CMP, VAL) \
+  lockcmpxchg(MEM, (intptr_t)(CMP), (intptr_t)(VAL), sizeof(*(MEM)))
+#define lockxchg(MEM, VAR) \
+  lockxchg(MEM, VAR, sizeof(*(MEM)) / (sizeof(*(MEM)) == sizeof(*(VAR))))
+#define atomic_store(MEM, VAL) \
+  atomic_store(MEM, VAL, sizeof(*(MEM)) / (sizeof(*(MEM)) == sizeof(*(VAL))))
+#define atomic_load(MEM) atomic_load(MEM, sizeof(*(MEM)))
+#endif /* __GNUC__ && !__STRICT_ANSI__ */
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_LIBC_BITS_H_ */
@@ -0,0 +1,47 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/bits/bits.h"
+
+/**
+ * Compares and exchanges.
+ *
+ * @param ifthing is uint𝑘_t[hasatleast 1] where 𝑘 ∈ {8,16,32,64}
+ * @param size is automatically supplied by macro wrapper
+ * @return true if value was exchanged, otherwise false
+ * @see lockcmpxchg()
+ */
+bool(cmpxchg)(void *ifthing, intptr_t isequaltome, intptr_t replaceitwithme,
+              size_t size) {
+  switch (size) {
+    case 1:
+      return cmpxchg((int8_t *)ifthing, (int8_t)isequaltome,
+                     (int8_t)replaceitwithme);
+    case 2:
+      return cmpxchg((int16_t *)ifthing, (int16_t)isequaltome,
+                     (int16_t)replaceitwithme);
+    case 4:
+      return cmpxchg((int32_t *)ifthing, (int32_t)isequaltome,
+                     (int32_t)replaceitwithme);
+    case 8:
+      return cmpxchg((int64_t *)ifthing, (int64_t)isequaltome,
+                     (int64_t)replaceitwithme);
+    default:
+      return false;
+  }
+}
@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_LIBC_BITS_EMMINTRIN_H_
 #define COSMOPOLITAN_LIBC_BITS_EMMINTRIN_H_
-#include "libc/bits/progn.internal.h"
 #include "libc/bits/xmmintrin.internal.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)

@@ -170,13 +169,25 @@ struct thatispacked mayalias __usi128ma {
  })

 #define _mm_add_sd(M128D_0, M128D_1) \
-  PROGN((M128D_0)[0] += (M128D_1)[0], (M128D_0))
+  ({                                 \
+    (M128D_0)[0] += (M128D_1)[0];    \
+    (M128D_0);                       \
+  })
 #define _mm_sub_sd(M128D_0, M128D_1) \
-  PROGN((M128D_0)[0] -= (M128D_1)[0], (M128D_0))
+  ({                                 \
+    (M128D_0)[0] -= (M128D_1)[0];    \
+    (M128D_0);                       \
+  })
 #define _mm_mul_sd(M128D_0, M128D_1) \
-  PROGN((M128D_0)[0] *= (M128D_1)[0], (M128D_0))
+  ({                                 \
+    (M128D_0)[0] *= (M128D_1)[0];    \
+    (M128D_0);                       \
+  })
 #define _mm_div_sd(M128D_0, M128D_1) \
-  PROGN((M128D_0)[0] /= (M128D_1)[0], (M128D_0))
+  ({                                 \
+    (M128D_0)[0] /= (M128D_1)[0];    \
+    (M128D_0);                       \
+  })

 #define _mm_min_sd(M128D_0, M128D_1) \
  __builtin_ia32_minsd((__v2df)(M128D_0), (__v2df)(M128D_1))
@@ -7,6 +7,7 @@
 /**
 * Teleports code fragment inside _init().
 */
+#ifndef INITIALIZER
 #define INITIALIZER(PRI, NAME, CODE)                               \
  asm(".section .init." #PRI "." #NAME ",\"ax\",@progbits\n\t"     \
      "call\t" #NAME "\n\t"                                        \
@@ -15,6 +16,7 @@
    CODE;                                                          \
    asm volatile("" : /* no outputs */ : "D"(rdi), "S"(rsi));      \
  }
+#endif /* INITIALIZER */

 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_LIBC_BITS_INITIALIZER_H_ */
@@ -2,8 +2,8 @@
 #define COSMOPOLITAN_LIBC_BITS_LIKELY_H_
 #if !(__ASSEMBLER__ + __LINKER__ + 0)

-#define likely(expr)   __builtin_expect(!!(expr), 1)
-#define unlikely(expr) __builtin_expect(!!(expr), 0)
+#define LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#define UNLIKELY(expr) __builtin_expect(!!(expr), 0)

 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_LIBC_BITS_LIKELY_H_ */
@@ -0,0 +1,47 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/bits/bits.h"
+
+/**
+ * Compares and exchanges w/ lock prefix.
+ *
+ * @param ifthing is uint𝑘_t[hasatleast 1] where 𝑘 ∈ {8,16,32,64}
+ * @param size is automatically supplied by macro wrapper
+ * @return true if value was exchanged, otherwise false
+ * @see cmpxchg()
+ */
+bool(lockcmpxchg)(void *ifthing, intptr_t isequaltome, intptr_t replaceitwithme,
+                  size_t size) {
+  switch (size) {
+    case 1:
+      return lockcmpxchg((int8_t *)ifthing, (int8_t)isequaltome,
+                         (int8_t)replaceitwithme);
+    case 2:
+      return lockcmpxchg((int16_t *)ifthing, (int16_t)isequaltome,
+                         (int16_t)replaceitwithme);
+    case 4:
+      return lockcmpxchg((int32_t *)ifthing, (int32_t)isequaltome,
+                         (int32_t)replaceitwithme);
+    case 8:
+      return lockcmpxchg((int64_t *)ifthing, (int64_t)isequaltome,
+                         (int64_t)replaceitwithme);
+    default:
+      return false;
+  }
+}
@@ -0,0 +1,42 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/bits/bits.h"
+
+/**
+ * Compares and exchanges w/ lock prefix.
+ *
+ * @param memory is uint𝑘_t[hasatleast 1] where 𝑘 ∈ {8,16,32,64}
+ * @param size is automatically supplied by macro wrapper
+ * @return true if value was exchanged, otherwise false
+ * @see xchg()
+ */
+intptr_t(lockxchg)(void *memory, void *localvar, size_t size) {
+  switch (size) {
+    case 1:
+      return lockxchg((int8_t *)memory, (int8_t *)localvar);
+    case 2:
+      return lockxchg((int16_t *)memory, (int16_t *)localvar);
+    case 4:
+      return lockxchg((int32_t *)memory, (int32_t *)localvar);
+    case 8:
+      return lockxchg((int64_t *)memory, (int64_t *)localvar);
+    default:
+      return false;
+  }
+}
@@ -1,15 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_BITS_PROGN_H_
-#define COSMOPOLITAN_LIBC_BITS_PROGN_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-COSMOPOLITAN_C_START_
-
-/**
- * Evaluates args, returning value of last one.
- *
- * This API comes from LISP.
- */
-#define PROGN(...) ({ __VA_ARGS__; })
-
-COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_BITS_PROGN_H_ */
@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_LIBC_BITS_SAFEMACROS_H_
 #define COSMOPOLITAN_LIBC_BITS_SAFEMACROS_H_
-#ifndef __STRICT_ANSI__
 #include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
@@ -16,7 +15,8 @@ const char *emptytonull(const char *);
 const char *firstnonnull(const char *, const char *);
 uint64_t(unsignedsubtract)(uint64_t, uint64_t) pureconst;

-#if !defined(__STRICT_ANSI__) && defined(__GNUC__)
+#if !defined(__STRICT_ANSI__) && defined(__GNUC__) && \
+!defined(__VSCODE_INTELLISENSE__)

 #define min(x, y)              \
  ({                           \
@@ -83,5 +83,4 @@ uint64_t(unsignedsubtract)(uint64_t, uint64_t) pureconst;

 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* !ANSI */
 #endif /* COSMOPOLITAN_LIBC_BITS_SAFEMACROS_H_ */
@@ -1,6 +1,7 @@
 #ifndef COSMOPOLITAN_LIBC_BITS_SEGMENTATION_H_
 #define COSMOPOLITAN_LIBC_BITS_SEGMENTATION_H_
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__)

 /**
 * Reads scalar from memory, offset by segment.
@@ -19,5 +20,6 @@
    Pk;                                                           \
  })

+#endif /* __GNUC__ && !__STRICT_ANSI__ */
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_LIBC_BITS_SEGMENTATION_H_ */
@@ -1,7 +1,6 @@
 #ifndef COSMOPOLITAN_LIBC_BITS_XMMINTRIN_H_
 #define COSMOPOLITAN_LIBC_BITS_XMMINTRIN_H_
 #include "libc/bits/emmintrin.internal.h"
-#include "libc/bits/progn.internal.h"
 #include "libc/dce.h"

 #define _MM_EXCEPT_MASK       0x003f
@@ -17,10 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/calls/internal.h"
-#include "libc/dce.h"
 #include "libc/sysv/consts/at.h"
-#include "libc/sysv/errfuns.h"

 /**
 * Checks if effective user can access path in particular ways.
@@ -31,12 +28,5 @@
 * @asyncsignalsafe
 */
 int access(const char *path, int mode) {
-  char16_t path16[PATH_MAX];
-  if (!path) return efault();
-  if (!IsWindows()) {
-    return faccessat$sysv(AT_FDCWD, path, mode, 0);
-  } else {
-    if (__mkntpath(path, path16) == -1) return -1;
-    return ntaccesscheck(path16, mode);
-  }
+  return faccessat(AT_FDCWD, path, mode, 0);
 }
@@ -1,7 +1,15 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_SYSCALLS_H_
 #define COSMOPOLITAN_LIBC_CALLS_SYSCALLS_H_
+#include "libc/calls/struct/dirent.h"
+#include "libc/calls/struct/iovec.h"
+#include "libc/calls/struct/rlimit.h"
+#include "libc/calls/struct/rusage.h"
 #include "libc/calls/struct/sigaction.h"
+#include "libc/calls/struct/stat.h"
+#include "libc/calls/struct/sysinfo.h"
 #include "libc/calls/struct/timespec.h"
+#include "libc/calls/struct/tms.h"
+#include "libc/calls/struct/utsname.h"
 #include "libc/calls/typedef/sighandler_t.h"
 #include "libc/dce.h"
 #include "libc/fmt/pflink.h"
@@ -54,19 +62,7 @@ COSMOPOLITAN_C_START_
 │ cosmopolitan § system calls                                              ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/

-struct dirstream;
-struct iovec;
-struct rlimit;
-struct rusage;
-struct sigaction;
-struct sigset;
-struct stat;
-struct sysinfo;
-struct tms;
-struct utsname;
-
 typedef int sig_atomic_t;
-typedef struct dirstream DIR;

 extern const struct sigset kSigsetFull;
 extern const struct sigset kSigsetEmpty;
@@ -106,7 +102,6 @@ int execvp(const char *, char *const[]) paramsnonnull();
 int execvpe(const char *, char *const[], char *const[]) paramsnonnull();
 int faccessat(int, const char *, int, uint32_t);
 int fadvise(int, uint64_t, uint64_t, int);
-int fallocate(int, int32_t, int64_t, int64_t);
 int fchmod(int, uint32_t) nothrow;
 int fchmodat(int, const char *, uint32_t, uint32_t);
 int fchown(int, uint32_t, uint32_t);
@@ -151,7 +146,6 @@ int personality(uint64_t);
 int pipe(int[hasatleast 2]);
 int pipe2(int[hasatleast 2], int);
 int posix_fadvise(int, uint64_t, uint64_t, int);
-int posix_fallocate(int, int64_t, int64_t);
 int posix_madvise(void *, uint64_t, int);
 int raise(int);
 int readlink(const char *, char *, size_t);
@@ -196,12 +190,12 @@ int wait(int *);
 int wait3(int *, int, struct rusage *);
 int wait4(int, int *, int, struct rusage *);
 int waitpid(int, int *, int);
-int64_t lseek(int, int64_t, int);
-int64_t pread(int, void *, size_t, int64_t);
-int64_t preadv(int, struct iovec *, int, int64_t);
-int64_t pwrite(int, const void *, size_t, int64_t);
-int64_t pwritev(int, const struct iovec *, int, int64_t);
-int64_t syscall();
+ssize_t lseek(int, int64_t, unsigned);
+ssize_t pread(int, void *, size_t, int64_t);
+ssize_t preadv(int, struct iovec *, int, int64_t);
+ssize_t pwrite(int, const void *, size_t, int64_t);
+ssize_t pwritev(int, const struct iovec *, int, int64_t);
+intptr_t syscall(int, ...);
 void sync(void);
 long telldir(DIR *);
 int getpid(void);
@@ -230,10 +224,7 @@ long ptrace(int, int, void *, void *);
 int chroot(const char *);
 int prctl();
 int sysctl(const int *, unsigned, void *, size_t *, void *, size_t);
-
-#define getcwd(BUF, SIZE)                                                    \
-  (__builtin_constant_p(BUF) && (&(BUF)[0] == NULL) ? get_current_dir_name() \
-                                                    : getcwd(BUF, SIZE))
+int fchdir(int);

 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § system calls » formatting                                 ─╬─│┼
@@ -247,9 +238,14 @@ int vdprintf(int, const char *, va_list) paramsnonnull();
 ╚────────────────────────────────────────────────────────────────────────────│*/
 #if defined(__GNUC__) && !defined(__STRICT_ANSI__)

+#define getcwd(BUF, SIZE)                                       \
+  (__builtin_constant_p(BUF) && !(BUF) ? get_current_dir_name() \
+                                       : getcwd(BUF, SIZE))
+
 void _init_onntconsoleevent(void);
 void _init_wincrash(void);

+#ifndef __SIGACTION
 #define __SIGACTION(FN, SIG, ...)          \
  ({                                       \
    if (SupportsWindows()) {               \
@@ -278,6 +274,7 @@ void _init_wincrash(void);
    }                                      \
    (FN)(SIG, __VA_ARGS__);                \
  })
+#endif

 #define dprintf(FD, FMT, ...)    (dprintf)(FD, PFLINK(FMT), ##__VA_ARGS__)
 #define sigaction(SIG, ACT, OLD) __SIGACTION(sigaction, SIG, ACT, OLD)
@@ -17,10 +17,10 @@ LIBC_CALLS = $(LIBC_CALLS_A_DEPS) $(LIBC_CALLS_A)
 LIBC_CALLS_A = o/$(MODE)/libc/calls/syscalls.a
 LIBC_CALLS_A_FILES :=					\
 	$(wildcard libc/calls/typedef/*)		\
-	$(wildcard libc/calls/thunks/*)			\
 	$(wildcard libc/calls/struct/*)			\
 	$(wildcard libc/calls/*)
 LIBC_CALLS_A_HDRS = $(filter %.h,$(LIBC_CALLS_A_FILES))
+LIBC_CALLS_A_INCS = $(filter %.inc,$(LIBC_CALLS_A_FILES))
 LIBC_CALLS_A_SRCS_S = $(filter %.S,$(LIBC_CALLS_A_FILES))
 LIBC_CALLS_A_SRCS_C = $(filter %.c,$(LIBC_CALLS_A_FILES))

@@ -43,7 +43,6 @@ LIBC_CALLS_A_DIRECTDEPS =				\
 	LIBC_NT_ADVAPI32				\
 	LIBC_NT_KERNEL32				\
 	LIBC_NT_NTDLL					\
-	LIBC_RAND					\
 	LIBC_STR					\
 	LIBC_STUBS					\
 	LIBC_SYSV_CALLS					\
@@ -86,12 +85,11 @@ o/$(MODE)/libc/calls/mkntenvblock.o:			\
 LIBC_CALLS_LIBS = $(foreach x,$(LIBC_CALLS_ARTIFACTS),$($(x)))
 LIBC_CALLS_SRCS = $(foreach x,$(LIBC_CALLS_ARTIFACTS),$($(x)_SRCS))
 LIBC_CALLS_HDRS = $(foreach x,$(LIBC_CALLS_ARTIFACTS),$($(x)_HDRS))
+LIBC_CALLS_INCS = $(foreach x,$(LIBC_CALLS_ARTIFACTS),$($(x)_INCS))
 LIBC_CALLS_BINS = $(foreach x,$(LIBC_CALLS_ARTIFACTS),$($(x)_BINS))
 LIBC_CALLS_CHECKS = $(foreach x,$(LIBC_CALLS_ARTIFACTS),$($(x)_CHECKS))
 LIBC_CALLS_OBJS = $(foreach x,$(LIBC_CALLS_ARTIFACTS),$($(x)_OBJS))
 LIBC_CALLS_TESTS = $(foreach x,$(LIBC_CALLS_ARTIFACTS),$($(x)_TESTS))

 .PHONY: o/$(MODE)/libc/calls
-o/$(MODE)/libc/calls:					\
-		o/$(MODE)/libc/calls/hefty		\
-		$(LIBC_CALLS_CHECKS)
+o/$(MODE)/libc/calls: $(LIBC_CALLS_CHECKS)
@@ -17,21 +17,39 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
+#include "libc/nt/errors.h"
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
+#include "libc/nt/synchronization.h"
 #include "libc/sysv/errfuns.h"

-textwindows int chdir$nt(const char *path) {
-  int len;
+textwindows int sys_chdir_nt(const char *path) {
+  int e, ms, len;
  char16_t path16[PATH_MAX];
  if ((len = __mkntpath(path, path16)) == -1) return -1;
-  if (path16[len - 1] != u'/' && path16[len - 1] != u'\\') {
-    path16[len + 0] = u'/';
+  if (path16[len - 1] != u'\\') {
+    if (len + 1 + 1 > PATH_MAX) return enametoolong();
+    path16[len + 0] = u'\\';
    path16[len + 1] = u'\0';
  }
-  if (SetCurrentDirectory(path16)) {
-    return 0;
-  } else {
-    return __winerr();
+  /*
+   * chdir() seems flaky on windows 7
+   * in a similar way to rmdir() sigh
+   */
+  for (ms = 1;; ms *= 2) {
+    if (SetCurrentDirectory(path16)) {
+      return 0;
+    } else {
+      e = GetLastError();
+      if (ms <= 512 &&
+          (e == kNtErrorFileNotFound || e == kNtErrorAccessDenied)) {
+        Sleep(ms);
+        continue;
+      } else {
+        break;
+      }
+    }
  }
+  errno = e;
+  return -1;
 }
@@ -16,21 +16,19 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/dce.h"
-#include "libc/sysv/errfuns.h"

 /**
 * Sets current directory.
+ *
 * @asyncsignalsafe
- * @syscall
+ * @see fchdir()
 */
 int chdir(const char *path) {
-  if (!path) return efault();
  if (!IsWindows()) {
-    return chdir$sysv(path);
+    return sys_chdir(path);
  } else {
-    return chdir$nt(path);
+    return sys_chdir_nt(path);
  }
 }
@@ -42,9 +42,7 @@
 * @errors ENOENT, ENOTDIR, ENOSYS
 * @asyncsignalsafe
 * @see fchmod()
- * @syscall
 */
 int chmod(const char *pathname, uint32_t mode) {
-  if (!pathname) return efault();
-  return fchmodat$sysv(AT_FDCWD, pathname, mode, 0);
+  return sys_fchmodat(AT_FDCWD, pathname, mode, 0);
 }
@@ -32,9 +32,7 @@
 * @see /etc/passwd for user ids
 * @see /etc/group for group ids
 * @asyncsignalsafe
- * @syscall
 */
 int chown(const char *pathname, uint32_t uid, uint32_t gid) {
-  if (!pathname) return efault();
-  return fchownat$sysv(AT_FDCWD, pathname, uid, gid, 0);
+  return sys_fchownat(AT_FDCWD, pathname, uid, gid, 0);
 }
@@ -16,22 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/bits/bits.h"
-#include "libc/bits/safemacros.h"
-#include "libc/calls/calls.h"
+#include "libc/assert.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timeval.h"
-#include "libc/dce.h"
 #include "libc/fmt/conv.h"
-#include "libc/mach.h"
-#include "libc/nt/struct/filetime.h"
-#include "libc/nt/struct/systemtime.h"
 #include "libc/nt/synchronization.h"
-#include "libc/sysv/consts/clock.h"
-#include "libc/sysv/consts/fileno.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/time/time.h"

 /**
 * Returns nanosecond time.
@@ -43,41 +33,34 @@
 * @param clockid can be CLOCK_REALTIME, CLOCK_MONOTONIC, etc. noting
 *     that on Linux CLOCK_MONOTONIC is redefined to use the monotonic
 *     clock that's actually monotonic lool
- * @param out_ts is where the nanoseconds are stored if non-NULL
- * @return 0 on success or -1 w/ errno on error
+ * @param ts is where the result is stored
+ * @return 0 on success, or -1 w/ errno
 * @error ENOSYS if clockid isn't available; in which case this function
- *     guarantees an ordinary timestamp is still stored to out_ts; and
+ *     guarantees an ordinary timestamp is still stored to ts; and
 *     errno isn't restored to its original value, to detect prec. loss
 * @see strftime(), gettimeofday()
 * @asyncsignalsafe
- * @syscall
 */
-int clock_gettime(int clockid, struct timespec *out_ts) {
-  /* TODO(jart): Just ignore O/S for MONOTONIC and measure RDTSC on start */
+int clock_gettime(int clockid, struct timespec *ts) {
+  int rc;
+  axdx_t ad;
+  struct NtFileTime ft;
+  if (!ts) return efault();
  if (!IsWindows()) {
-    if (!IsXnu()) {
-      if (out_ts) {
-        out_ts->tv_sec = 0;
-        out_ts->tv_nsec = 0;
+    if ((rc = sys_clock_gettime(clockid, ts)) == -1 && errno == ENOSYS) {
+      ad = sys_gettimeofday((struct timeval *)ts, NULL, NULL);
+      assert(ad.ax != -1);
+      if (SupportsXnu() && ad.ax) {
+        ts->tv_sec = ad.ax;
+        ts->tv_nsec = ad.dx;
      }
-      return clock_gettime$sysv(clockid, out_ts);
-    } else {
-      int rc;
-      _Static_assert(sizeof(struct timeval) == sizeof(struct timespec));
-      if (out_ts) {
-        out_ts->tv_sec = 0;
-        out_ts->tv_nsec = 0;
-      }
-      rc = gettimeofday$sysv((struct timeval *)out_ts, NULL);
-      if (out_ts) {
-        out_ts->tv_nsec *= 1000;
-      }
-      return rc;
+      ts->tv_nsec *= 1000;
+      rc = 0;
    }
+    return rc;
  } else {
-    struct NtFileTime ft;
    GetSystemTimeAsFileTime(&ft);
-    *out_ts = FileTimeToTimeSpec(ft);
+    *ts = FileTimeToTimeSpec(ft);
    return 0;
  }
 }
Author	SHA1	Message	Date
Justine Tunney	face6b61d5	Add APE support for 32-bit programs This is an experimental proof of concept demo: make -j8 o//examples/i386.i386.com o//examples/i386.i386.com --32 echo $? # <-- prints main32's argc parameter Please note there's no libc support at the moment. This change is just for fun and shouldn't be interpreted as intent to support. Having this project on the whole support i386 would be tough because the calling conventions are so different. There really isn't much in the way of low hanging fruit opportunities to do something like NOP out REX prefixes and call it a day. It'd likely need disjoint builds or possibly better yet really cleverly crafted code generation in //third_party/chibicc! Another challenge is is that Linux changed its SYSCALL ordinals when it migrated from i386 to x86_64. Linux used to use the same magic numbers as everyone else for functions like exit/write/read/etc. BSDs on the other hand didn't pointlessly renumber things. So we'd need to find a way to define the ordinals in libc/sysv/syscalls.sh twice for Linux. The same goes for other ISAs too. Especially MIPS. For the Linux Kernel alone, syscall magic numbers and data structure layouts are totally different, and that's likely the case for other ISAs on other operating systems too. Probably because ISA code historically got contributed to open source by the companies that made the chips. Ulrich Drepper wrote an amusing essay on the subject some years back.	2021-02-20 15:58:48 -08:00
Justine Tunney	e345b42d78	Don't scrub PATH variable since Clang needs it	2021-02-20 12:54:13 -08:00
Justine Tunney	e85aeda4ba	Fix some more build issues (#43 ) We're now scrubbing environment variables in compile.com since gnu make was not behaving as expected. It also appears there was a regression in recent revisions that caused ASAN to be turned off for most binaries in dbg mode, which has now been fixed. Cosmopolitan is fully ASAN hardened down to the lowest level libraries and it doesn't need any interceptors	2021-02-20 12:39:39 -08:00
Justine Tunney	3e1fd1d962	Add tool for parsing strace output	2021-02-20 10:45:55 -08:00
Justine Tunney	b740cca642	Improve build system - Reduce full build latency from ~20s to ~18s - Bring back silent mode if `make V=0` is passed - Demodernize utimes() polyfill so it works RHEL5 - Delete some old shell scripts that are no longer needed - Truncate long lines when outputting builds to Emacs buffers	2021-02-19 23:03:34 -08:00
Justine Tunney	c797f139bb	Set LC_ALL=C in build config (#43 ) It's most likely the case (and SHOULD be the case) that C is the same locale as C.UTF-8. The only exception might be Python's gonzo unicode handling which whines when unicode is used without authorization, but that shouldn't be an issue since we don't need Python to build.	2021-02-19 17:16:45 -08:00
Justine Tunney	adebc5e4c3	Remove support vector config shortcuts These were used to build the "How Fat Does a Fat Binary Need to Be?" blog post, but they're not needed anymore.	2021-02-19 17:16:17 -08:00
Justine Tunney	5f1415af3a	Add help dialog to Blinkenlights emulator	2021-02-19 17:16:17 -08:00
Jay Petacat	02b4a5c824	Fix zip file name in "Getting Started" example	2021-02-19 13:39:06 -08:00
Justine Tunney	45b994ea23	Make minor corrections to curl example This makes the code size smaller and correctly uses the firstnonnull() API which aborts if both arguments are NULL.	2021-02-18 20:17:07 -08:00
Justine Tunney	2c15efc249	Add curl example (#42 ) make -j8 o//examples/curl.com o//examples/curl.com http://justine.lol/ape.html	2021-02-18 19:20:41 -08:00
Justine Tunney	667ab245fe	Implement setlocale() stub (#43 )	2021-02-18 17:06:06 -08:00
Justine Tunney	08d3700c15	Fix getting started example for Z-shell (#44 ) Apropos zsh, our patch has now been upstreamed! See: https://github.com/zsh-users/zsh/commit/326d9c203b39	2021-02-18 16:32:31 -08:00
Justine Tunney	6f35bd47ab	Fix JavaScript interpreter example	2021-02-11 23:18:39 -08:00
Justine Tunney	bfa8581537	Trim down executable sizes	2021-02-11 08:37:18 -08:00
Justine Tunney	ec69413f83	Cosmopolitan 0.2	2021-02-09 20:36:07 -08:00
Justine Tunney	e75ffde09e	Get codebase completely working with LLVM You can now build Cosmopolitan with Clang: make -j8 MODE=llvm o/llvm/examples/hello.com The assembler and linker code is now friendly to LLVM too. So it's not needed to configure Clang to use binutils under the hood. If you love LLVM then you can now use pure LLVM.	2021-02-09 02:57:32 -08:00
Justine Tunney	0e36cb3ac4	Improve dead code elimination	2021-02-08 04:04:42 -08:00
Justine Tunney	760db8c5ad	Remove clang dependency from build We need a better way to conditionally test Clang if it exists.	2021-02-07 07:20:56 -08:00
Justine Tunney	2f3bd90216	Apply some touchups	2021-02-07 07:02:46 -08:00
Justine Tunney	9f149e1de3	Elevate .text.syscall to .privileged It turns out adding OpenBSD msyscall() origin verification broke the --ftrace flag. The executable needs to issue raw syscalls while it's rewriting itself. So they need to be in the same section, and that's just plain simpler too.	2021-02-06 04:49:22 -08:00
Justine Tunney	d7733579d3	Fix Clang support The amalgamated release is now confirmed to be working with Clang, including its integrated assembler. Fixes #41	2021-02-06 00:29:09 -08:00
Justine Tunney	e06c90fafc	Cleanup socket code	2021-02-05 23:58:50 -08:00
Justine Tunney	a91ba89d85	Fix sigsuspend() and sigprocmask() on OpenBSD Test reliability is now iron clad.	2021-02-05 12:19:43 -08:00
Justine Tunney	b2cd58a322	Get all tests passing on NetBSD	2021-02-05 09:49:28 -08:00
Justine Tunney	23ae9dfceb	Add NetBSD support	2021-02-05 06:19:45 -08:00
Justine Tunney	2fdc19e7a7	Write more memory mapping tests Microsoft claims to support COW but it's probably not true.	2021-02-04 18:24:33 -08:00
Justine Tunney	74d48f7cb6	Definen LLP64 data model for code completion This change should not be interpreted as an intent to support MSVC which appears to live on in VSCode IntelliSense for what's dead will never die	2021-02-04 16:56:43 -08:00
Justine Tunney	3384a5a48c	Apply touchups to last PR Compilers like GCC require comments on lines like `#endif rdmsr`. Since the rdmsr macro was only being used in arch_prctl(), I've localized the macro, and I'm considering deleting arch_prctl() too, since there isn't any way to have mem segments unfortunately across operating systems ;_; The remaining changed lines are due to clang-format which runs on auto.	2021-02-04 16:41:34 -08:00
Justine Tunney	888cfa74d7	Merge pull request #40 from nicholatian/jart Add VS Code IntelliSense support scaffolding	2021-02-04 15:45:07 -08:00
Alexander Nicholi	46d8fd8c3f	remove semicolons from #defines	2021-02-04 08:38:21 -05:00
Alexander Nicholi	dbd7edba10	sync and try changes	2021-02-04 08:33:22 -05:00
Justine Tunney	c93a4661a3	Add Cosmopolitan Honeybadger to README.md	2021-02-04 03:31:03 -08:00
Justine Tunney	d934f38c99	Polyfill auxiliary values on XNU	2021-02-03 20:37:52 -08:00
Justine Tunney	a37960a3af	Remove dollars from system call support symbols	2021-02-03 19:35:29 -08:00
Justine Tunney	a8d7195777	Make Cosmopolitan ANSI C89 compatible You can now use cosmopolitan.h with an ANSI C89 compiler like MSVC. The Cosmopolitan codebase itself won't support being compiled that way. But you can build objects that link against Cosmopolitan using any compiler and you can furthermore use tools like IntelliSense that can't even GNU See also #40	2021-02-03 17:48:59 -08:00
Justine Tunney	46085797b6	Make ANSI mode closer to being ANSI	2021-02-03 17:14:17 -08:00
Justine Tunney	28135b7a20	Add `q` keyboard shortcut to printvideo.com (#37 )	2021-02-03 15:53:33 -08:00
Alexander Nicholi	ec9bfd8c56	finish intellisense support and sync with upstream	2021-02-03 13:50:08 -05:00
Justine Tunney	4e56d89dcd	Eliminate some flakes - Get ASAN working on Windows. - Deleting directories and then recreating them with the same name in a short period of time appears to be a no-no on Windows. - There's no reason to call FlushFileBuffers on close() for pipes, and it's harmful since it might block indefinitely for no good reason.	2021-02-03 06:25:27 -08:00
Justine Tunney	27c899af56	Make mmap() work better - Mapping file offsets now works on Windows - Mapping stack memory now works on OpenBSD	2021-02-03 00:10:12 -08:00
Justine Tunney	23a14b537c	Delete LIBC_CALLS_HEFTY - fork() no longer requires malloc() - readdir() moved to LIBC_STDIO - Custom APIs moved to LIBC_X	2021-02-02 22:17:53 -08:00
Justine Tunney	c843243322	Implement more security stuff - Support deterministic stacks on OpenBSD - Support OpenBSD system call origin verification - Fix overrun by one in chibicc string token allocator - Get all chibicc tests passing under Address Sanitizer	2021-02-02 20:21:06 -08:00
Alexander Nicholi	7642710155	wip on intellisense (again)	2021-02-02 11:14:45 -05:00
Alexander Nicholi	9841e2186a	wip vscode intellisense support	2021-02-02 07:29:00 -05:00
Justine Tunney	cbfd4ccd1e	Make more functions friendly to Address Sanitizer	2021-02-02 03:45:31 -08:00
Justine Tunney	3ab76b2312	Fix cosmopolitan.h for C++ We now have an integration test that runs the amalgamated sources through a C++ compiler, to prevent the recurrence of such issues. Fixes #38 Thanks @gbbnfhb for the report!	2021-02-01 04:04:44 -08:00
Justine Tunney	1ff9ab95ac	Make C memory safe like Rust This change enables Address Sanitizer systemically w/ `make MODE=dbg`. Our version of Rust's `unsafe` keyword is named `noasan` which is used for two functions that do aligned memory chunking, like `strcpy.c` and we need to fix the tiny DEFLATE code, but that's it everything else is fabulous you can have all the fischer price security blankets you need Best of all is we're now able to use the ASAN data in Blinkenlights to colorize the memory dumps. See the screenshot below of a test program: https://justine.lol/blinkenlights/asan.png Which is operating on float arrays stored on the stack, with red areas indicating poisoned memory, and the green areas indicate valid memory.	2021-02-01 03:58:46 -08:00
Justine Tunney	fdc3fa9148	Remove sun musl fdlibm math library The libm code from musl wasn't being used since most of these functions are implemented using x87 which goes faster than a library intended for risc machines.	2021-01-31 18:25:16 -08:00
Justine Tunney	e6481efa80	Use `make SILENT=0` by default Silent build configs are good for the core developers of a project because they understand the build config, however it's an obstacle for newcomers who'll be better served by seeing the build commands	2021-01-31 11:30:42 -08:00
Justine Tunney	39bb91fc44	Improve fcntl(F_{SET,GET}FL) implementation (#32 )	2021-01-30 13:10:32 -08:00
Justine Tunney	4072e40bb8	Cosmopolitan 0.1.2	2021-01-30 10:13:13 -08:00
Justine Tunney	393a642c22	Increase Windows stack size (#32 ) We're now using the same values CMD.EXE uses.	2021-01-30 10:08:28 -08:00
Justine Tunney	95173645a1	Implement getcwd() for XNU	2021-01-30 08:54:12 -08:00
Justine Tunney	417797d218	Support dirfd relative iops on Windows We always favor calling functions like openat(), fstatat(), etc. because Linux, XNU, FreeBSD, and OpenBSD all elected to support them, while some systems like Android love them so much, that they stopped supporting the old interfaces. This change ensures that when dirfd is actually a dirfd and not AT_FDCWD we'll do the right thing on Windows NT. We use an API that's been around since Vista to accomplish that. This change also adds exponential backoff to chdir() on Windows since it seems almost as flaky on Windows 7 as the rmdir() function.	2021-01-30 01:49:43 -08:00
Justine Tunney	b8d26e2418	Fix fork() on Windows after chdir()	2021-01-29 23:19:29 -08:00
Justine Tunney	21e1023d28	Reduce memory requirements for execve()	2021-01-29 22:00:10 -08:00
Justine Tunney	eaca5b3e81	Add exponential backoff to rmdir() on Windows	2021-01-29 21:48:40 -08:00
Justine Tunney	bf8b1623c8	Normalize mkdir() error codes	2021-01-29 21:21:06 -08:00
Justine Tunney	6070319f84	Create FUNDING.yml	2021-01-29 14:56:22 -08:00
Justine Tunney	36b4bf74f7	Cosmopolitan 0.1.1 This fixes a few bugs that slipped through the 0.1 release process.	2021-01-29 01:30:51 -08:00
Justine Tunney	caee314a50	Make PATH search do the right thing w/ empty path	2021-01-29 01:27:09 -08:00
Justine Tunney	a5f3456333	Refix readdir() on OpenBSD We now have better tests which are catching these kinds of bugs.	2021-01-29 01:25:14 -08:00
Justine Tunney	f7c7b949fd	Explore comfort level with posix_spawn Justine says nay for the time being. Only XNU implements this. It's not clear what ABI XNU is using but it's obviously not the one in the POSIX documentation link below. Since all platforms implement vfork, it might be better to empirically gauge the intersection of consensus which will have better performance than this interface. https://pubs.opengroup.org/onlinepubs/009696699/xrat/xsh_chap03.html	2021-01-29 01:24:54 -08:00
Justine Tunney	b2260c2278	Remove printfs accidentally in release :(	2021-01-29 00:07:53 -08:00