Cosmopolitan 0.2

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.

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [jart]

.vscode/c_cpp_properties.json

@@ -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
+}

.vscode/vscode.h

@@ -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 */

Makefile

@@ -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,13 +194,14 @@ 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
 
@@ -217,10 +211,10 @@ o/$(MODE)/.x:
 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)
+o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt $(SRCS) $(HDRS) $(INCS)
 	@build/mkdeps -o $@ -r o/$(MODE)/ o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
 
 TAGS:	o/$(MODE)/srcs.txt $(SRCS)
@@ -253,7 +247,6 @@ COSMOPOLITAN_OBJECTS =		\
 	APE_LIB			\
 	THIRD_PARTY_MUSL	\
 	LIBC_STDIO		\
-	LIBC_CALLS_HEFTY	\
 	THIRD_PARTY_REGEX	\
 	LIBC_ALG		\
 	LIBC_MEM		\
@@ -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

README.md

@@ -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
+wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-0.2.zip
+unzip cosmopolitan-amalgamated-0.2.zip
 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
+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
+```

ape/ape.lds

@@ -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);
@@ -220,33 +206,34 @@ SECTIONS {
     /* Executable & Linkable Format */
     . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 1);
     KEEP(*(.elf.phdrs))
-    HIDDEN(.Lape.phdrs.end = .);
+    HIDDEN(ape_phdrs_end = .);
     . += 1;
 
     /* OpenBSD */
     . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 1);
-    HIDDEN(.Lape.note = .);
+    HIDDEN(ape_note = .);
     KEEP(*(.note.openbsd.ident))
-    HIDDEN(.Lape.note.end = .);
+    KEEP(*(.note.netbsd.ident))
+    HIDDEN(ape_note_end = .);
     . += 1;
 
     /* 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 */
 
@@ -264,7 +251,7 @@ SECTIONS {
     *(.start)
     KEEP(*(.initprologue))
     KEEP(*(SORT_BY_NAME(.init.*)))
-    KEEP(*(SORT_NONE(.init)))
+    KEEP(*(.init))
     KEEP(*(.initepilogue))
     KEEP(*(.pltprologue))
     *(.plt)
@@ -288,44 +275,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 +306,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 +335,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 +358,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 +391,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 +433,94 @@ 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);
+HIDDEN(__privileged_addr = ROUNDDOWN(__privileged_start, PAGESIZE)); 
+HIDDEN(__privileged_size = (ROUNDUP(__privileged_end, PAGESIZE) -
+                            ROUNDDOWN(__privileged_start, PAGESIZE))); 
 
-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(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.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_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.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_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.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_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.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_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));
 
-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_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);
 
-/* Program Loader Auto-Tune */
+#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 +529,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 +543,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 +637,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__ */

ape/ape.mk

@@ -21,23 +21,26 @@ APE =	$(APE_DEPS)			\
 
 APELINK =				\
 	ACTION=LINK.ape 		\
-	$(MKDIR) $(@D) &&		\
+	$(COMPILE)			\
 	$(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

ape/idata.internal.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

ape/lib/apelib.mk

@@ -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)

ape/lib/bootdr.S

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

ape/lib/e820map.S

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

ape/lib/g_ptsp.S

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

ape/lib/kbiosdataarea.S

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

ape/lib/pageunmap.c

@@ -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");
 }

ape/lib/pc.h

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

ape/macros.internal.h

@@ -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)); \

build/archive

@@ -15,28 +15,28 @@
 #   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
+if [ -x "o//tool/build/ar.com" ]; then
+  set -- "o//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
-set -- o/build/bootstrap/ar.com "$@"
-# fi
 OUT=$3
 
 printf "$LOGFMT" "${ACTION:-ARCHIVE.a}" "$OUT" >&2
-# if [ "$SILENT" = "0" ]; then
+# if [ "$V" = "0" ]; then
+#   printf "$LOGFMT" "${ACTION:-ARCHIVE.a}" "$OUT" >&2
+# else
 #   # 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

build/assemble

@@ -23,13 +23,12 @@ 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
+if [ "$V" = "0" ]; then
   printf "$LOGFMT" "${ACTION:-OBJECTIFY.s}" "$TARGET" >&2
+else
+  printf "%s\n" "$*" >&2
 fi
 
 if [ "$TARGET" ]; then

build/compile

@@ -33,10 +33,11 @@ if [ "$1" = "clang++-10" ]; then
   fi
 fi
 
-export LC_ALL=C
 MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit
 
 GZME=
+ASAN=
+UBSAN=
 PLAT="${1%% *}"
 FDIAGNOSTIC_COLOR=
 CCNAME=${CCNAME:-gcc}
@@ -86,9 +87,22 @@ for x; do
     -mno-vzeroupper)
       set -- "$@" "$x" -Wa,-msse2avx -D__MNO_VZEROUPPER__
       ;;
+    -fsanitize=address)
+      ASAN="$x -D__FSANITIZE_ADDRESS__"
+      ;;
     -fsanitize=undefined)
-      set -- "$@" "$x" -D__FSANITIZE_UNDEFINED__
-      COUNTERMAND="$COUNTERMAND -fno-data-sections"  # sqlite.o
+      # UBSAN w/ -fdata-sections exceeds ELF's 65,280 section limit
+      UBSAN="$x -fno-data-sections"
+      ;;
+    -fno-sanitize=address)
+      ASAN=
+      ;;
+    -fno-sanitize=ubsan)
+      UBSAN=
+      ;;
+    -fno-sanitize=all)
+      ASAN=
+      UBSAN=
       ;;
     -mnop-mcount)
       if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 6 ]; then
@@ -253,12 +267,12 @@ else
   done
 fi
 
-set -- "$@" -no-canonical-prefixes $FDIAGNOSTIC_COLOR $COUNTERMAND
+set -- "$@" -no-canonical-prefixes $FDIAGNOSTIC_COLOR $ASAN $UBSAN $COUNTERMAND
 
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
+if [ "$V" = "0" ]; then
   printf "$LOGFMT" "${ACTION:-COMPILE}" "${TARGET:-$OUT}" >&2
+else
+  printf "%s\n" "$*" >&2
 fi
 
 OUTDIR="${OUT%/*}"

build/config.mk

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

build/definitions.mk

@@ -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,6 +42,10 @@
 #     ASFLAGS      assembler flags (don't use -Wa, frontend prefix)
 #     TARGET_ARCH  microarchitecture flags (e.g. -march=native)
 
+V ?= 1
+LC_ALL = C.UTF-8
+SOURCE_DATE_EPOCH = 0
+
 DD ?= /bin/dd
 CP ?= /bin/cp -f
 RM ?= /bin/rm -f
@@ -49,7 +53,6 @@ SED ?= /bin/sed
 MKDIR ?= /bin/mkdir -p
 TAGS ?= /usr/bin/ctags  # emacs source builds or something breaks it
 ARFLAGS = rcsD
-SILENT ?= 1
 ZFLAGS ?=
 XARGS ?= xargs -P4 -rs8000
 NICE ?= build/actuallynice
@@ -77,41 +80,58 @@ PWD := $(shell pwd)
 IMAGE_BASE_VIRTUAL ?= 0x400000
 TMPDIR := $(shell build/findtmp)
 LOGFMT := $(shell build/getlogfmt)
+COMPILE := $(shell build/getcompile)
 CCNAME := $(shell build/getccname $(CC))
 CCVERSION := $(shell build/getccversion $(CC))
 BLAH1 := $(shell build/zipobj 2>/dev/null)
 BLAH2 := $(shell build/package 2>/dev/null)
 
 export ADDR2LINE
-export OBJDUMP
 export CCNAME
 export CCVERSION
+export COMPILE
 export CP
 export DD
 export GZ
 export IMAGE_BASE_VIRTUAL
+export LC_ALL
 export LOGFMT
 export MKDIR
 export MODE
+export OBJDUMP
 export RM
 export SED
-export SILENT
+export SOURCE_DATE_EPOCH
 export TMPDIR
+export V
 export ZFLAGS
 
+unexport COMPILER_PATH
+unexport CPATH
+unexport CPLUS_INCLUDE_PATH
+unexport C_INCLUDE_PATH
+unexport DEPENDENCIES_OUTPUT
+unexport GCC_COMPARE_DEBUG
+unexport GCC_EXEC_PREFIX
+unexport LANG
+unexport LC_CTYPE
+unexport LC_MESSAGES
+unexport LIBRARY_PATH
+unexport OBJC_INCLUDE_PATH
+unexport SUNPRO_DEPENDENCIES
+
 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 +173,7 @@ MATHEMATICAL =								\
 DEFAULT_CPPFLAGS =							\
 	-DIMAGE_BASE_VIRTUAL=$(IMAGE_BASE_VIRTUAL)			\
 	-nostdinc							\
-	-iquote -							\
-	-iquote .
+	-iquote.
 
 DEFAULT_CFLAGS =							\
 	-std=gnu2x
@@ -178,17 +197,15 @@ DEFAULT_LDFLAGS =							\
 	-static								\
 	-nostdlib							\
 	-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)"=
 
@@ -294,7 +311,7 @@ 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)

build/do

@@ -46,10 +46,10 @@ if [ "$OUT" ]; then
 fi
 
 # Log command.
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
+if [ "$V" = "0" ]; then
   printf "$LOGFMT" "${ACTION:-BUILD}" "$TARGET" >&2
+else
+  printf "%s\n" "$*" >&2
 fi
 
 exec "$@"

build/findtmp

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

build/getcompile

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

build/getlogfmt

@@ -11,23 +11,19 @@
 #   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
+W1=15
+if [ "$TERM" = "dumb" ]; then
+  if [ "$COLUMNS" = "" ]; then
+    if TPUT=$(command -v tput); then
+      COLUMNS=$("$TPUT" cols)
+    else
+      COLUMNS=80
     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
+  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

build/link

@@ -19,7 +19,6 @@ 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=
@@ -41,10 +40,10 @@ for x; do
   set -- "$@" "$x"
 done
 
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
+if [ "$V" = "0" ]; then
   printf "$LOGFMT" "${ACTION:-LINK.elf}" "$OUT" >&2
+else
+  printf "%s\n" "$*" >&2
 fi
 
 OUTDIR="${OUT%/*}"

build/mkdeps

@@ -13,10 +13,10 @@ else
   set -- o/build/bootstrap/mkdeps.com "$@"
 fi
 
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
+if [ "$V" = "0" ]; then
   printf "$LOGFMT" "${ACTION:-MKDEPS}" "$3" >&2
+else
+  printf "%s\n" "$*" >&2
 fi
 
 exec "$@"

build/package

@@ -20,14 +20,14 @@ else
 fi
 
 printf "$LOGFMT" "${ACTION:-PACKAGE}" "$3" >&2
-# if [ "$SILENT" = "0" ]; then
+# if [ "$V" = "0" ]; then
+#   printf "$LOGFMT" "${ACTION:-PACKAGE}" "$3" >&2
+# else
 #   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 "$@"

build/rules.mk

@@ -17,72 +17,72 @@
 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/%.o: %.s; @TARGET=$@ $(COMPILE) $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/%.o: o/%.s; @TARGET=$@ $(COMPILE) $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/%.s: %.S; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/%.s: o/%.S; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/%.i: %.S; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/%.o: %.S; @ACTION=OBJECTIFY.S $(COMPILE) $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/%.o: o/%.S; @ACTION=OBJECTIFY.S $(COMPILE) $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/%.s: %.i; @ACTION=COMPILE.i $(COMPILE) $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/%.s: o/%.i; @ACTION=COMPILE.i $(COMPILE) $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/%.o: %.cc; @ACTION=OBJECTIFY.cxx $(COMPILE) $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/%.o: o/%.cc; @ACTION=OBJECTIFY.cxx $(COMPILE) $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/%.lds: %.lds; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
+o/%.inc: %.h; @ACTION=PREPROCESS $(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/%.h.ok: %.h; @ACTION=CHECK.h $(COMPILE) $(COMPILE.c) -x c -g0 -o $@ $<
+o/%.h.okk: %.h; @ACTION=CHECK.h $(COMPILE) $(COMPILE.cxx) -x c++ -g0 -o $@ $<
+o/%.greg.o: %.greg.c; @ACTION=OBJECTIFY.greg $(COMPILE) $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
 o/%.zip.o: o/%; @build/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)/%: o/$(MODE)/%.dbg; @ACTION=OBJCOPY TARGET=$@ $(COMPILE) $(OBJCOPY) -S -O binary $< $@
+o/$(MODE)/%.o: %.s; @TARGET=$@ $(COMPILE) $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.s; @TARGET=$@ $(COMPILE) $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: %.S; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: o/$(MODE)/%.S; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.c; @ACTION=OBJECTIFY.c $(COMPILE) $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.f; @ACTION=OBJECTIFY.f $(COMPILE) $(OBJECTIFY.f) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.F; @ACTION=OBJECTIFY.F $(COMPILE) $(OBJECTIFY.F) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.c; @ACTION=OBJECTIFY.c $(COMPILE) $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ss: %.c; @ACTION=COMPILE.c $(COMPILE) $(COMPILE.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ss: o/$(MODE)/%.c; @ACTION=OBJECTIFY.s $(COMPILE) $(COMPILE.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.S; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.c; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.cc; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: o/$(MODE)/%.c; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.h: %.c; @ACTION=AMALGAMATE $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
+o/$(MODE)/%.h: o/$(MODE)/%.c; @ACTION=AMALGAMATE $(COMPILE) $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
+o/$(MODE)/%.o: %.S; @ACTION=OBJECTIFY.S $(COMPILE) $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.S; @ACTION=OBJECTIFY.S $(COMPILE) $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: %.i; @ACTION=COMPILE.i $(COMPILE) $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: o/$(MODE)/%.i; @ACTION=COMPILE.i $(COMPILE) $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.cc; @ACTION=OBJECTIFY.cxx $(COMPILE) $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.cc; @ACTION=OBJECTIFY.cxx $(COMPILE) $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.lds: %.lds; @ACTION=PREPROCESS $(COMPILE) $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.h.ok: %.h; @ACTION=CHECK.h $(COMPILE) $(COMPILE.c) -x c -g0 -o $@ $<
+o/$(MODE)/%.h.okk: %.h; @ACTION=CHECK.h $(COMPILE) $(COMPILE.cxx) -x c++ -g0 -o $@ $<
+o/$(MODE)/%.o: %.greg.c; @ACTION=OBJECTIFY.greg $(COMPILE) $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.greg.o: %.greg.c; @ACTION=OBJECTIFY.greg $(COMPILE) $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ansi.o: %.ansi.c; @ACTION=OBJECTIFY.ansi $(COMPILE) $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ansi.o: %.c; @ACTION=OBJECTIFY.ansi $(COMPILE) $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c99.o: %.c99.c; @ACTION=OBJECTIFY.c99 $(COMPILE) $(OBJECTIFY.c99.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c11.o: %.c11.c; @ACTION=OBJECTIFY.c11 $(COMPILE) $(OBJECTIFY.c11.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c2x.o: %.c2x.c; @ACTION=OBJECTIFY.c2x $(COMPILE) $(OBJECTIFY.c2x.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.initabi.o: %.initabi.c; @ACTION=OBJECTIFY.init $(COMPILE) $(OBJECTIFY.initabi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ncabi.o: %.ncabi.c; @ACTION=OBJECTIFY.nc $(COMPILE) $(OBJECTIFY.ncabi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.real.o: %.c; @ACTION=OBJECTIFY.real $(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)/%-gcc.asm: %.c; @ACTION=OBJECTIFY.c build/compile $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
+o/$(MODE)/%-gcc.asm: %.c; @ACTION=OBJECTIFY.c $(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: %.c; @ACTION=OBJECTIFY.c $(COMPILE) $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@
+o/$(MODE)/%-gcc.asm: %.f; @ACTION=OBJECTIFY.f $(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: %.f; @ACTION=OBJECTIFY.f $(COMPILE) $(OBJECTIFY.f) -S -g0 $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@
+o/$(MODE)/%-gcc.asm: %.F; @ACTION=OBJECTIFY.F $(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)/%-clang.asm: %.F; @ACTION=OBJECTIFY.F $(COMPILE) $(OBJECTIFY.F) -S -g0 $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@

build/runcom

@@ -6,5 +6,6 @@ DD=${DD:-$(command -v dd)} || exit
 $DD if="$1" of="$1.bak" bs=4096 count=1 conv=notrunc 2>/dev/null
 "$@"
 rc=$?
+echo "$1"
 $DD if="$1.bak" of="$1" bs=4096 count=1 conv=notrunc 2>/dev/null
 exit $rc

build/zipobj

@@ -42,10 +42,10 @@ else
   set -- o/build/bootstrap/zipobj.com "$@"
 fi
 
-if [ "$SILENT" = "0" ]; then
-  printf "%s\n" "$*" >&2
-else
+if [ "$V" = "0" ]; then
   printf "$LOGFMT" "${ACTION:-ZIPOBJ}" "$3" >&2
+else
+  printf "%s\n" "$*" >&2
 fi
 
 exec "$@"

dsp/core/core.mk

@@ -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))

dsp/core/half.h

@@ -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_ */

dsp/core/mulaw.S

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

dsp/core/sad16x8n.S

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

dsp/scale/scale.mk

@@ -30,6 +30,7 @@ DSP_SCALE_A_DIRECTDEPS =			\
 	LIBC_MEM				\
 	LIBC_NEXGEN32E				\
 	LIBC_RUNTIME				\
+	LIBC_STR				\
 	LIBC_STUBS				\
 	LIBC_STUBS				\
 	LIBC_TIME				\

dsp/tty/hidecursor.c

@@ -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);

dsp/tty/mpsadbw.S

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/macros.h"
 
-/	TODO(jart): write me
+//	TODO(jart): write me
 
 	movdqa	a,%xmm0
 	mpsadbw $0,inv,%xmm0

dsp/tty/quant.h

@@ -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;

dsp/tty/tty.mk

@@ -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))

dsp/tty/windex-avx2.S

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

dsp/tty/windex-k8.c

@@ -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];

dsp/tty/windex-sse4.S

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

dsp/tty/windex.S

@@ -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 */

examples/cp.c

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

examples/cplusplus.cc

@@ -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;
 }

examples/crashreport.c

@@ -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;
 }

examples/examples.mk

@@ -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,9 @@ EXAMPLES_DIRECTDEPS =						\
 	LIBC_ALG						\
 	LIBC_BITS						\
 	LIBC_CALLS						\
-	LIBC_CALLS_HEFTY					\
 	LIBC_FMT						\
 	LIBC_INTRIN						\
 	LIBC_LOG						\
-	LIBC_LOG_ASAN						\
 	LIBC_MEM						\
 	LIBC_NEXGEN32E						\
 	LIBC_NT_KERNEL32					\
@@ -100,21 +94,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,6 +125,8 @@ o/$(MODE)/examples/nesemu1.com.dbg:				\
 		$(APE)
 	@$(APELINK)
 
+$(EXAMPLES_OBJS): examples/examples.mk
+
 usr/share/dict/words: usr/share/dict/words.gz
 	@$(MKDIR) $(dir $@)
 	@$(GZ) $(ZFLAGS) -d <$< >$@

examples/kilo.c

@@ -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);

examples/nesemu1.cc

@@ -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]);

examples/package/build.mk

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

examples/package/lib/build.mk

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

examples/package/lib/myasm.S

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

examples/printargs.c

@@ -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);

examples/seq.c

@@ -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);
+  }
+}

examples/tiny-raw-linux-tutorial.S

@@ -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__

examples/x86split.c

@@ -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);

libc/alg/alg.mk

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

libc/alg/arraylist.internal.h

@@ -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_ */

libc/alg/arraylist2.internal.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) */

libc/alg/reverse.h

@@ -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_ */

libc/alg/shuffle.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_ */

libc/bits/atomic_load.c

@@ -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;
+  }
+}

libc/bits/atomic_store.c

@@ -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;
+  }
+}

libc/bits/bits.h

@@ -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_ */

libc/bits/cmpxchg.c

@@ -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;
+  }
+}

libc/bits/emmintrin.internal.h

@@ -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))

libc/bits/initializer.internal.h

@@ -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_ */

libc/bits/likely.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_ */

libc/bits/lockcmpxchg.c

@@ -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;
+  }
+}

libc/bits/lockxchg.c

@@ -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;
+  }
+}

libc/bits/progn.internal.h

@@ -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_ */

libc/bits/safemacros.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_ */

libc/bits/segmentation.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_ */

libc/bits/xmmintrin.internal.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

libc/calls/access.c

@@ -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);
 }

libc/calls/calls.h

@@ -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)

libc/calls/calls.mk

@@ -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)

libc/calls/chdir-nt.c

@@ -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;
 }

libc/calls/chdir.c

@@ -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);
   }
 }

libc/calls/chmod.c

@@ -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);
 }

libc/calls/chown.c

@@ -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);
 }

libc/calls/clock_gettime.c

@@ -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;
   }
 }

libc/calls/close-nt.c

@@ -17,21 +17,24 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
+#include "libc/nt/enum/filetype.h"
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
 #include "libc/sysv/errfuns.h"
 
-textwindows int close$nt(int fd) {
+textwindows int sys_close_nt(struct Fd *fd) {
   bool32 ok;
-  if (g_fds.p[fd].kind == kFdFile) {
+  if (fd->kind == kFdFile && GetFileType(fd->handle) == kNtFileTypeDisk) {
     /*
      * Like Linux, closing a file on Windows doesn't guarantee it's
      * immediately synced to disk. But unlike Linux, this could cause
      * subsequent operations, e.g. unlink() to break w/ access error.
      */
-    FlushFileBuffers(g_fds.p[fd].handle);
+    FlushFileBuffers(fd->handle);
+  }
+  ok = CloseHandle(fd->handle);
+  if (fd->kind == kFdConsole) {
+    ok &= CloseHandle(fd->extra);
   }
-  ok = CloseHandle(g_fds.p[fd].handle);
-  if (g_fds.p[fd].kind == kFdConsole) ok &= CloseHandle(g_fds.p[fd].extra);
   return ok ? 0 : __winerr();
 }

libc/calls/close.c

@@ -39,22 +39,23 @@ int close(int fd) {
   if (fd < 0) return einval();
   if (fd < g_fds.n && g_fds.p[fd].kind == kFdZip) {
     rc = weaken(__zipos_close)(fd);
-  } else if (fd < g_fds.n && g_fds.p[fd].kind == kFdEpoll) {
-    rc = weaken(close$epoll)(fd);
-  } else if (!IsWindows()) {
-    rc = close$sysv(fd);
-  } else if (fd < g_fds.n && g_fds.p[fd].kind == kFdSocket) {
-    rc = weaken(closesocket$nt)(fd);
-  } else if (fd < g_fds.n &&
-             (g_fds.p[fd].kind == kFdFile || g_fds.p[fd].kind == kFdConsole ||
-              g_fds.p[fd].kind == kFdProcess)) {
-    rc = close$nt(fd);
   } else {
-    rc = ebadf();
-  }
-  if (!__vforked && fd < g_fds.n) {
-    g_fds.p[fd].kind = kFdEmpty;
-    g_fds.f = MIN(g_fds.f, fd);
+    if (!IsWindows()) {
+      rc = sys_close(fd);
+    } else {
+      if (fd < g_fds.n && g_fds.p[fd].kind == kFdEpoll) {
+        rc = weaken(sys_close_epoll_nt)(fd);
+      } else if (fd < g_fds.n && g_fds.p[fd].kind == kFdSocket) {
+        rc = weaken(sys_closesocket_nt)(g_fds.p + fd);
+      } else if (fd < g_fds.n && (g_fds.p[fd].kind == kFdFile ||
+                                  g_fds.p[fd].kind == kFdConsole ||
+                                  g_fds.p[fd].kind == kFdProcess)) {
+        rc = sys_close_nt(g_fds.p + fd);
+      } else {
+        rc = ebadf();
+      }
+    }
   }
+  __releasefd(fd);
   return rc;
 }

libc/calls/commandv.c

@@ -16,7 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/bits/progn.internal.h"
 #include "libc/bits/safemacros.h"
 #include "libc/calls/calls.h"
 #include "libc/runtime/runtime.h"
@@ -27,7 +26,9 @@ static bool AccessCommand(char path[hasatleast PATH_MAX], const char *name,
                           size_t namelen, size_t pathlen) {
   if (pathlen + 1 + namelen + 1 + 4 + 1 > PATH_MAX) return -1;
   if (pathlen && (path[pathlen - 1] != '/' && path[pathlen - 1] != '\\')) {
-    path[pathlen++] = '/';
+    path[pathlen] =
+        !IsWindows() ? '/' : memchr(path, '\\', pathlen) ? '\\' : '/';
+    pathlen++;
   }
   memcpy(path + pathlen, name, namelen + 1);
   if (isexecutable(path)) return true;
@@ -43,15 +44,18 @@ static bool SearchPath(char path[hasatleast PATH_MAX], const char *name,
   size_t i;
   const char *p;
   p = firstnonnull(emptytonull(getenv("PATH")), "/bin:/usr/local/bin:/usr/bin");
-  for (;; p += i) {
-    while (*p == ':' || *p == ';') ++p;
-    if (!*p) break;
-    for (i = 0; i < PATH_MAX && p[i] && p[i] != ':' && p[i] != ';'; ++i) {
-      path[i] = p[i];
+  for (;;) {
+    for (i = 0; p[i] && p[i] != ':' && p[i] != ';'; ++i) {
+      if (i < PATH_MAX) path[i] = p[i];
     }
     if (AccessCommand(path, name, namelen, i)) {
       return true;
     }
+    if (p[i] == ':' || p[i] == ';') {
+      p += i + 1;
+    } else {
+      break;
+    }
   }
   return false;
 }
@@ -69,11 +73,20 @@ char *commandv(const char *name, char pathbuf[hasatleast PATH_MAX]) {
   char *p;
   size_t namelen;
   int rc, olderr;
-  if (!(namelen = strlen(name))) return PROGN(enoent(), NULL);
-  if (namelen + 1 > PATH_MAX) return PROGN(enametoolong(), NULL);
-  if (name[0] == '/' || name[0] == '\\') {
-    memcpy(pathbuf, name, namelen + 1);
-    return pathbuf;
+  if (!(namelen = strlen(name))) {
+    enoent();
+    return NULL;
+  }
+  if (namelen + 1 > PATH_MAX) {
+    enametoolong();
+    return NULL;
+  }
+  if (strchr(name, '/') || strchr(name, '\\')) {
+    if (AccessCommand(strcpy(pathbuf, ""), name, namelen, 0)) {
+      return pathbuf;
+    } else {
+      return NULL;
+    }
   }
   olderr = errno;
   if ((IsWindows() &&
@@ -81,7 +94,6 @@ char *commandv(const char *name, char pathbuf[hasatleast PATH_MAX]) {
                       stpcpy(pathbuf, kNtSystemDirectory) - pathbuf) ||
         AccessCommand(pathbuf, name, namelen,
                       stpcpy(pathbuf, kNtWindowsDirectory) - pathbuf))) ||
-      AccessCommand(strcpy(pathbuf, ""), name, namelen, 0) ||
       SearchPath(pathbuf, name, namelen)) {
     errno = olderr;
     return pathbuf;

libc/calls/copyfile.c

@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/hefty/copyfile.h"
+#include "libc/calls/copyfile.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/dce.h"
@@ -32,7 +32,7 @@
 #include "libc/sysv/consts/o.h"
 #include "libc/time/time.h"
 
-static textwindows int copyfile$nt(const char *src, const char *dst,
+static textwindows int sys_copyfile_nt(const char *src, const char *dst,
                                    int flags) {
   int64_t fhsrc, fhdst;
   struct NtFileTime accessed, modified;
@@ -58,7 +58,7 @@ static textwindows int copyfile$nt(const char *src, const char *dst,
   }
 }
 
-static int copyfile$sysv(const char *src, const char *dst, int flags) {
+static int sys_copyfile(const char *src, const char *dst, int flags) {
   struct stat st;
   size_t remaining;
   ssize_t transferred;
@@ -66,12 +66,12 @@ static int copyfile$sysv(const char *src, const char *dst, int flags) {
   int64_t inoffset, outoffset;
   int rc, srcfd, dstfd, oflags, omode;
   rc = -1;
-  if ((srcfd = openat$sysv(AT_FDCWD, src, O_RDONLY, 0)) != -1) {
-    if (fstat$sysv(srcfd, &st) != -1) {
+  if ((srcfd = sys_openat(AT_FDCWD, src, O_RDONLY, 0)) != -1) {
+    if (sys_fstat(srcfd, &st) != -1) {
       omode = st.st_mode & 0777;
       oflags = O_WRONLY | O_CREAT;
       if (flags & COPYFILE_NOCLOBBER) oflags |= O_EXCL;
-      if ((dstfd = openat$sysv(AT_FDCWD, dst, oflags, omode)) != -1) {
+      if ((dstfd = sys_openat(AT_FDCWD, dst, oflags, omode)) != -1) {
         remaining = st.st_size;
         ftruncate(dstfd, remaining);
         inoffset = 0;
@@ -86,13 +86,13 @@ static int copyfile$sysv(const char *src, const char *dst, int flags) {
           if (flags & COPYFILE_PRESERVE_TIMESTAMPS) {
             amtime[0] = st.st_atim;
             amtime[1] = st.st_mtim;
-            utimensat$sysv(dstfd, NULL, amtime, 0);
+            sys_utimensat(dstfd, NULL, amtime, 0);
           }
         }
-        rc |= close$sysv(dstfd);
+        rc |= sys_close(dstfd);
       }
     }
-    rc |= close$sysv(srcfd);
+    rc |= sys_close(srcfd);
   }
   return rc;
 }
@@ -102,8 +102,8 @@ static int copyfile$sysv(const char *src, const char *dst, int flags) {
  */
 int copyfile(const char *src, const char *dst, int flags) {
   if (!IsWindows()) {
-    return copyfile$sysv(src, dst, flags);
+    return sys_copyfile(src, dst, flags);
   } else {
-    return copyfile$nt(src, dst, flags);
+    return sys_copyfile_nt(src, dst, flags);
   }
 }

libc/calls/copyfile.h

@@ -0,0 +1,15 @@
+#ifndef COSMOPOLITAN_LIBC_CALLS_COPYFILE_H_
+#define COSMOPOLITAN_LIBC_CALLS_COPYFILE_H_
+
+#define COPYFILE_NOCLOBBER           1
+#define COPYFILE_PRESERVE_OWNER      2
+#define COPYFILE_PRESERVE_TIMESTAMPS 4
+
+#if !(__ASSEMBLER__ + __LINKER__ + 0)
+COSMOPOLITAN_C_START_
+
+int copyfile(const char *, const char *, int) paramsnonnull();
+
+COSMOPOLITAN_C_END_
+#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+#endif /* COSMOPOLITAN_LIBC_CALLS_COPYFILE_H_ */

libc/calls/creat.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/sysv/consts/at.h"
 #include "libc/sysv/consts/o.h"
 
 /**
@@ -35,5 +36,5 @@
  * @asyncsignalsafe
  */
 nodiscard int creat(const char *file, uint32_t mode) {
-  return open(file, O_CREAT | O_WRONLY | O_TRUNC, mode);
+  return openat(AT_FDCWD, file, O_CREAT | O_WRONLY | O_TRUNC, mode);
 }

libc/calls/dup-nt.c

@@ -28,19 +28,20 @@
 /**
  * Implements dup(), dup2(), and dup3() for Windows NT.
  */
-textwindows int dup$nt(int oldfd, int newfd, int flags) {
+textwindows int sys_dup_nt(int oldfd, int newfd, int flags) {
   int64_t proc;
-  if (!__isfdkind(oldfd, kFdFile)) return ebadf();
+  if (oldfd < 0) return einval();
+  if (oldfd >= g_fds.n ||
+      (g_fds.p[oldfd].kind != kFdFile && g_fds.p[oldfd].kind != kFdSocket &&
+       g_fds.p[oldfd].kind != kFdConsole)) {
+    return ebadf();
+  }
   if (newfd == -1) {
-    if ((newfd = __getemptyfd()) == -1) {
-      return -1;
-    }
-  } else if (__ensurefds(newfd) != -1) {
-    if (g_fds.p[newfd].kind != kFdEmpty) {
-      close(newfd);
-    }
+    if ((newfd = __reservefd()) == -1) return -1;
   } else {
-    return -1;
+    if (__ensurefds(newfd) == -1) return -1;
+    if (g_fds.p[newfd].kind) close(newfd);
+    g_fds.p[newfd].kind = kFdReserved;
   }
   proc = GetCurrentProcess();
   if (DuplicateHandle(proc, g_fds.p[oldfd].handle, proc, &g_fds.p[newfd].handle,
@@ -49,6 +50,7 @@ textwindows int dup$nt(int oldfd, int newfd, int flags) {
     g_fds.p[newfd].flags = flags;
     return newfd;
   } else {
+    __releasefd(newfd);
     return __winerr();
   }
 }

libc/calls/dup.c

@@ -30,8 +30,8 @@
  */
 nodiscard int dup(int fd) {
   if (!IsWindows()) {
-    return dup$sysv(fd);
+    return sys_dup(fd);
   } else {
-    return dup$nt(fd, -1, 0);
+    return sys_dup_nt(fd, -1, 0);
   }
 }

libc/calls/dup2.c

@@ -33,8 +33,8 @@
 int dup2(int oldfd, int newfd) {
   if (oldfd == newfd) return newfd;
   if (!IsWindows()) {
-    return dup3$sysv(oldfd, newfd, 0);
+    return sys_dup3(oldfd, newfd, 0);
   } else {
-    return dup$nt(oldfd, newfd, 0);
+    return sys_dup_nt(oldfd, newfd, 0);
   }
 }

libc/calls/dup3-sysv.c

@@ -21,21 +21,22 @@
 
 #define __NR_dup3_linux 0x0124 /*RHEL5:CVE-2010-3301*/
 
-int32_t dup3$sysv(int32_t oldfd, int32_t newfd, int flags) {
+int32_t sys_dup3(int32_t oldfd, int32_t newfd, int flags) {
   static bool once, demodernize;
   int olderr, fd;
   if (!once) {
-    once = true;
     olderr = errno;
-    fd = __dup3$sysv(oldfd, newfd, flags);
+    fd = __sys_dup3(oldfd, newfd, flags);
     if ((fd == -1 && errno == ENOSYS) || fd == __NR_dup3_linux) {
       demodernize = true;
+      once = true;
       errno = olderr;
     } else {
+      once = true;
       return fd;
     }
   } else if (!demodernize) {
-    return __dup3$sysv(oldfd, newfd, flags);
+    return __sys_dup3(oldfd, newfd, flags);
   }
-  return fixupnewfd$sysv(dup2$sysv(oldfd, newfd), flags);
+  return __fixupnewfd(sys_dup2(oldfd, newfd), flags);
 }

libc/calls/dup3.c

@@ -33,13 +33,11 @@
  *     unless it's equal to oldfd, in which case dup2() is a no-op
  * @flags can have O_CLOEXEC
  * @see dup(), dup2()
- * @syscall
  */
 int dup3(int oldfd, int newfd, int flags) {
-  if (oldfd == newfd) return einval();
   if (!IsWindows()) {
-    return dup3$sysv(oldfd, newfd, flags);
+    return sys_dup3(oldfd, newfd, flags);
   } else {
-    return dup$nt(oldfd, newfd, flags);
+    return sys_dup_nt(oldfd, newfd, flags);
   }
 }

libc/calls/ensurefds.c

@@ -0,0 +1,53 @@
+/*-*- 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 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/assert.h"
+#include "libc/bits/bits.h"
+#include "libc/bits/weaken.h"
+#include "libc/calls/internal.h"
+#include "libc/mem/mem.h"
+#include "libc/str/str.h"
+#include "libc/sysv/errfuns.h"
+
+int __ensurefds(int fd) {
+  size_t n1, n2;
+  struct Fd *p1, *p2;
+  for (;;) {
+    p1 = g_fds.p;
+    n1 = g_fds.n;
+    if (fd < n1) return fd;
+    if (weaken(malloc)) {
+      n2 = MAX(fd + 1, n1 + (n1 << 1));
+      if ((p2 = weaken(malloc)(n2 * sizeof(*p1)))) {
+        memcpy(p2, p1, n1 * sizeof(*p1));
+        memset(p2 + n1, 0, (n2 - n1) * sizeof(*p1));
+        if (p1 != g_fds.__init_p && weaken(free)) weaken(free)(p1);
+        if (cmpxchg(&g_fds.p, p1, p2)) {
+          g_fds.n = n2;
+          return fd;
+        } else if (weaken(free)) {
+          weaken(free)(p2);
+        }
+      } else {
+        return enomem();
+      }
+    } else {
+      return emfile();
+    }
+  }
+}

libc/calls/execve-nt.c

@@ -29,7 +29,7 @@
 #include "libc/str/str.h"
 #include "libc/sysv/consts/o.h"
 
-textwindows int execve$nt(const char *program, char *const argv[],
+textwindows int sys_execve_nt(const char *program, char *const argv[],
                           char *const envp[]) {
   int rc;
   size_t i;
@@ -47,11 +47,8 @@ textwindows int execve$nt(const char *program, char *const argv[],
       close(i);
     }
   }
-  for (i = 0; argv[i];) ++i;
-  i = (i + 1) * sizeof(char *);
-  argv = memcpy(alloca(i), argv, i);
-  memcpy(argv, &program, sizeof(program));
-  rc = ntspawn(argv, envp, NULL, NULL, true, 0, NULL, &startinfo, &procinfo);
+  rc = ntspawn(program, argv, envp, NULL, NULL, NULL, true, 0, NULL, &startinfo,
+               &procinfo);
   if (rc == -1) return -1;
   CloseHandle(procinfo.hThread);
   do {