Release Cosmopolitan v3.6.2

Our cosmocc binaries are now built with GCC 14.1, using the Cosmo commit
efb3a34608 from yesterday.

GCC is now configured using --enable-analyzer so you can use -fanalyzer.

.git-blame-ignore-revs

@@ -25,3 +25,5 @@ c0eacf2eb1e1c0b3bd4f71f12fef258f5b249c3f
 da8baf2aa5ce93b958aca90a0ae69f537806324b
 # Run clang-format on most sources
 369f9740de4534c28d0e81ab2afc99decbb9a3e6
+# Get rid of .internal.h convention in LIBC_INTRIN
+86d884cce24d773e298a2714c1e3d91ecab9be45

Makefile

@@ -101,19 +101,20 @@ XARGS ?= xargs -P4 -rs8000
 DOT ?= dot
 CLANG = clang
 TMPDIR = o/tmp
-AR = build/bootstrap/ar
-CP = build/bootstrap/cp
-RM = build/bootstrap/rm -f
-GZIP = build/bootstrap/gzip
-ECHO = build/bootstrap/echo
-CHMOD = build/bootstrap/chmod
-TOUCH = build/bootstrap/touch
-PKG = build/bootstrap/package
-MKDEPS = build/bootstrap/mkdeps
-ZIPOBJ = build/bootstrap/zipobj
-ZIPCOPY = build/bootstrap/zipcopy
-PECHECK = build/bootstrap/pecheck
-FIXUPOBJ = build/bootstrap/fixupobj
+AR = $(BOOTSTRAP)/ar.ape
+CP = $(BOOTSTRAP)/cp.ape
+RM = $(BOOTSTRAP)/rm.ape -f
+GZIP = $(BOOTSTRAP)/gzip.ape
+ECHO = $(BOOTSTRAP)/echo.ape
+CHMOD = $(BOOTSTRAP)/chmod.ape
+TOUCH = $(BOOTSTRAP)/touch.ape
+PKG = $(BOOTSTRAP)/package.ape
+MKDEPS = $(BOOTSTRAP)/mkdeps
+ZIPOBJ = $(BOOTSTRAP)/zipobj
+ZIPCOPY = $(BOOTSTRAP)/zipcopy
+PECHECK = $(BOOTSTRAP)/pecheck
+FIXUPOBJ = $(BOOTSTRAP)/fixupobj
+OBJBINCOPY = $(BOOTSTRAP)/objbincopy
 MKDIR = build/bootstrap/mkdir -p
 COMPILE = build/bootstrap/compile -V9 -M2048m -P8192 $(QUOTA)
 
@@ -149,9 +150,10 @@ export MODE
 export SOURCE_DATE_EPOCH
 export TMPDIR
 
-COSMOCC = .cosmocc/3.3.5
+COSMOCC = .cosmocc/3.6.0
+BOOTSTRAP = $(COSMOCC)/bin
 TOOLCHAIN = $(COSMOCC)/bin/$(ARCH)-linux-cosmo-
-DOWNLOAD := $(shell build/download-cosmocc.sh $(COSMOCC) 3.3.5 db78fd8d3f8706e9dff4be72bf71d37a3f12062f212f407e1c33bc4af3780dd0)
+DOWNLOAD := $(shell build/download-cosmocc.sh $(COSMOCC) 3.6.0 4918c45ac3e0972ff260e2a249e25716881e39fb679d5e714ae216a2ef6c3f7e)
 
 AS = $(TOOLCHAIN)as
 CC = $(TOOLCHAIN)gcc
@@ -291,8 +293,7 @@ include third_party/openmp/BUILD.mk		# │
 include third_party/pcre/BUILD.mk		# │
 include third_party/less/BUILD.mk		# │
 include net/https/BUILD.mk			# │
-include third_party/regex/BUILD.mk		# │
-include third_party/bash/BUILD.mk		#─┘
+include third_party/regex/BUILD.mk		#─┘
 include third_party/tidy/BUILD.mk
 include third_party/BUILD.mk
 include third_party/nsync/testing/BUILD.mk
@@ -434,6 +435,9 @@ loc: o/$(MODE)/tool/build/summy
 # PLEASE: MAINTAIN TOPOLOGICAL ORDER
 # FROM HIGHEST LEVEL TO LOWEST LEVEL
 COSMOPOLITAN_OBJECTS =			\
+	CTL				\
+	THIRD_PARTY_DOUBLECONVERSION	\
+	THIRD_PARTY_OPENMP		\
 	TOOL_ARGS			\
 	NET_HTTP			\
 	LIBC_SOCK			\
@@ -443,7 +447,6 @@ COSMOPOLITAN_OBJECTS =			\
 	THIRD_PARTY_GETOPT		\
 	LIBC_LOG			\
 	THIRD_PARTY_TZ			\
-	THIRD_PARTY_OPENMP		\
 	THIRD_PARTY_MUSL		\
 	THIRD_PARTY_ZLIB_GZ		\
 	THIRD_PARTY_LIBCXXABI		\
@@ -454,7 +457,6 @@ COSMOPOLITAN_OBJECTS =			\
 	LIBC_THREAD			\
 	LIBC_PROC			\
 	THIRD_PARTY_NSYNC_MEM		\
-	CTL				\
 	LIBC_MEM			\
 	THIRD_PARTY_DLMALLOC		\
 	LIBC_DLOPEN			\

README.md

@@ -244,7 +244,7 @@ server. You're welcome to join us! <https://discord.gg/FwAVVu7eJ4>
 
 | Platform       | Min Version | Circa |
 | :---           | ---:        | ---:  |
-| AMD            | K8 Venus    | 2005  |
+| AMD            | K8          | 2003  |
 | Intel          | Core        | 2006  |
 | Linux          | 2.6.18      | 2007  |
 | Windows        | 8 [1]       | 2012  |

ape/BUILD.mk

@@ -218,10 +218,10 @@ o/$(MODE)/ape/loader-xnu-clang.asm: ape/loader.c
 	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
 
 o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
-	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy -f -o $@ $<
+	@$(COMPILE) -AOBJBINCOPY -w $(OBJBINCOPY) -f -o $@ $<
 
 o/$(MODE)/ape/ape.macho: o/$(MODE)/ape/ape.elf.dbg
-	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy -fm -o $@ $<
+	@$(COMPILE) -AOBJBINCOPY -w $(OBJBINCOPY) -fm -o $@ $<
 
 APE_LOADER_LDFLAGS =				\
 	-static					\

ape/specification.md

@@ -0,0 +1,703 @@
+# Actually Portable Executable Specification v0.1
+
+Actually Portable Executable (APE) is an executable file format that
+polyglots the Windows Portable Executable (PE) format with a UNIX Sixth
+Edition style shell script that doesn't have a shebang. This makes it
+possible to produce a single file binary that executes on the stock
+installations of the many OSes and architectures.
+
+## Supported OSes and Architectures
+
+- AMD64
+  - Linux
+  - MacOS
+  - Windows
+  - FreeBSD
+  - OpenBSD
+  - NetBSD
+  - BIOS
+
+- ARM64
+  - Linux
+  - MacOS
+  - FreeBSD
+  - Windows (non-native)
+
+## File Header
+
+APE defines three separate file magics, all of which are 8 characters
+long. Any file that starts with one of these magic values can be
+considered an APE program.
+
+### (1) APE MZ Magic
+
+- ASCII: `MZqFpD='`
+- Hex: 4d 5a 71 46 70 44 3d 27
+
+This is the canonical magic used by almost all APE programs. It enables
+maximum portability between OSes. When interpreted as a shell script, it
+is assigning a single quoted string to an unused variable. The shell
+will then ignore subsequent binary content that's placed inside the
+string.
+
+It is strongly recommended that this magic value be immediately followed
+by a newline (\n or hex 0a) character. Some shells, e.g. FreeBSD SH and
+Zsh impose a binary safety check before handing off files that don't
+have a shebang to `/bin/sh`. That check applies to the first line, which
+can't contain NUL characters.
+
+The letters were carefully chosen so as to be valid x86 instructions in
+all operating modes. This makes it possible to store a BIOS bootloader
+disk image inside an APE binary. For example, simple CLI programs built
+with Cosmopolitan Libc will boot from BIOS into long mode if they're
+treated as a floppy disk image.
+
+The letters also allow for the possibility of being treated on x86-64 as
+a flat executable, where the PE / ELF / Mach-O executable structures are
+ignored, and execution simply begins at the beginning of the file,
+similar to how MS-DOS .COM binaries work.
+
+The 0x4a relative offset of the magic causes execution to jump into the
+MS-DOS stub defined by Portable Executable. APE binaries built by Cosmo
+Libc use tricks in the MS-DOS stub to check the operating mode and then
+jump to the appropriate entrypoint, e.g. `_start()`.
+
+#### Decoded as i8086
+
+```asm
+  dec  %bp
+  pop  %dx
+  jno  0x4a
+  jo   0x4a
+```
+
+#### Decoded as i386
+
+```asm
+  push %ebp
+  pop  %edx
+  jno  0x4a
+  jo   0x4a
+```
+
+#### Decoded as x86-64
+
+```asm
+  rex.WRB
+  pop %r10
+  jno 0x4a
+  jo  0x4a
+```
+
+### (2) APE UNIX-Only Magic
+
+- ASCII: `jartsr='`
+- Hex: 6a 61 72 74 73 72 3d 27
+
+Being a novel executable format that was first published in 2020, the
+APE file format is less understood by industry tools compared to the PE,
+ELF, and Mach-O executable file formats, which have been around for
+decades. For this reason, APE programs that use the MZ magic above can
+attract attention from Windows AV software, which may be unwanted by
+developers who aren't interested in targeting the Windows platform.
+Therefore the `jartsr='` magic is defined which enables the creation of
+APE binaries that can safely target all non-Windows platforms. Even
+though this magic is less common, APE interpreters and binfmt-misc
+installations MUST support this.
+
+It is strongly recommended that this magic value be immediately followed
+by a newline (\n or hex 0a) character. Some shells, e.g. FreeBSD SH and
+Zsh impose a binary safety check before handing off files that don't
+have a shebang to `/bin/sh`. That check applies to the first line, which
+can't contain NUL characters.
+
+The letters were carefully chosen so as to be valid x86 instructions in
+all operating modes. This makes it possible to store a BIOS bootloader
+disk image inside an APE binary. For example, simple CLI programs built
+with Cosmopolitan Libc will boot from BIOS into long mode if they're
+treated as a floppy disk image.
+
+The letters also allow for the possibility of being treated on x86-64 as
+a flat executable, where the PE / ELF / Mach-O executable structures are
+ignored, and execution simply begins at the beginning of the file,
+similar to how MS-DOS .COM binaries work.
+
+The 0x78 relative offset of the magic causes execution to jump into the
+MS-DOS stub defined by Portable Executable. APE binaries built by Cosmo
+Libc use tricks in the MS-DOS stub to check the operating mode and then
+jump to the appropriate entrypoint, e.g. `_start()`.
+
+#### Decoded as i8086 / i386 / x86-64
+
+```asm
+  push $0x61
+  jb   0x78
+  jae  0x78
+```
+
+### (3) APE Debug Magic
+
+- ASCII: `APEDBG='`
+- Hex: 41 50 45 44 42 47 3d 27
+
+While APE files must be valid shell scripts, in practice, UNIX systems
+will oftentimes be configured to provide a faster safer alternative to
+loading an APE binary through `/bin/sh`. The Linux Kernel can be patched
+to have execve() recognize the APE format and directly load its embedded
+ELF header. Linux systems can also use binfmt-misc to recognize APE's MZ
+and jartsr magic, and pass them to a userspace program named `ape` that
+acts as an interpreter. In such environments, the need sometimes arises
+to be able to test that the `/bin/sh` is working correctly, in which
+case the `APEDBG='` magic is RECOMMENDED.
+
+APE interpreters, execve() implementations, and binfmt-misc installs
+MUST ignore this magic. If necessary, steps can be taken to help files
+with this magic be passed to `/bin/sh` like a normal shebang-less shell
+script for execution.
+
+## Embedded ELF Header
+
+APE binaries MAY embed an ELF header inside them. Unlike conventional
+executable file formats, this header is not stored at a fixed offset.
+It's instead encoded as octal escape codes in a shell script `printf`
+statement. For example:
+
+```
+printf '\177ELF\2\1\1\011\0\0\0\0\0\0\0\0\2\0\076\0\1\0\0\0\166\105\100\000\000\000\000\000\060\013\000\000\000\000\000\000\000\000\000\000\000\000\000\000\165\312\1\1\100\0\070\0\005\000\0\0\000\000\000\000'
+```
+
+This `printf` statement MUST appear in the first 8192 bytes of the APE
+executable, so as to limit how much of the initial portion of a file an
+interpreter must load.
+
+Multiple such `printf` statements MAY appear in the first 8192 bytes, in
+order to specify multiple architectures. For example, fat binaries built
+by the `apelink` program (provided by Cosmo Libc) will have two encoded
+ELF headers, for AMD64 and ARM64, each of which point into the proper
+file offsets for their respective native code. Therefore, kernels and
+interpreters which load the APE format directly MUST check the
+`e_machine` field of the `Elf64_Ehdr` that's decoded from the octal
+codes, before accepting a `printf` shell statement as valid.
+
+These printf statements MUST always use only unescaped ASCII characters
+or octal escape codes. These printf statements MUST NOT use space saving
+escape codes such as `\n`. For example, rather than saying `\n` it would
+be valid to say `\012` instead. It's also valid to say `\12` but only if
+the encoded characters that follow aren't an octal digit.
+
+For example, the following algorithm may be used for parsing octal:
+
+```c
+static int ape_parse_octal(const unsigned char page[8192], int i, int *pc)
+{
+        int c;
+        if ('0' <= page[i] && page[i] <= '7') {
+                c = page[i++] - '0';
+                if ('0' <= page[i] && page[i] <= '7') {
+                        c *= 8;
+                        c += page[i++] - '0';
+                        if ('0' <= page[i] && page[i] <= '7') {
+                                c *= 8;
+                                c += page[i++] - '0';
+                        }
+                }
+                *pc = c;
+        }
+        return i;
+}
+```
+
+APE aware interpreters SHOULD only take `e_machine` into consideration.
+It is the responsibility of the `_start()` function to detect the OS.
+Therefore, multiple `printf` statements are only embedded in the shell
+script for different CPU architectures.
+
+The OS ABI field of an APE embedded `Elf64_Ehdr` SHOULD be set to
+`ELFOSABI_FREEBSD`, since it's the only UNIX OS APE supports that
+actually checks the field. However different values MAY be chosen for
+binaries that don't intend to have FreeBSD in their support vector.
+
+Counter-intuitively, the ARM64 ELF header is used on the MacOS ARM64
+platform when loading from fat binaries.
+
+## Embedded Mach-O Header (x86-64 only)
+
+APE shell scripts that support MacOS on AMD64 must use the `dd` command
+in a very specific way to specify how the embedded binary Macho-O header
+is copied backward to the start of the file. For example:
+
+```
+dd if="$o" of="$o" bs=8 skip=433      count=66       conv=notrunc
+```
+
+These `dd` statements have traditionally been generated by the GNU as
+and ld.bfd programs by encoding ASCII into 64-bit linker relocations,
+which necessitated a fixed width for integer values. It took several
+iterations over APE's history before we eventually got it right:
+
+- `arg="  9293"` is how we originally had ape do it
+- `arg=$((  9293))` b/c busybox sh disliked quoted space
+- `arg=9293  ` is generated by modern apelink program
+
+Software that parses the APE file format, which needs to extract the
+Macho-O x86-64 header SHOULD support the old binaries that use the
+previous encodings. To make backwards compatibility simple the following
+regular expression may be used, which generalizes to all defined
+formats:
+
+```c
+regcomp(&rx,
+        "bs="              // dd block size arg
+        "(['\"] *)?"       //   #1 optional quote w/ space
+        "(\\$\\(\\( *)?"   //   #2 optional math w/ space
+        "([[:digit:]]+)"   //   #3
+        "( *\\)\\))?"      //   #4 optional math w/ space
+        "( *['\"])?"       //   #5 optional quote w/ space
+        " +"               //
+        "skip="            // dd skip arg
+        "(['\"] *)?"       //   #6 optional quote w/ space
+        "(\\$\\(\\( *)?"   //   #7 optional math w/ space
+        "([[:digit:]]+)"   //   #8
+        "( *\\)\\))?"      //   #9 optional math w/ space
+        "( *['\"])?"       //  #10 optional quote w/ space
+        " +"               //
+        "count="           // dd count arg
+        "(['\"] *)?"       //  #11 optional quote w/ space
+        "(\\$\\(\\( *)?"   //  #12 optional math w/ space
+        "([[:digit:]]+)",  //  #13
+        REG_EXTENDED);
+```
+
+For further details, see the canonical implementation in
+`cosmopolitan/tool/build/assimilate.c`.
+
+## Static Linking
+
+Actually Portable Executables are always statically linked. This
+revision of the specification does not define any facility for storing
+code in dynamic shared objects.
+
+Cosmopolitan Libc provides a solution that enables APE binaries have
+limited access to dlopen(). By manually loading a platform-specific
+executable and asking the OS-specific libc's dlopen() to load
+OS-specific libraries, it becomes possible to use GPUs and GUIs. This
+has worked great for AI projects like llamafile.
+
+There is no way for an Actually Portable Executable to interact with
+OS-specific dynamic shared object extension modules to programming
+languages. For example, a Lua interpreter compiled as an Actually
+Portable Executable would have no way of linking extension libraries
+downloaded from the Lua Rocks package manager. This is primarily because
+different OSes define incompatible ABIs.
+
+While it was possible to polyglot PE+ELF+MachO to create multi-OS
+executables, it simply isn't possible to do that same thing for
+DLL+DYLIB+SO. Therefore, in order to have DSOs, APE would need to either
+choose one of the existing formats or invent one of its own, and then
+develop its own parallel ecosystem of extension software. In the future,
+the APE specification may expand to encompass this. However the focus to
+date has been exclusively on executables with limited dlopen() support.
+
+## Application Binary Interface (ABI)
+
+APE binaries use the System V ABI, as defined by:
+
+- [System V ABI - AMD64 Architecture Processor Supplement](https://gitlab.com/x86-psABIs/x86-64-ABI)
+- AARCH64 has a uniform consensus defined by ARM Limited
+
+There are however a few changes we've had to make.
+
+### No Red Zone
+
+Actually Portable Executables that have Windows and/or bare metal in
+their support vector MUST be compiled using `-mno-red-zone`. This is
+because, on Windows, DLLs and other software lurking in the va-space
+might use tricks like SetThreadContext() to take control of a thread
+whereas on bare metal, it's also generally accepted that kernel-mode
+code cannot assume a red zone either due to hardware interrupts that
+pull the exact same kinds of stunts.
+
+APE software that only has truly System V ABI conformant OSes (e.g.
+Linux) in their support vector MAY use the red zone optimization.
+
+### Thread Local Storage
+
+#### aarch64
+
+Here's the TLS memory layout on aarch64:
+
+```
+           x28
+        %tpidr_el0
+            │
+            │    _Thread_local
+        ┌───┼───┬──────────┬──────────┐
+        │tib│dtv│  .tdata  │  .tbss   │
+        ├───┴───┴──────────┴──────────┘
+        │
+    __get_tls()
+```
+
+The ARM64 code in actually portable executables use the `x28` register
+to store the address of the thread information block. All aarch64 code
+linked into these executables SHOULD be compiled with `-ffixed-x28`
+which is supported by both Clang and GCC.
+
+The runtime library for an actually portable executables MAY choose to
+use `tpidr_el0` instead, if OSes like MacOS aren't being targeted. For
+example, if the goal is to create a Linux-only fat binary linker program
+for Musl Libc, then choosing to use the existing `tpidr_el0` convention
+would be friction-free alternative.
+
+It's not possible for an APE runtime that targets the full range of OSes
+to use the `tpidr_el0` register for TLS because Apple won't allow it. On
+MacOS ARM64 systems, this register can only be used by a runtime to
+implement the `sched_getcpu()` system call. It's reserved by MacOS.
+
+#### x86-64
+
+Here's the TLS memory layout on x86_64:
+
+```
+                          __get_tls()
+                              │
+                             %fs OpenBSD/NetBSD
+           _Thread_local      │
+    ┌───┬──────────┬──────────┼───┐
+    │pad│  .tdata  │  .tbss   │tib│
+    └───┴──────────┴──────────┼───┘
+                              │
+   Linux/FreeBSD/Windows/Mac %gs
+```
+
+Quite possibly the greatest challenge in Actually Portable Executable
+working, has been overcoming the incompatibilities between OSes in how
+thread-local storage works on x86-64. The AMD64 architecture defines two
+special segment registers. Every OS uses one of these segment registers
+to implement TLS support. However not all OSes agree on which register
+to use. Some OSes grant userspace the power to define either of these
+registers to hold any value that is desired. Some OSes only effectively
+allow a single one of them to be changed. Lastly, some OSes, e.g.
+Windows, claim ownership of the memory layout these registers point
+towards too.
+
+Here's a breakdown on how much power is granted to userspace runtimes by
+each OS when it comes to changing amd64 segment registers.
+
+|         | %fs          | %gs          |
+|---------|--------------|--------------|
+| Linux   | unrestricted | unrestricted |
+| MacOS   | inaccessible | unrestricted |
+| Windows | inaccessible | restricted   |
+| FreeBSD | unrestricted | unrestricted |
+| NetBSD  | unrestricted | broken       |
+| OpenBSD | unrestricted | inaccessible |
+
+Therefore, regardless of which register one we choose, some OSes are
+going to be incompatible.
+
+APE binaries are always built with a Linux compiler. So another issue
+arises in the fact that our Linux-flavored GCC and Clang toolchains
+(which are used to produce cross-OS binaries) are also only capable of
+producing TLS instructions that use the %fs convention.
+
+To solve these challenges, the `cosmocc` compiler will rewrite binary
+objects after they've been compiled by GCC, so that the `%gs` register
+is used, rather than `%fs`. Morphing x86-64 binaries after they've been
+compiled is normally difficult, due to the complexity of the machine
+instruction language. However GCC provides `-mno-tls-direct-seg-refs`
+which greatly reduces the complexity of this task. This flag forgoes
+some optimizations to make the generated code simpler. Rather than doing
+clever arithmetic with `%fs` prefixes, the compiler will always generate
+the thread information block address load as a separate instruction.
+
+```c
+// Change AMD code to use %gs:0x30 instead of %fs:0
+// We assume -mno-tls-direct-seg-refs has been used
+static void ChangeTlsFsToGs(unsigned char *p, size_t n) {
+  unsigned char *e = p + n - 9;
+  while (p <= e) {
+    // we're checking for the following expression:
+    //   0144 == p[0] &&           // %fs
+    //   0110 == (p[1] & 0373) &&  // rex.w (and ignore rex.r)
+    //   (0213 == p[2] ||          // mov reg/mem → reg (word-sized)
+    //   0003 == p[2]) &&          // add reg/mem → reg (word-sized)
+    //   0004 == (p[3] & 0307) &&  // mod/rm (4,reg,0) means sib → reg
+    //   0045 == p[4] &&           // sib (5,4,0) → (rbp,rsp,0) → disp32
+    //   0000 == p[5] &&           // displacement (von Neumann endian)
+    //   0000 == p[6] &&           // displacement
+    //   0000 == p[7] &&           // displacement
+    //   0000 == p[8]              // displacement
+    uint64_t w = READ64LE(p) & READ64LE("\377\373\377\307\377\377\377\377");
+    if ((w == READ64LE("\144\110\213\004\045\000\000\000") ||
+         w == READ64LE("\144\110\003\004\045\000\000\000")) &&
+        !p[8]) {
+      p[0] = 0145;  // change %fs to %gs
+      p[5] = 0x30;  // change 0 to 0x30
+      p += 9;
+    } else {
+      ++p;
+    }
+  }
+}
+```
+
+By favoring `%gs` we've now ensured friction-free compatibility for the
+APE runtime on MacOS, Linux, and FreeBSD which are all able to conform
+easily to this convention. However additional work needs to be done at
+runtime when an APE program is started on Windows, OpenBSD, and NetBSD.
+On these platforms, all executable pages must be faulted and morphed to
+fixup the TLS instructions.
+
+On OpenBSD and NetBSD, this is as simple as undoing the example
+operation above. Earlier at compile-time we turned `%fs` into `%gs`.
+Now, at runtime, `%gs` must be turned back into `%fs`. Since the
+executable is morphing itself, this is easier said than done.
+
+OpenBSD for example enforces a `W^X` invariant. Code that's executing
+can't modify itself at the same time. The way Cosmopolitan solves this
+is by defining a special part of the binary called `.text.privileged`.
+This section is aligned to page boundaries. A GNU ld linker script is
+used to ensure that code which morphs code is placed into this section,
+through the use of a header-defined cosmo-specific keyword `privileged`.
+Additionally, the `fixupobj` program is used by the Cosmo build system
+to ensure that compiled objects don't contain privileged functions that
+call non-privileged functions. Needless to say, `mprotect()` needs to be
+a privileged function, so that it can be used to disable the execute bit
+on all other parts of the executable except for the privileged section,
+thereby making it writable. Once this has been done, code can change.
+
+On Windows the displacement bytes of the TLS instruction are changed to
+use the `%gs:0x1480+i*8` ABI where `i` is a number assigned by the WIN32
+`TlsAlloc()` API. This avoids the need to call `TlsGetValue()` which is
+implemented this exact same way under the hood. Even though 0x1480 isn't
+explicitly documented by MSDN, this ABI is believed to be stable because
+MSVC generates binaries that use this offset directly. The only caveat
+is that `TlsAlloc()` must be called as early in the runtime init as
+possible, to ensure an index less than 64 is returned.
+
+### Thread Information Block (TIB)
+
+The Actually Portable Executable Thread Information Block (TIB) is
+defined by this version of the specification as follows:
+
+- The 64-bit TIB self-pointer is stored at offset 0x00.
+- The 64-bit TIB self-pointer is also stored at offset 0x30.
+- The 32-bit `errno` value is stored at offset 0x3c.
+
+All other parts of the thread information block should be considered
+unspecified and therefore reserved for future specifications.
+
+The APE thread information block is aligned on a 64-byte boundary.
+
+Cosmopolitan Libc v3.5.8 (c. 2024-07-21) currently implements a thread
+information block that's 512 bytes in size.
+
+### Foreign Function Calls
+
+Even though APE programs always use the System V ABI, there arises the
+occasional need to interface with foreign functions, e.g. WIN32. The
+`__attribute__((__ms_abi__))` annotation introduced by GCC v6 is used
+for this purpose.
+
+The ability to change a function's ABI on a case-by-case basis is
+surprisingly enough supported by GCC, Clang, NVCC, and even the AMD HIP
+compilers for both UNIX systems and Windows. All of these compilers
+support both the System V ABI and the Microsoft x64 ABI.
+
+APE binaries will actually favor the Microsoft ABI even when running on
+UNIX OSes for certain dlopen() use-cases. For example, if we control the
+code to a CUDA module, which we compile on each OS separately from our
+main APE binary, then any function that's inside the APE binary whose
+pointer may be passed into a foreign module SHOULD be compiled to use
+the Microsoft ABI. This is because in practice the OS-specific module
+may need to be compiled by MSVC, where MS ABI is the *only* ABI, which
+forces our UNIX programs to partially conform. Thankfully, all UNIX
+compilers support doing it on a case-by-case basis.
+
+### Char Signedness
+
+Actually Portable Executable defines `char` as signed.
+
+Therefore conformant APE software MUST use `-fsigned-char` when building
+code for aarch64, as well as any other architecture that (unlike x86-64)
+would otherwise define `char` as being `unsigned char` by default.
+
+This decision was one of the cases where it made sense to offer a more
+consistent runtime experience for fat multi-arch binaries. However you
+SHOULD still write code to assume `char` can go either way. But if all
+you care about is using APE, then you CAN assume `char` is signed.
+
+### Long Double
+
+On AMD64 platforms, APE binaries define `long double` as 80-bit.
+
+On ARM64 platforms, APE binaries define `long double` as 128-bit.
+
+We accept inconsistency in this case, because hardware acceleration is
+far more valuable than stylistic consistency in the case of mathematics.
+
+One challenge arises on AMD64 for supporting `long double` across OSes.
+Unlike UNIX systems, the Windows Executive on x86-64 initializes the x87
+FPU to have double (64-bit) precision rather than 80-bit. That's because
+code compiled by MSVC treats `long double` as though it were `double` to
+prefer always using the more modern SSE instructions. However System V
+requires genuine 80-bit `long double` support on AMD64.
+
+Therefore, if an APE program detects that it's been started on a Windows
+x86-64 system, then it SHOULD use the following assembly to initialize
+the x87 FPU in System V ABI mode.
+
+```asm
+	fldcw	1f(%rip)
+	.rodata
+	.balign	2
+//	8087 FPU Control Word
+//	 IM: Invalid Operation ───────────────┐
+//	 DM: Denormal Operand ───────────────┐│
+//	 ZM: Zero Divide ───────────────────┐││
+//	 OM: Overflow ─────────────────────┐│││
+//	 UM: Underflow ───────────────────┐││││
+//	 PM: Precision ──────────────────┐│││││
+//	 PC: Precision Control ───────┐  ││││││
+//	  {float,∅,double,long double}│  ││││││
+//	 RC: Rounding Control ──────┐ │  ││││││
+//	  {even, →-∞, →+∞, →0}      │┌┤  ││││││
+//	                           ┌┤││  ││││││
+//	                          d││││rr││││││
+1:	.short	0b00000000000000000001101111111
+	.previous
+```
+
+## Executable File Alignment
+
+Actually Portable Executable is a statically-linked flat executable file
+format that is, as a thing in itself, agnostic to file alignments. For
+example, the shell script payload at the beginning of the file and its
+statements have no such requirements. Alignment requirements are however
+imposed by the executable formats that APE wraps.
+
+1. ELF requires that file offsets be congruent with virtual addresses
+   modulo the CPU page size. So when we add a shell script to the start
+   of an executable, we need to round up to the page size in order to
+   maintain ELF's invariant. Although no such roundup is required on the
+   program segments once the invariant is restored. ELF loaders will
+   happily map program headers from arbitrary file intervals (which may
+   overlap) onto arbitrarily virtual intervals (which don't need to be
+   contiguous). In order to do that, the loaders will generally use
+   UNIX's mmap() function which is more restrictive and only accepts
+   addresses and offsets that are page aligned. To make it possible to
+   map an unaligned ELF program header that could potentially start and
+   stop at any byte, ELF loaders round-out the intervals, which means
+   adjacent unrelated data might also get mapped, which may need to be
+   explicitly zero'd. Thanks to the cleverness of ELF, it's possible to
+   have an executable file be very tiny, without needing any alignment
+   bytes, and it'll be loaded into a properly aligned virtual space
+   where segments can be as sparse as we want them to be.
+
+2. PE doesn't care about congruence and instead defines two separate
+   kinds of alignment. First, PE requires that the layout of segment
+   memory inside the file be aligned on at minimum the classic 512 byte
+   MS-DOS page size. This means that, unlike ELF, some alignment padding
+   may need to be encoded into the file, making it slightly larger. Next
+   PE imposes an alignment restriction on segments once they've been
+   mapped into the virtual address space, which must be rounded to the
+   system page size. Like ELF, PE segments need to be properly ordered
+   but they're allowed to drift apart once mapped in a non-contiguous
+   sparsely mapped way. When inserting shell script content at the start
+   of a PE file, the most problematic thing is the need to round up to
+   the 64kb system granularity, which results in a lot of needless bytes
+   of padding being inserted by a naive second-pass linker.
+
+3. Apple's Mach-O format is the strictest of them all. While both ELF
+   and PE are defined in such a way that invites great creativity, XNU
+   will simply refuse to an executable that does anything creative with
+   alignment. All loaded segments need to both start and end on a page
+   aligned address. XNU also wants segments to be contiguous similar to
+   portable executable, except it applies to both the file and virtual
+   spaces, which must follow the same structure.
+
+Actually Portable Executables must conform to the strictest requirements
+demanded by the support vector. Therefore an APE binary that has headers
+for all three of the above executable formats MUST conform to the Apple
+way of doing things. GNU ld linker scripts aren't very good at producing
+ELF binaries that rigidly conform to this simple naive layout. There are
+so many ways things can go wrong, where third party code might slip its
+own custom section name in-between the linker script sections that are
+explicitly defined, thereby causing ELF's powerful features to manifest
+and the resulting content overlapping. The best `ld` flag that helps is
+`--orphan-handling=error` which can help with explaining such mysteries.
+
+While Cosmopolitan was originally defined to just use stock GNU tools,
+this proved intractable over time, and the project has been evolving in
+the direction of building its own. Inventing the `apelink` program was
+what enabled the project to achieve multi-architecture binaries whereas
+previously it was only possible to do multi-OS binaries. In the future,
+our hope is that a fast power linker like Mold can be adapted to produce
+fat APE binaries directly from object files in one pass.
+
+## Position Independent Code
+
+APE doesn't currently support position independent executable formats.
+This is because APE was originally written for the GNU linker, where PIC
+and PIE were after-thoughts and never fully incorporated with the older
+more powerful linker script techniques upon which APE relies. Future
+iterations of this specification are intended to converge on modern
+standards, as our tooling becomes developed enough to support it.
+
+However this only applies to the wrapped executable formats themselves.
+While our convention to date has been to always load ELF programs at the
+4mb mark, this is not guaranteed across OSes and architectures. Programs
+should have no expectations that a program will be loaded to any given
+address. For example, Cosmo currently implements APE on AARCH64 as
+loading executables to a starting address of 0x000800000000. This
+address occupies a sweet spot of requirements.
+
+## Address Space
+
+In order to create a single binary that supports as many platforms as
+possible without needing to be recompiled, there's a very narrow range
+of addresses that can be used. That range is somewhere between 32 bits
+and 39 bits.
+
+- Embedded devices that claim to be 64-bit will oftentimes only support
+  a virtual address space that's 39 bits in size.
+
+- We can't load executable images on AARCH64 beneath 0x100000000 (4gb)
+  because Apple forbids doing that, possibly in an effort to enforce a
+  best practice for spotting 32-bit to 64-bit transition bugs. Please
+  note that this restriction only applies to Apple ARM64 systems. The
+  x86-64 version of XNU will happily load APE binaries to 0x00400000.
+
+- The AMD64 architecture on desktops and servers can usually be counted
+  upon to provide a 47-bit address space. The Linux Kernel for instance
+  grants each userspace program full dominion over addresses 0x00200000
+  through 0x00007fffffffffff provided the hardware supports this. On
+  modern workstations supporting Intel and AMD's new PML5T feature which
+  virtualizes memory using a radix trie that's five layers deep, Linux
+  is able to offer userspace its choice of fixed addresses from
+  0x00200000 through 0x00ffffffffffffff. The only exception to this rule
+  we've encountered so far is that Windows 7 and Windows Vista behaved
+  similar to embedded devices in reducing the number of va bits.
+
+## Page Size
+
+APE software MUST be page size agnostic. For many years the industry had
+converged on a strong consensus of having a page size that's 4096 bytes.
+However this convention was never guaranteed. New computers have become
+extremely popular, such as Apple Silicon, that use a 16kb page size.
+
+By convention, Cosmopolitan Libc currently generates ELF headers for
+x86-64 that are strictly aligned on a 4096-byte page size. On ARM64
+Cosmopolitan is currently implemented to always generate ELF headers
+aligned on a 16kb page size.
+
+In addition to being page size agnostic, APE software that cares about
+working correctly on Windows needs to be aware of the concept of
+allocation granularity. While the page size on Windows is generally 4kb
+in size, memory mappings can only be created on addresses that aligned
+to the system allocation granularity, which is generally 64kb. If you
+use a function like mmap() with Cosmopolitan Libc, then the `addr` and
+`offset` parameters need to be aligned to `sysconf(_SC_GRANSIZE)` or
+else your software won't work on Windows. Windows has other limitations
+too, such as lacking the ability to carve or punch holes in mappings.

build/config.mk

@@ -14,7 +14,6 @@ ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CCFLAGS += -O2 $(BACKTRACES)
 CONFIG_CPPFLAGS += -DSYSDEBUG
-TARGET_ARCH ?= -msse3
 endif
 ifeq ($(MODE), x86_64)
 ENABLE_FTRACE = 1
@@ -64,7 +63,6 @@ ENABLE_FTRACE = 1
 CONFIG_CCFLAGS += $(BACKTRACES) -O
 CONFIG_CPPFLAGS += -DSYSDEBUG -DDWARFLESS
 CONFIG_LDFLAGS += -S
-TARGET_ARCH ?= -msse3
 endif
 
 # Optimized Mode
@@ -84,7 +82,7 @@ ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
 CONFIG_CCFLAGS += $(BACKTRACES) -O3 -fmerge-all-constants
-TARGET_ARCH ?= -march=native
+CONFIG_TARGET_ARCH ?= -march=native
 endif
 
 # Optimized Linux Mode
@@ -102,7 +100,20 @@ CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
 CONFIG_CCFLAGS += -O3 -fmerge-all-constants
 CONFIG_COPTS += -mred-zone
-TARGET_ARCH ?= -march=native
+CONFIG_TARGET_ARCH ?= -march=native
+endif
+ifeq ($(MODE), x86_64-optlinux)
+CONFIG_OFLAGS ?= -g -ggdb
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS += -O3 -fmerge-all-constants
+CONFIG_COPTS += -mred-zone
+CONFIG_TARGET_ARCH ?= -march=native
+endif
+ifeq ($(MODE), aarch64-optlinux)
+CONFIG_OFLAGS ?= -g -ggdb
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS += -O3 -fmerge-all-constants
+CONFIG_COPTS += -mred-zone
 endif
 
 # Release Mode
@@ -123,7 +134,6 @@ endif
 ifeq ($(MODE), rel)
 CONFIG_CPPFLAGS += -DNDEBUG -DDWARFLESS
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
-TARGET_ARCH ?= -msse3
 PYFLAGS += -O1
 endif
 
@@ -139,18 +149,32 @@ endif
 ifeq ($(MODE), dbg)
 ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
-CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__
-CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline
+OVERRIDE_CFLAGS += -O0
+OVERRIDE_CXXFLAGS += -O0
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__ -Wno-unused-variable -Wno-unused-but-set-variable
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG
+CONFIG_COPTS += -fsanitize=undefined
+OVERRIDE_CCFLAGS += -fno-pie
+QUOTA ?= -C64 -L300
+endif
+ifeq ($(MODE), x86_64-dbg)
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g -ggdb
+OVERRIDE_CFLAGS += -O0
+OVERRIDE_CXXFLAGS += -O0
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__ -Wno-unused-variable -Wno-unused-but-set-variable
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG
 CONFIG_COPTS += -fsanitize=undefined
-TARGET_ARCH ?= -msse3
 OVERRIDE_CCFLAGS += -fno-pie
 QUOTA ?= -C64 -L300
 endif
 ifeq ($(MODE), aarch64-dbg)
 ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
-CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__
-CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline -fdce
+OVERRIDE_CFLAGS += -O0 -fdce
+OVERRIDE_CXXFLAGS += -O0 -fdce
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__ -Wno-unused-variable -Wno-unused-but-set-variable
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG
 CONFIG_COPTS += -fsanitize=undefined
 QUOTA ?= -C64 -L300
 endif
@@ -170,7 +194,6 @@ ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
 CONFIG_CPPFLAGS += -DSYSDEBUG -DSUPPORT_VECTOR=121
-TARGET_ARCH ?= -msse3
 endif
 
 # Tiny Mode
@@ -200,8 +223,6 @@ CONFIG_CCFLAGS +=			\
 	-momit-leaf-frame-pointer	\
 	-foptimize-sibling-calls	\
 	-DDWARFLESS
-TARGET_ARCH ?=				\
-	-msse3
 PYFLAGS +=				\
 	-O2				\
 	-B
@@ -221,8 +242,6 @@ CONFIG_CCFLAGS +=			\
 	-momit-leaf-frame-pointer	\
 	-foptimize-sibling-calls	\
 	-DDWARFLESS
-TARGET_ARCH ?=				\
-	-msse3
 PYFLAGS +=				\
 	-O2				\
 	-B
@@ -274,8 +293,6 @@ CONFIG_CCFLAGS +=			\
 	-fno-align-jumps		\
 	-fno-align-labels		\
 	-fno-align-loops
-TARGET_ARCH ?=				\
-	-msse3
 endif
 
 # Linux+BSD Tiny Mode
@@ -305,8 +322,6 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=			\
-	-msse3
 endif
 
 # Unix Tiny Mode
@@ -335,8 +350,6 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=			\
-	-msse3
 endif
 
 # Tiny Metallic Unix Mode
@@ -365,8 +378,6 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=			\
-	-msse3
 endif
 
 # no x87 instructions mode
@@ -388,7 +399,6 @@ ENABLE_FTRACE = 1
 CONFIG_COPTS += -mlong-double-64
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
 CONFIG_CPPFLAGS += -DSYSDEBUG -DNOX87
-TARGET_ARCH ?= -msse3
 endif
 
 # LLVM Mode
@@ -401,7 +411,6 @@ endif
 #
 ifeq ($(MODE), llvm)
 .STRICT = 0
-TARGET_ARCH ?= -msse3
 CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O2
 AS = clang
 CC = clang
@@ -444,7 +453,6 @@ ifeq ($(MODE), ansi)
 CONFIG_CFLAGS += -std=c11
 #CONFIG_CPPFLAGS += -ansi
 CONFIG_CXXFLAGS += -std=c++11
-TARGET_ARCH ?= -msse3
 endif
 
 ifneq ($(ENABLE_FTRACE),)
@@ -502,3 +510,5 @@ ifeq ($(ARCH), aarch64)
 CONFIG_CCFLAGS += -fpatchable-function-entry=7,6
 endif
 endif
+
+TARGET_ARCH ?= $(CONFIG_TARGET_ARCH)

build/definitions.mk

@@ -139,10 +139,10 @@ DEFAULT_CPPFLAGS +=							\
 	-isystem libc/isystem
 
 DEFAULT_CFLAGS =							\
-	-std=gnu2x
+	-std=gnu23
 
 DEFAULT_CXXFLAGS =							\
-	-std=gnu++20							\
+	-std=gnu++23							\
 	-fno-rtti							\
 	-fno-exceptions							\
 	-fuse-cxa-atexit						\

build/objdump

@@ -6,14 +6,14 @@ if [ -n "$OBJDUMP" ]; then
 fi
 
 find_objdump() {
-  if [ -x .cosmocc/3.3.5/bin/$1-linux-cosmo-objdump ]; then
-    OBJDUMP=.cosmocc/3.3.5/bin/$1-linux-cosmo-objdump
-  elif [ -x .cosmocc/3.3.5/bin/$1-linux-musl-objdump ]; then
-    OBJDUMP=.cosmocc/3.3.5/bin/$1-linux-musl-objdump
-  elif [ -x "$COSMO/.cosmocc/3.3.5/bin/$1-linux-cosmo-objdump" ]; then
-    OBJDUMP="$COSMO/.cosmocc/3.3.5/bin/$1-linux-cosmo-objdump"
-  elif [ -x "$COSMO/.cosmocc/3.3.5/bin/$1-linux-musl-objdump" ]; then
-    OBJDUMP="$COSMO/.cosmocc/3.3.5/bin/$1-linux-musl-objdump"
+  if [ -x .cosmocc/3.6.0/bin/$1-linux-cosmo-objdump ]; then
+    OBJDUMP=.cosmocc/3.6.0/bin/$1-linux-cosmo-objdump
+  elif [ -x .cosmocc/3.6.0/bin/$1-linux-musl-objdump ]; then
+    OBJDUMP=.cosmocc/3.6.0/bin/$1-linux-musl-objdump
+  elif [ -x "$COSMO/.cosmocc/3.6.0/bin/$1-linux-cosmo-objdump" ]; then
+    OBJDUMP="$COSMO/.cosmocc/3.6.0/bin/$1-linux-cosmo-objdump"
+  elif [ -x "$COSMO/.cosmocc/3.6.0/bin/$1-linux-musl-objdump" ]; then
+    OBJDUMP="$COSMO/.cosmocc/3.6.0/bin/$1-linux-musl-objdump"
   else
     echo "error: toolchain not found (try running 'cosmocc --update' or 'make' in the cosmo monorepo)" >&2
     exit 1

build/sanitycheck

@@ -31,7 +31,7 @@ if [ ! -f /proc/sys/fs/binfmt_misc/status ]; then
   exit 0
 fi
 
-if ! build/bootstrap/echo.com -n; then
+if ! build/bootstrap/echo -n; then
   cat <<'EOF' >&2
 
 ERROR

ctl/is_void.h

@@ -0,0 +1,24 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_VOID_H_
+#define CTL_IS_VOID_H_
+#include "integral_constant.h"
+#include "remove_cv.h"
+
+namespace ctl {
+
+template<typename>
+struct is_void_ : public ctl::false_type
+{};
+
+template<>
+struct is_void_<void> : public ctl::true_type
+{};
+
+template<typename _Tp>
+struct is_void : public is_void_<typename ctl::remove_cv<_Tp>::type>::type
+{};
+
+} // namespace ctl
+
+#endif // CTL_IS_VOID_H_

ctl/istream.cc

@@ -17,6 +17,7 @@
 // PERFORMANCE OF THIS SOFTWARE.
 
 #include "istream.h"
+#include "libc/ctype.h"
 #include "libc/fmt/conv.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"

ctl/istringstream.cc

@@ -17,6 +17,7 @@
 // PERFORMANCE OF THIS SOFTWARE.
 
 #include "istringstream.h"
+#include "libc/ctype.h"
 #include "libc/fmt/conv.h"
 #include "libc/str/str.h"
 

ctl/set.h

@@ -13,18 +13,34 @@ class set
 {
     struct rbtree
     {
-        rbtree* left;
+        uintptr_t left_;
         rbtree* right;
         rbtree* parent;
-        bool is_red;
         Key value;
 
+        rbtree* left() const
+        {
+            return (rbtree*)(left_ & -2);
+        }
+
+        void left(rbtree* val)
+        {
+            left_ = (uintptr_t)val | (left_ & 1);
+        }
+
+        bool is_red() const
+        {
+            return left_ & 1;
+        }
+
+        void is_red(bool val)
+        {
+            left_ &= -2;
+            left_ |= val;
+        }
+
         rbtree(const Key& val)
-          : left(nullptr)
-          , right(nullptr)
-          , parent(nullptr)
-          , is_red(true)
-          , value(val)
+          : left_(1), right(nullptr), parent(nullptr), value(val)
         {
         }
     };
@@ -85,14 +101,14 @@ class set
         {
             if (node_ == nullptr)
                 __builtin_trap();
-            if (node_->left) {
-                node_ = rightmost(node_->left);
+            if (node_->left()) {
+                node_ = rightmost(node_->left());
             } else {
                 node_type* parent = node_->parent;
                 for (;;) {
                     if (parent == nullptr)
                         break;
-                    if (node_ == parent->left) {
+                    if (node_ == parent->left()) {
                         node_ = parent;
                         parent = parent->parent;
                     } else {
@@ -161,11 +177,11 @@ class set
 
         reverse_iterator& operator++()
         {
-            if (node_->left) {
-                node_ = rightmost(node_->left);
+            if (node_->left()) {
+                node_ = rightmost(node_->left());
             } else {
                 node_type* parent = node_->parent;
-                while (parent && node_ == parent->left) {
+                while (parent && node_ == parent->left()) {
                     node_ = parent;
                     parent = parent->parent;
                 }
@@ -508,7 +524,7 @@ class set
     {
         size_type count = 0;
         if (root_ != nullptr) {
-            if (root_->is_red)
+            if (root_->is_red())
                 // ILLEGAL TREE: root node must be black
                 __builtin_trap();
             int black_height = -1;
@@ -523,8 +539,8 @@ class set
   private:
     static node_type* leftmost(node_type* node) noexcept
     {
-        while (node && node->left)
-            node = node->left;
+        while (node && node->left())
+            node = node->left();
         return node;
     }
 
@@ -535,35 +551,35 @@ class set
         return node;
     }
 
-    static void clearer(node_type* node) noexcept
+    static optimizesize void clearer(node_type* node) noexcept
     {
         node_type* right;
         for (; node; node = right) {
             right = node->right;
-            clearer(node->left);
+            clearer(node->left());
             delete node;
         }
     }
 
-    static node_type* copier(const node_type* node)
+    static optimizesize node_type* copier(const node_type* node)
     {
         if (node == nullptr)
             return nullptr;
         node_type* new_node = new node_type(node->value);
-        new_node->left = copier(node->left);
+        new_node->left(copier(node->left()));
         new_node->right = copier(node->right);
-        if (new_node->left)
-            new_node->left->parent = new_node;
+        if (new_node->left())
+            new_node->left()->parent = new_node;
         if (new_node->right)
             new_node->right->parent = new_node;
         return new_node;
     }
 
-    static size_type tally(const node_type* node)
+    static optimizesize size_type tally(const node_type* node)
     {
         if (node == nullptr)
             return 0;
-        return 1 + tally(node->left) + tally(node->right);
+        return 1 + tally(node->left()) + tally(node->right);
     }
 
     template<typename K>
@@ -572,7 +588,7 @@ class set
         node_type* current = root_;
         while (current != nullptr) {
             if (comp_(key, current->value)) {
-                current = current->left;
+                current = current->left();
             } else if (comp_(current->value, key)) {
                 current = current->right;
             } else {
@@ -590,7 +606,7 @@ class set
         while (current != nullptr) {
             if (!comp_(current->value, key)) {
                 result = current;
-                current = current->left;
+                current = current->left();
             } else {
                 current = current->right;
             }
@@ -606,7 +622,7 @@ class set
         while (current != nullptr) {
             if (comp_(key, current->value)) {
                 result = current;
-                current = current->left;
+                current = current->left();
             } else {
                 current = current->right;
             }
@@ -614,11 +630,11 @@ class set
         return result;
     }
 
-    ctl::pair<iterator, bool> insert_node(node_type* node)
+    optimizesize ctl::pair<iterator, bool> insert_node(node_type* node)
     {
         if (root_ == nullptr) {
             root_ = node;
-            root_->is_red = false;
+            root_->is_red(false);
             size_++;
             return { iterator(root_), true };
         }
@@ -627,7 +643,7 @@ class set
         while (current != nullptr) {
             parent = current;
             if (comp_(node->value, current->value)) {
-                current = current->left;
+                current = current->left();
             } else if (comp_(current->value, node->value)) {
                 current = current->right;
             } else {
@@ -636,7 +652,7 @@ class set
             }
         }
         if (comp_(node->value, parent->value)) {
-            parent->left = node;
+            parent->left(node);
         } else {
             parent->right = node;
         }
@@ -646,23 +662,23 @@ class set
         return { iterator(node), true };
     }
 
-    void erase_node(node_type* node)
+    optimizesize void erase_node(node_type* node)
     {
         node_type* y = node;
         node_type* x = nullptr;
         node_type* x_parent = nullptr;
-        bool y_original_color = y->is_red;
-        if (node->left == nullptr) {
+        bool y_original_color = y->is_red();
+        if (node->left() == nullptr) {
             x = node->right;
             transplant(node, node->right);
             x_parent = node->parent;
         } else if (node->right == nullptr) {
-            x = node->left;
-            transplant(node, node->left);
+            x = node->left();
+            transplant(node, node->left());
             x_parent = node->parent;
         } else {
             y = leftmost(node->right);
-            y_original_color = y->is_red;
+            y_original_color = y->is_red();
             x = y->right;
             if (y->parent == node) {
                 if (x)
@@ -675,9 +691,9 @@ class set
                 x_parent = y->parent;
             }
             transplant(node, y);
-            y->left = node->left;
-            y->left->parent = y;
-            y->is_red = node->is_red;
+            y->left(node->left());
+            y->left()->parent = y;
+            y->is_red(node->is_red());
         }
         if (!y_original_color)
             rebalance_after_erase(x, x_parent);
@@ -685,28 +701,28 @@ class set
         --size_;
     }
 
-    void left_rotate(node_type* x)
+    optimizesize void left_rotate(node_type* x)
     {
         node_type* y = x->right;
-        x->right = y->left;
-        if (y->left != nullptr)
-            y->left->parent = x;
+        x->right = y->left();
+        if (y->left() != nullptr)
+            y->left()->parent = x;
         y->parent = x->parent;
         if (x->parent == nullptr) {
             root_ = y;
-        } else if (x == x->parent->left) {
-            x->parent->left = y;
+        } else if (x == x->parent->left()) {
+            x->parent->left(y);
         } else {
             x->parent->right = y;
         }
-        y->left = x;
+        y->left(x);
         x->parent = y;
     }
 
-    void right_rotate(node_type* y)
+    optimizesize void right_rotate(node_type* y)
     {
-        node_type* x = y->left;
-        y->left = x->right;
+        node_type* x = y->left();
+        y->left(x->right);
         if (x->right != nullptr)
             x->right->parent = y;
         x->parent = y->parent;
@@ -715,18 +731,18 @@ class set
         } else if (y == y->parent->right) {
             y->parent->right = x;
         } else {
-            y->parent->left = x;
+            y->parent->left(x);
         }
         x->right = y;
         y->parent = x;
     }
 
-    void transplant(node_type* u, node_type* v)
+    optimizesize void transplant(node_type* u, node_type* v)
     {
         if (u->parent == nullptr) {
             root_ = v;
-        } else if (u == u->parent->left) {
-            u->parent->left = v;
+        } else if (u == u->parent->left()) {
+            u->parent->left(v);
         } else {
             u->parent->right = v;
         }
@@ -734,10 +750,10 @@ class set
             v->parent = u->parent;
     }
 
-    void checker(const node_type* node,
-                 const node_type* parent,
-                 int black_count,
-                 int& black_height) const
+    optimizesize void checker(const node_type* node,
+                              const node_type* parent,
+                              int black_count,
+                              int& black_height) const
     {
         if (node == nullptr) {
             // Leaf nodes are considered black
@@ -753,117 +769,121 @@ class set
             // ILLEGAL TREE: Parent link is incorrect
             __builtin_trap();
         if (parent) {
-            if (parent->left == node && !comp_(node->value, parent->value))
+            if (parent->left() == node && !comp_(node->value, parent->value))
                 // ILLEGAL TREE: Binary search property violated on left child
                 __builtin_trap();
             if (parent->right == node && !comp_(parent->value, node->value))
                 // ILLEGAL TREE: Binary search property violated on right child
                 __builtin_trap();
         }
-        if (!node->is_red) {
+        if (!node->is_red()) {
             black_count++;
-        } else if (parent != nullptr && parent->is_red) {
+        } else if (parent != nullptr && parent->is_red()) {
             // ILLEGAL TREE: Red node has red child
             __builtin_trap();
         }
-        checker(node->left, node, black_count, black_height);
+        checker(node->left(), node, black_count, black_height);
         checker(node->right, node, black_count, black_height);
     }
 
-    void rebalance_after_insert(node_type* node)
+    optimizesize void rebalance_after_insert(node_type* node)
     {
-        node->is_red = true;
-        while (node != root_ && node->parent->is_red) {
-            if (node->parent == node->parent->parent->left) {
+        node->is_red(true);
+        while (node != root_ && node->parent->is_red()) {
+            if (node->parent == node->parent->parent->left()) {
                 node_type* uncle = node->parent->parent->right;
-                if (uncle && uncle->is_red) {
-                    node->parent->is_red = false;
-                    uncle->is_red = false;
-                    node->parent->parent->is_red = true;
+                if (uncle && uncle->is_red()) {
+                    node->parent->is_red(false);
+                    uncle->is_red(false);
+                    node->parent->parent->is_red(true);
                     node = node->parent->parent;
                 } else {
                     if (node == node->parent->right) {
                         node = node->parent;
                         left_rotate(node);
                     }
-                    node->parent->is_red = false;
-                    node->parent->parent->is_red = true;
+                    node->parent->is_red(false);
+                    node->parent->parent->is_red(true);
                     right_rotate(node->parent->parent);
                 }
             } else {
-                node_type* uncle = node->parent->parent->left;
-                if (uncle && uncle->is_red) {
-                    node->parent->is_red = false;
-                    uncle->is_red = false;
-                    node->parent->parent->is_red = true;
+                node_type* uncle = node->parent->parent->left();
+                if (uncle && uncle->is_red()) {
+                    node->parent->is_red(false);
+                    uncle->is_red(false);
+                    node->parent->parent->is_red(true);
                     node = node->parent->parent;
                 } else {
-                    if (node == node->parent->left) {
+                    if (node == node->parent->left()) {
                         node = node->parent;
                         right_rotate(node);
                     }
-                    node->parent->is_red = false;
-                    node->parent->parent->is_red = true;
+                    node->parent->is_red(false);
+                    node->parent->parent->is_red(true);
                     left_rotate(node->parent->parent);
                 }
             }
         }
-        root_->is_red = false;
+        root_->is_red(false);
     }
 
-    void rebalance_after_erase(node_type* node, node_type* parent)
+    optimizesize void rebalance_after_erase(node_type* node, node_type* parent)
     {
-        while (node != root_ && (node == nullptr || !node->is_red)) {
-            if (node == parent->left) {
+        while (node != root_ && (node == nullptr || !node->is_red())) {
+            if (node == parent->left()) {
                 node_type* sibling = parent->right;
-                if (sibling->is_red) {
-                    sibling->is_red = false;
-                    parent->is_red = true;
+                if (sibling->is_red()) {
+                    sibling->is_red(false);
+                    parent->is_red(true);
                     left_rotate(parent);
                     sibling = parent->right;
                 }
-                if ((sibling->left == nullptr || !sibling->left->is_red) &&
-                    (sibling->right == nullptr || !sibling->right->is_red)) {
-                    sibling->is_red = true;
+                if ((sibling->left() == nullptr ||
+                     !sibling->left()->is_red()) &&
+                    (sibling->right == nullptr || !sibling->right->is_red())) {
+                    sibling->is_red(true);
                     node = parent;
                     parent = node->parent;
                 } else {
-                    if (sibling->right == nullptr || !sibling->right->is_red) {
-                        sibling->left->is_red = false;
-                        sibling->is_red = true;
+                    if (sibling->right == nullptr ||
+                        !sibling->right->is_red()) {
+                        sibling->left()->is_red(false);
+                        sibling->is_red(true);
                         right_rotate(sibling);
                         sibling = parent->right;
                     }
-                    sibling->is_red = parent->is_red;
-                    parent->is_red = false;
-                    sibling->right->is_red = false;
+                    sibling->is_red(parent->is_red());
+                    parent->is_red(false);
+                    sibling->right->is_red(false);
                     left_rotate(parent);
                     node = root_;
                     break;
                 }
             } else {
-                node_type* sibling = parent->left;
-                if (sibling->is_red) {
-                    sibling->is_red = false;
-                    parent->is_red = true;
+                node_type* sibling = parent->left();
+                if (sibling->is_red()) {
+                    sibling->is_red(false);
+                    parent->is_red(true);
                     right_rotate(parent);
-                    sibling = parent->left;
+                    sibling = parent->left();
                 }
-                if ((sibling->right == nullptr || !sibling->right->is_red) &&
-                    (sibling->left == nullptr || !sibling->left->is_red)) {
-                    sibling->is_red = true;
+                if ((sibling->right == nullptr || !sibling->right->is_red()) &&
+                    (sibling->left() == nullptr ||
+                     !sibling->left()->is_red())) {
+                    sibling->is_red(true);
                     node = parent;
                     parent = node->parent;
                 } else {
-                    if (sibling->left == nullptr || !sibling->left->is_red) {
-                        sibling->right->is_red = false;
-                        sibling->is_red = true;
+                    if (sibling->left() == nullptr ||
+                        !sibling->left()->is_red()) {
+                        sibling->right->is_red(false);
+                        sibling->is_red(true);
                         left_rotate(sibling);
-                        sibling = parent->left;
+                        sibling = parent->left();
                     }
-                    sibling->is_red = parent->is_red;
-                    parent->is_red = false;
-                    sibling->left->is_red = false;
+                    sibling->is_red(parent->is_red());
+                    parent->is_red(false);
+                    sibling->left()->is_red(false);
                     right_rotate(parent);
                     node = root_;
                     break;
@@ -871,7 +891,7 @@ class set
             }
         }
         if (node != nullptr)
-            node->is_red = false;
+            node->is_red(false);
     }
 
     node_type* root_;

ctl/string.cc

@@ -21,6 +21,9 @@
 #include <__atomic/fence.h>
 #include <stdckdint.h>
 
+#include "libc/mem/mem.h"
+#include "libc/str/str.h"
+
 namespace ctl {
 
 void

ctl/string_view.h

@@ -1,7 +1,7 @@
 // -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
 // vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-#ifndef COSMOPOLITAN_CTL_STRINGVIEW_H_
-#define COSMOPOLITAN_CTL_STRINGVIEW_H_
+#ifndef CTL_STRINGVIEW_H_
+#define CTL_STRINGVIEW_H_
 #include "utility.h"
 
 namespace ctl {
@@ -157,4 +157,4 @@ struct string_view
 
 } // namespace ctl
 
-#endif // COSMOPOLITAN_CTL_STRINGVIEW_H_
+#endif // CTL_STRINGVIEW_H_

ctl/vector.h

@@ -525,7 +525,7 @@ class vector
         capacity_ = new_capacity;
     }
 
-    Allocator alloc_;
+    [[no_unique_address]] Allocator alloc_;
     pointer data_;
     size_type size_;
     size_type capacity_;

dsp/core/core.h

@@ -9,14 +9,13 @@ int mulaw(int);
 int unmulaw(int);
 void *double2byte(long, const void *, double, double) vallocesque;
 void *byte2double(long, const void *, double, double) vallocesque;
-void *dct(float[restrict hasatleast 8][8], unsigned, float, float, float, float,
-          float);
-void *dctjpeg(float[restrict hasatleast 8][8], unsigned);
+void *dct(float[hasatleast 8][8], unsigned, float, float, float, float, float);
+void *dctjpeg(float[hasatleast 8][8], unsigned);
 double det3(const double[3][3]) nosideeffect;
-void *inv3(double[restrict 3][3], const double[restrict 3][3], double);
-void *matmul3(double[restrict 3][3], const double[3][3], const double[3][3]);
-void *vmatmul3(double[restrict 3], const double[3], const double[3][3]);
-void *matvmul3(double[restrict 3], const double[3][3], const double[3]);
+void *inv3(double[3][3], const double[3][3], double);
+void *matmul3(double[3][3], const double[3][3], const double[3][3]);
+void *vmatmul3(double[3], const double[3], const double[3][3]);
+void *matvmul3(double[3], const double[3][3], const double[3]);
 double rgb2stdtv(double) pureconst;
 double rgb2lintv(double) pureconst;
 double rgb2stdpc(double, double) pureconst;

dsp/core/dct.c

@@ -65,8 +65,8 @@
  *
  * @cost ~100ns
  */
-void *dct(float M[restrict hasatleast 8][8], unsigned stride, float c0,
-          float c1, float c2, float c3, float c4) {
+void *dct(float M[hasatleast 8][8], unsigned stride, float c0, float c1,
+          float c2, float c3, float c4) {
   unsigned y, x;
   for (y = 0; y < stride * 8; y += stride) {
     DCT(M[y][0], M[y][1], M[y][2], M[y][3], M[y][4], M[y][5], M[y][6], M[y][7],
@@ -79,7 +79,7 @@ void *dct(float M[restrict hasatleast 8][8], unsigned stride, float c0,
   return M;
 }
 
-void *dctjpeg(float M[restrict hasatleast 8][8], unsigned stride) {
+void *dctjpeg(float M[hasatleast 8][8], unsigned stride) {
   return dct(M, stride, .707106781f, .382683433f, .541196100f, 1.306562965f,
              .707106781f);
 }

dsp/core/inv3.c

@@ -30,7 +30,7 @@
  * @define 𝐀⁻¹=𝐁 such that 𝐀×𝐁=𝐁×𝐀=𝐈ₙ
  * @see det3()
  */
-void *inv3(double B[restrict 3][3], const double A[restrict 3][3], double d) {
+void *inv3(double B[3][3], const double A[3][3], double d) {
   d = d ? 1 / d : NAN;
   B[0][0] = (A[1][1] * A[2][2] - A[2][1] * A[1][2]) * d;
   B[0][1] = (A[2][1] * A[0][2] - A[0][1] * A[2][2]) * d;

dsp/core/matmul3.c

@@ -22,8 +22,7 @@
 /**
  * Multiplies 3×3 matrices.
  */
-void *matmul3(double R[restrict 3][3], const double A[3][3],
-              const double B[3][3]) {
+void *matmul3(double R[3][3], const double A[3][3], const double B[3][3]) {
   int i, j, k;
   memset(R, 0, sizeof(double) * 3 * 3);
   for (i = 0; i < 3; ++i) {

dsp/core/matvmul3.c

@@ -23,7 +23,7 @@
  *
  * @see vmatmul3() for noncommutative corollary
  */
-void *matvmul3(double R[restrict 3], const double M[3][3], const double V[3]) {
+void *matvmul3(double R[3], const double M[3][3], const double V[3]) {
   R[0] = V[0] * M[0][0] + V[1] * M[0][1] + V[2] * M[0][2];
   R[1] = V[0] * M[1][0] + V[1] * M[1][1] + V[2] * M[1][2];
   R[2] = V[0] * M[2][0] + V[1] * M[2][1] + V[2] * M[2][2];

dsp/core/scalevolume.c

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

dsp/core/vmatmul3.c

@@ -23,7 +23,7 @@
  *
  * @see matvmul3() for noncommutative corollary
  */
-void *vmatmul3(double R[restrict 3], const double V[3], const double M[3][3]) {
+void *vmatmul3(double R[3], const double V[3], const double M[3][3]) {
   R[0] = V[0] * M[0][0] + V[1] * M[1][0] + V[2] * M[2][0];
   R[1] = V[0] * M[0][1] + V[1] * M[1][1] + V[2] * M[2][1];
   R[2] = V[0] * M[0][2] + V[1] * M[1][2] + V[2] * M[2][2];

dsp/mpeg/macroblock.c

@@ -31,9 +31,8 @@
 #include "dsp/mpeg/video.h"
 #include "libc/log/check.h"
 
-forceinline void plm_video_process_macroblock(plm_video_t *self,
-                                              uint8_t *restrict d,
-                                              uint8_t *restrict s, int motion_h,
+forceinline void plm_video_process_macroblock(plm_video_t *self, uint8_t *d,
+                                              uint8_t *s, int motion_h,
                                               int motion_v, bool interpolate,
                                               unsigned BW) {
   unsigned si, di, max_address;
@@ -155,17 +154,17 @@ forceinline void plm_video_process_macroblock(plm_video_t *self,
   }
 }
 
-void plm_video_process_macroblock_8(plm_video_t *self, uint8_t *restrict d,
-                                    uint8_t *restrict s, int motion_h,
-                                    int motion_v, bool interpolate) {
+void plm_video_process_macroblock_8(plm_video_t *self, uint8_t *d, uint8_t *s,
+                                    int motion_h, int motion_v,
+                                    bool interpolate) {
   DCHECK_ALIGNED(8, d);
   DCHECK_ALIGNED(8, s);
   plm_video_process_macroblock(self, d, s, motion_h, motion_v, interpolate, 8);
 }
 
-void plm_video_process_macroblock_16(plm_video_t *self, uint8_t *restrict d,
-                                     uint8_t *restrict s, int motion_h,
-                                     int motion_v, bool interpolate) {
+void plm_video_process_macroblock_16(plm_video_t *self, uint8_t *d, uint8_t *s,
+                                     int motion_h, int motion_v,
+                                     bool interpolate) {
   DCHECK_ALIGNED(16, d);
   DCHECK_ALIGNED(16, s);
   plm_video_process_macroblock(self, d, s, motion_h, motion_v, interpolate, 16);

dsp/mpeg/video.h

@@ -51,10 +51,10 @@ typedef struct plm_video_t {
   int assume_no_b_frames;
 } plm_video_t;
 
-void plm_video_process_macroblock_8(plm_video_t *, uint8_t *restrict,
-                                    uint8_t *restrict, int, int, bool);
-void plm_video_process_macroblock_16(plm_video_t *, uint8_t *restrict,
-                                     uint8_t *restrict, int, int, bool);
+void plm_video_process_macroblock_8(plm_video_t *, uint8_t *, uint8_t *, int,
+                                    int, bool);
+void plm_video_process_macroblock_16(plm_video_t *, uint8_t *, uint8_t *, int,
+                                     int, bool);
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_DSP_MPEG_VIDEO_H_ */

dsp/scale/gyarados.c

@@ -53,11 +53,11 @@ struct SamplingSolution {
 static double ComputeWeight(double x) {
   if (-1.5 < x && x < 1.5) {
     if (-.5 < x && x < .5) {
-      return .75 - SQR(x);
+      return.75 - SQR(x);
     } else if (x < 0) {
-      return .5 * SQR(x + 1.5);
+      return.5 * SQR(x + 1.5);
     } else {
-      return .5 * SQR(x - 1.5);
+      return.5 * SQR(x - 1.5);
     }
   } else {
     return 0;
@@ -149,12 +149,11 @@ static int Sharpen(int ax, int bx, int cx) {
 
 static void GyaradosImpl(long dyw, long dxw, int dst[dyw][dxw], long syw,
                          long sxw, const int src[syw][sxw], long dyn, long dxn,
-                         long syn, long sxn, int tmp0[restrict dyn][sxn],
-                         int tmp1[restrict dyn][sxn],
-                         int tmp2[restrict dyn][dxn], long yfn, long xfn,
-                         const short fyi[dyn][yfn], const short fyw[dyn][yfn],
-                         const short fxi[dxn][xfn], const short fxw[dxn][xfn],
-                         bool sharpen) {
+                         long syn, long sxn, int tmp0[dyn][sxn],
+                         int tmp1[dyn][sxn], int tmp2[dyn][dxn], long yfn,
+                         long xfn, const short fyi[dyn][yfn],
+                         const short fyw[dyn][yfn], const short fxi[dxn][xfn],
+                         const short fxw[dxn][xfn], bool sharpen) {
   long i;
   int eax, dy, dx, sx;
   for (sx = 0; sx < sxn; ++sx) {

dsp/scale/magikarp.c

@@ -106,9 +106,9 @@ void *Magkern2xY(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) {
   return p;
 }
 
-void *MagikarpY(long dys, long dxs, unsigned char d[restrict dys][dxs],
-                long sys, long sxs, const unsigned char s[sys][sxs], long yn,
-                long xn, const signed char K[8]) {
+void *MagikarpY(long dys, long dxs, unsigned char d[dys][dxs], long sys,
+                long sxs, const unsigned char s[sys][sxs], long yn, long xn,
+                const signed char K[8]) {
   long y, x;
   for (y = 0; y < yn; ++y) {
     for (x = 0; x < xn; ++x) {

dsp/tty/ident.c

@@ -21,7 +21,7 @@
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/intrin/weaken.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"

dsp/tty/ttymove.c

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/itoa8.h"
 #include "dsp/tty/tty.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 

dsp/tty/ttyraster.c

@@ -22,7 +22,7 @@
 #include "dsp/tty/ttyrgb.h"
 #include "dsp/tty/windex.h"
 #include "libc/assert.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"

examples/BUILD.mk

@@ -39,6 +39,7 @@ EXAMPLES_BINS =							\
 	$(EXAMPLES_COMS:%=%.dbg)
 
 EXAMPLES_DIRECTDEPS =						\
+	CTL							\
 	DSP_CORE						\
 	DSP_SCALE						\
 	DSP_TTY							\

examples/blas.cc

@@ -135,7 +135,7 @@ void sgemm(int m, int n, int k,      //
            const float *B, int ldb,  //
            float *C, int ldc) {
   int nth = sysconf(_SC_NPROCESSORS_ONLN);
-#pragma omp parallel for
+#pragma omp parallel for schedule(static)
   for (int ith = 0; ith < nth; ++ith) {
     ansiBLAS tb{k, A, lda, B, ldb, C, ldc, ith, nth};
     tb.matmul(m, n);

examples/crashreport2.cc

@@ -7,9 +7,8 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/math.h"
-#include "libc/runtime/runtime.h"
+#include <cosmo.h>
+#include <math.h>
 
 void crash(long x0, long x1, long x2,  //
            double v0, double v1, double v2) {

examples/greenbean.c

@@ -24,6 +24,7 @@
 #include <sys/socket.h>
 #include <time.h>
 #include "libc/mem/leaks.h"
+#include "libc/runtime/runtime.h"
 
 /**
  * @fileoverview greenbean lightweight threaded web server
@@ -288,10 +289,11 @@ int main(int argc, char *argv[]) {
   // print all the ips that 0.0.0.0 would bind
   // Cosmo's GetHostIps() API is much easier than ioctl(SIOCGIFCONF)
   uint32_t *hostips;
-  for (hostips = gc(GetHostIps()), i = 0; hostips[i]; ++i) {
+  for (hostips = GetHostIps(), i = 0; hostips[i]; ++i) {
     kprintf("listening on http://%hhu.%hhu.%hhu.%hhu:%hu\n", hostips[i] >> 24,
             hostips[i] >> 16, hostips[i] >> 8, hostips[i], PORT);
   }
+  free(hostips);
 
   // secure the server
   //
@@ -336,13 +338,12 @@ int main(int argc, char *argv[]) {
   sigaddset(&block, SIGHUP);
   sigaddset(&block, SIGQUIT);
   pthread_attr_t attr;
-  int pagesz = getauxval(AT_PAGESZ);
   unassert(!pthread_attr_init(&attr));
   unassert(!pthread_attr_setstacksize(&attr, 65536));
-  unassert(!pthread_attr_setguardsize(&attr, pagesz));
+  unassert(!pthread_attr_setguardsize(&attr, getpagesize()));
   unassert(!pthread_attr_setsigmask_np(&attr, &block));
   unassert(!pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0));
-  pthread_t *th = gc(calloc(threads, sizeof(pthread_t)));
+  pthread_t *th = calloc(threads, sizeof(pthread_t));
   for (i = 0; i < threads; ++i) {
     int rc;
     ++a_workers;
@@ -399,6 +400,7 @@ int main(int argc, char *argv[]) {
   for (i = 0; i < threads; ++i) {
     unassert(!pthread_join(th[i], 0));
   }
+  free(th);
 
   // close the server socket
   if (!IsWindows())

examples/helloplus.cc

@@ -0,0 +1,6 @@
+#include "ctl/ostream.h"
+
+int main(int argc, char* argv[]) {
+  ctl::cout << "hello world\n";
+  return 0;
+}

examples/kilo.c

@@ -60,6 +60,7 @@ Contact: [email protected]");
 #include "libc/calls/calls.h"
 #include "libc/calls/termios.h"
 #include "libc/calls/weirdtypes.h"
+#include "libc/ctype.h"
 #include "libc/errno.h"
 #include "libc/log/log.h"
 #include "libc/mem/alg.h"

examples/nesemu1.cc

@@ -19,7 +19,7 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/inttypes.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"

examples/ttyinfo.c

@@ -14,6 +14,7 @@
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/termios.h"
+#include "libc/ctype.h"
 #include "libc/errno.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"

examples/whois.c

@@ -30,6 +30,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/weirdtypes.h"
+#include "libc/ctype.h"
 #include "libc/errno.h"
 #include "libc/log/bsd.h"
 #include "libc/mem/mem.h"

libc/calls/assertfail.c

@@ -21,7 +21,7 @@
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describebacktrace.internal.h"
+#include "libc/intrin/describebacktrace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
 

libc/calls/cachestat.c

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 
 #include "libc/calls/cachestat.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 int sys_cachestat(int, struct cachestat_range *, struct cachestat *, uint32_t);
 

libc/calls/calls.h

@@ -69,48 +69,49 @@ COSMOPOLITAN_C_START_
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § system calls                                              ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
+/* clang-format off */
 
 typedef int sig_atomic_t;
 
 bool32 isatty(int) libcesque;
-char *getcwd(char *, size_t) dontthrow;
-char *realpath(const char *, char *) libcesque __wur;
+char *getcwd(char *, size_t) dontthrow __write_only(1, 2);
+char *realpath(const char *, char *) libcesque __wur __read_only(1) __write_only(2);
 char *ttyname(int) libcesque;
-int access(const char *, int) libcesque;
-int chdir(const char *) libcesque;
-int chmod(const char *, unsigned) libcesque;
-int chown(const char *, unsigned, unsigned) libcesque;
-int chroot(const char *) libcesque;
+int access(const char *, int) libcesque __read_only(1);
+int chdir(const char *) libcesque __read_only(1);
+int chmod(const char *, unsigned) libcesque __read_only(1);
+int chown(const char *, unsigned, unsigned) libcesque __read_only(1);
+int chroot(const char *) libcesque __read_only(1);
 int close(int) libcesque;
 int close_range(unsigned, unsigned, unsigned) libcesque;
 int closefrom(int) libcesque;
-int creat(const char *, unsigned) libcesque;
+int creat(const char *, unsigned) libcesque __read_only(1);
 int dup(int) libcesque;
 int dup2(int, int) libcesque;
 int dup3(int, int, int) libcesque;
-int execl(const char *, const char *, ...) nullterminated() libcesque;
-int execle(const char *, const char *, ...) nullterminated((1)) libcesque;
-int execlp(const char *, const char *, ...) nullterminated() libcesque;
-int execv(const char *, char *const[]) libcesque;
-int execve(const char *, char *const[], char *const[]) libcesque;
-int execvp(const char *, char *const[]) libcesque;
-int faccessat(int, const char *, int, int) libcesque;
+int execl(const char *, const char *, ...) nullterminated() libcesque __read_only(1) __read_only(2);
+int execle(const char *, const char *, ...) nullterminated((1)) libcesque __read_only(1) __read_only(2);
+int execlp(const char *, const char *, ...) nullterminated() libcesque __read_only(1) __read_only(2);
+int execv(const char *, char *const[]) libcesque __read_only(1) __read_only(2);
+int execve(const char *, char *const[], char *const[]) libcesque __read_only(1) __read_only(2) __read_only(3);
+int execvp(const char *, char *const[]) libcesque __read_only(1) __read_only(2);
+int faccessat(int, const char *, int, int) libcesque __read_only(2);
 int fchdir(int) libcesque;
 int fchmod(int, unsigned) libcesque;
-int fchmodat(int, const char *, unsigned, int) libcesque;
+int fchmodat(int, const char *, unsigned, int) libcesque __read_only(2);
 int fchown(int, unsigned, unsigned) libcesque;
-int fchownat(int, const char *, unsigned, unsigned, int) libcesque;
+int fchownat(int, const char *, unsigned, unsigned, int) libcesque __read_only(2);
 int fcntl(int, int, ...) libcesque;
 int fdatasync(int) libcesque;
-int fexecve(int, char *const[], char *const[]) libcesque;
+int fexecve(int, char *const[], char *const[]) libcesque __read_only(2) __read_only(3);
 int flock(int, int) libcesque;
 int fork(void) libcesque;
 int fsync(int) libcesque;
 int ftruncate(int, int64_t) libcesque;
-int getdomainname(char *, size_t) libcesque;
-int getgroups(int, unsigned[]) libcesque;
-int gethostname(char *, size_t) libcesque;
-int getloadavg(double *, int) libcesque;
+int getdomainname(char *, size_t) libcesque __write_only(1, 2);
+int getgroups(int, unsigned[]) libcesque __write_only(2, 1);
+int gethostname(char *, size_t) libcesque __write_only(1, 2);
+int getloadavg(double *, int) libcesque __write_only(1, 2);
 int getpgid(int) libcesque;
 int getpgrp(void) libcesque nosideeffect;
 int getpid(void) libcesque nosideeffect;
@@ -121,35 +122,35 @@ int ioctl(int, unsigned long, ...) libcesque;
 int issetugid(void) libcesque;
 int kill(int, int) libcesque;
 int killpg(int, int) libcesque;
-int lchmod(const char *, unsigned) libcesque;
-int lchown(const char *, unsigned, unsigned) libcesque;
-int link(const char *, const char *) libcesque;
-int linkat(int, const char *, int, const char *, int) libcesque;
-int mincore(void *, size_t, unsigned char *) libcesque;
-int mkdir(const char *, unsigned) libcesque;
-int mkdirat(int, const char *, unsigned) libcesque;
-int mknod(const char *, unsigned, uint64_t) libcesque;
+int lchmod(const char *, unsigned) libcesque __read_only(1);
+int lchown(const char *, unsigned, unsigned) libcesque __read_only(1);
+int link(const char *, const char *) libcesque __read_only(1) __read_only(2);
+int linkat(int, const char *, int, const char *, int) libcesque __read_only(2) __read_only(4);
+int mincore(void *, size_t, unsigned char *) libcesque __read_only(1) __write_only(3);
+int mkdir(const char *, unsigned) libcesque __read_only(1);
+int mkdirat(int, const char *, unsigned) libcesque __read_only(2);
+int mknod(const char *, unsigned, uint64_t) libcesque __read_only(1);
 int nice(int) libcesque;
-int open(const char *, int, ...) libcesque;
-int openat(int, const char *, int, ...) libcesque;
+int open(const char *, int, ...) libcesque __read_only(1);
+int openat(int, const char *, int, ...) libcesque __read_only(2);
 int pause(void) libcesque;
-int pipe(int[hasatleast 2]) libcesque;
-int pipe2(int[hasatleast 2], int) libcesque;
+int pipe(int[2]) libcesque __write_only(1);
+int pipe2(int[2], int) libcesque __write_only(1);
 int posix_fadvise(int, int64_t, int64_t, int) libcesque;
-int posix_madvise(void *, uint64_t, int) libcesque;
+int posix_madvise(void *, uint64_t, int) libcesque __read_write(1);
 int raise(int) libcesque;
 int reboot(int) libcesque;
-int remove(const char *) libcesque;
-int rename(const char *, const char *) libcesque;
-int renameat(int, const char *, int, const char *) libcesque;
-int rmdir(const char *) libcesque;
+int remove(const char *) libcesque __read_only(1);
+int rename(const char *, const char *) libcesque __read_only(1) __read_only(2);
+int renameat(int, const char *, int, const char *) libcesque __read_only(2) __read_only(4);
+int rmdir(const char *) libcesque __read_only(1);
 int sched_yield(void) libcesque;
 int setegid(unsigned) libcesque;
 int seteuid(unsigned) libcesque;
 int setfsgid(unsigned) libcesque;
 int setfsuid(unsigned) libcesque;
 int setgid(unsigned) libcesque;
-int setgroups(size_t, const unsigned[]) libcesque;
+int setgroups(size_t, const unsigned[]) libcesque __read_only(2);
 int setpgid(int, int) libcesque;
 int setpgrp(void) libcesque;
 int setpriority(int, unsigned, int) libcesque;
@@ -157,32 +158,32 @@ int setregid(unsigned, unsigned) libcesque;
 int setreuid(unsigned, unsigned) libcesque;
 int setsid(void) libcesque;
 int setuid(unsigned) libcesque;
-int shm_open(const char *, int, unsigned) libcesque;
-int shm_unlink(const char *) libcesque;
+int shm_open(const char *, int, unsigned) libcesque __read_only(1);
+int shm_unlink(const char *) libcesque __read_only(1);
 int sigignore(int) libcesque;
 int siginterrupt(int, int) libcesque;
-int symlink(const char *, const char *) libcesque;
-int symlinkat(const char *, int, const char *) libcesque;
+int symlink(const char *, const char *) libcesque __read_only(1) __read_only(2);
+int symlinkat(const char *, int, const char *) libcesque __read_only(1) __read_only(3);
 int tcgetpgrp(int) libcesque;
 int tcsetpgrp(int, int) libcesque;
-int truncate(const char *, int64_t) libcesque;
-int ttyname_r(int, char *, size_t) libcesque;
-int unlink(const char *) libcesque;
-int unlinkat(int, const char *, int) libcesque;
+int truncate(const char *, int64_t) libcesque __read_only(1);
+int ttyname_r(int, char *, size_t) libcesque __write_only(2, 3);
+int unlink(const char *) libcesque __read_only(1);
+int unlinkat(int, const char *, int) libcesque __read_only(2);
 int usleep(uint64_t) libcesque;
 int vfork(void) libcesque returnstwice;
-int wait(int *) libcesque;
-int waitpid(int, int *, int) libcesque;
+int wait(int *) libcesque __write_only(1);
+int waitpid(int, int *, int) libcesque __write_only(2);
 int64_t clock(void) libcesque;
-int64_t time(int64_t *) libcesque;
-ssize_t copy_file_range(int, long *, int, long *, size_t, unsigned) libcesque;
+int64_t time(int64_t *) libcesque __write_only(1);
+ssize_t copy_file_range(int, long *, int, long *, size_t, unsigned) libcesque __read_write(2) __read_write(4);
 ssize_t lseek(int, int64_t, int) libcesque;
-ssize_t pread(int, void *, size_t, int64_t) libcesque;
-ssize_t pwrite(int, const void *, size_t, int64_t) libcesque;
-ssize_t read(int, void *, size_t) libcesque;
-ssize_t readlink(const char *, char *, size_t) libcesque;
-ssize_t readlinkat(int, const char *, char *, size_t) libcesque;
-ssize_t write(int, const void *, size_t) libcesque;
+ssize_t pread(int, void *, size_t, int64_t) libcesque __write_only(2, 3);
+ssize_t pwrite(int, const void *, size_t, int64_t) libcesque __read_only(2);
+ssize_t read(int, void *, size_t) libcesque __write_only(2, 3);
+ssize_t readlink(const char *, char *, size_t) libcesque __read_only(1) __write_only(2, 3);
+ssize_t readlinkat(int, const char *, char *, size_t) libcesque __read_only(2) __write_only(3, 4);
+ssize_t write(int, const void *, size_t) libcesque __read_only(2);
 unsigned alarm(unsigned) libcesque;
 unsigned getegid(void) libcesque nosideeffect;
 unsigned geteuid(void) libcesque nosideeffect;
@@ -199,50 +200,50 @@ int prctl(int, ...) libcesque;
 int gettid(void) libcesque;
 int setresgid(unsigned, unsigned, unsigned) libcesque;
 int setresuid(unsigned, unsigned, unsigned) libcesque;
-int getresgid(unsigned *, unsigned *, unsigned *) libcesque;
-int getresuid(unsigned *, unsigned *, unsigned *) libcesque;
+int getresgid(unsigned *, unsigned *, unsigned *) libcesque __write_only(1) __write_only(2) __write_only(3);
+int getresuid(unsigned *, unsigned *, unsigned *) libcesque __write_only(1) __write_only(2) __write_only(3);
 char *get_current_dir_name(void) libcesque __wur;
-ssize_t splice(int, int64_t *, int, int64_t *, size_t, unsigned) libcesque;
-int memfd_create(const char *, unsigned int) libcesque;
-int execvpe(const char *, char *const[], char *const[]) libcesque;
-int euidaccess(const char *, int) libcesque;
-int eaccess(const char *, int) libcesque;
-int madvise(void *, uint64_t, int) libcesque;
-int getcpu(unsigned *, unsigned *) libcesque;
+ssize_t splice(int, int64_t *, int, int64_t *, size_t, unsigned) libcesque __read_write(2) __read_write(4);
+int memfd_create(const char *, unsigned int) libcesque __read_only(1);
+int execvpe(const char *, char *const[], char *const[]) libcesque __read_only(1) __read_only(2) __read_only(3);
+int euidaccess(const char *, int) libcesque __read_only(1);
+int eaccess(const char *, int) libcesque __read_only(1);
+int madvise(void *, uint64_t, int) libcesque __read_write(1);
+int getcpu(unsigned *, unsigned *) libcesque __write_only(1) __write_only(2);
 #endif
 
 #ifdef _COSMO_SOURCE
 bool32 fdexists(int) libcesque;
-bool32 fileexists(const char *) libcesque;
+bool32 fileexists(const char *) libcesque __read_only(1);
 bool32 ischardev(int) libcesque;
-bool32 isdirectory(const char *) libcesque;
-bool32 isexecutable(const char *) libcesque;
-bool32 isregularfile(const char *) libcesque;
-bool32 issymlink(const char *) libcesque;
-char *commandv(const char *, char *, size_t) libcesque;
-int __getcwd(char *, size_t) libcesque;
+bool32 isdirectory(const char *) libcesque __read_only(1);
+bool32 isexecutable(const char *) libcesque __read_only(1);
+bool32 isregularfile(const char *) libcesque __read_only(1);
+bool32 issymlink(const char *) libcesque __read_only(1);
+char *commandv(const char *, char *, size_t) libcesque __read_only(1) __write_only(2, 3);
+int __getcwd(char *, size_t) libcesque __write_only(1, 2);
 int clone(void *, void *, size_t, int, void *, void *, void *, void *);
 int fadvise(int, uint64_t, uint64_t, int) libcesque;
-int makedirs(const char *, unsigned) libcesque;
-int pivot_root(const char *, const char *) libcesque;
-int pledge(const char *, const char *) libcesque;
-int seccomp(unsigned, unsigned, void *) libcesque;
+int makedirs(const char *, unsigned) libcesque __read_only(1);
+int pivot_root(const char *, const char *) libcesque __read_only(1) __read_only(2);
+int pledge(const char *, const char *) libcesque __read_only(1) __read_only(2);
+int seccomp(unsigned, unsigned, void *) libcesque __read_only(3);
 int sys_iopl(int) libcesque;
 int sys_ioprio_get(int, int) libcesque;
 int sys_ioprio_set(int, int, int) libcesque;
-int sys_mlock(const void *, size_t) libcesque;
-int sys_mlock2(const void *, size_t, int) libcesque;
+int sys_mlock(const void *, size_t) libcesque __read_only(1);
+int sys_mlock2(const void *, size_t, int) libcesque __read_only(1);
 int sys_mlockall(int) libcesque;
-int sys_munlock(const void *, size_t) libcesque;
+int sys_munlock(const void *, size_t) libcesque __read_only(1);
 int sys_munlockall(void) libcesque;
 int sys_personality(uint64_t) libcesque;
 int sys_ptrace(int, ...) libcesque;
-int sysctl(int *, unsigned, void *, size_t *, void *, size_t) libcesque;
-int sysctlbyname(const char *, void *, size_t *, void *, size_t) libcesque;
-int sysctlnametomib(const char *, int *, size_t *) libcesque;
+int sysctl(int *, unsigned, void *, size_t *, void *, size_t) libcesque __read_write(1) __read_write(4) __read_write(5);
+int sysctlbyname(const char *, void *, size_t *, void *, size_t) libcesque __read_only(1) __write_only(2) __read_write(3) __read_only(4);
+int sysctlnametomib(const char *, int *, size_t *) libcesque __read_only(1) __write_only(2) __read_write(3);
 int tmpfd(void) libcesque;
-int touch(const char *, unsigned) libcesque;
-int unveil(const char *, const char *) libcesque;
+int touch(const char *, unsigned) libcesque __read_only(1);
+int unveil(const char *, const char *) libcesque __read_only(1);
 long ptrace(int, ...) libcesque;
 ssize_t copyfd(int, int, size_t) libcesque;
 ssize_t readansi(int, char *, size_t) libcesque;

libc/calls/chdir.c

@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/log.h"
 #include "libc/runtime/runtime.h"

libc/calls/chroot.c

@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**

libc/calls/clktck.c

@@ -20,7 +20,7 @@
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
 #include "libc/fmt/wintime.internal.h"
-#include "libc/intrin/getauxval.internal.h"
+#include "libc/intrin/getauxval.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/auxv.h"
 

libc/calls/clock_getres.c

@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/time.h"

libc/calls/clock_gettime.c

@@ -21,8 +21,8 @@
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/syslib.internal.h"
 
 #ifdef __aarch64__

libc/calls/clock_nanosleep-sys.c

@@ -22,8 +22,8 @@
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/thread.h"

libc/calls/clock_settime.c

@@ -21,8 +21,8 @@
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/struct/timeval.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
 

libc/calls/close-nt.c

@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/intrin/weaken.h"

libc/calls/close.c

@@ -20,14 +20,14 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sock/syscall_fd.internal.h"

libc/calls/close_range.c

@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**

libc/calls/closefrom.c

@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/sysv/errfuns.h"
 

libc/calls/commandv.c

@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/paths.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"

libc/calls/copy_file_range.c

@@ -27,8 +27,8 @@
 #include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
 

libc/calls/dup.c

@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/errfuns.h"

libc/calls/dup2.c

@@ -23,7 +23,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/str/str.h"

libc/calls/dup3-sysv.c

@@ -22,7 +22,7 @@
 #include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
 

libc/calls/dup3.c

@@ -23,7 +23,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/str/str.h"

libc/calls/faccessat.c

@@ -22,8 +22,8 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/consts/at.h"

libc/calls/fadvise.c

@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 

libc/calls/fchdir.c

@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**

libc/calls/fchmod-nt.c

@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/nt/enum/fileflagandattributes.h"

libc/calls/fchmod.c

@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**

libc/calls/fchmodat.c

@@ -22,8 +22,8 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/errfuns.h"

libc/calls/fchown.c

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/at.h"
 
 /**

libc/calls/fchownat.c

@@ -19,8 +19,8 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/errfuns.h"

libc/calls/fcntl-nt.c

@@ -20,7 +20,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/createfileflags.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/flock.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall-nt.internal.h"

libc/calls/fcntl.c

@@ -24,8 +24,8 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/str/str.h"

libc/calls/fdatasync.c

@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/errfuns.h"
 

libc/calls/fdexists.c

@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/f.h"
 
 /**

libc/calls/fileexists.c

@@ -23,7 +23,7 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/files.h"
 #include "libc/runtime/zipos.internal.h"

libc/calls/finddebugbinary.c

@@ -26,7 +26,7 @@
 #include "libc/elf/def.h"
 #include "libc/elf/tinyelf.internal.h"
 #include "libc/errno.h"
-#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/directmap.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/runtime.h"
 #include "libc/runtime/runtime.h"

libc/calls/flock-nt.c

@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/nt/enum/filelockflags.h"

libc/calls/flock.c

@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Acquires lock on file.

libc/calls/fstat-nt.c

@@ -19,14 +19,14 @@
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/calls/struct/stat.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/fmt/wintime.internal.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/bsr.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/macros.internal.h"
 #include "libc/mem/alloca.h"
 #include "libc/nt/enum/fileflagandattributes.h"

libc/calls/fstat.c

@@ -20,8 +20,8 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/stat.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/errfuns.h"

libc/calls/fstatat-nt.c

@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/struct/stat.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"

libc/calls/fstatat.c

@@ -23,8 +23,8 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/log.h"
 #include "libc/mem/alloca.h"

libc/calls/fstatfs.c

@@ -19,11 +19,11 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/statfs-meta.internal.h"
 #include "libc/calls/struct/statfs.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/stack.h"
 #include "libc/sysv/errfuns.h"
 

libc/calls/fsync.c

@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/errfuns.h"
 

libc/calls/ftruncate.c

@@ -23,7 +23,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**

libc/calls/futimens.c

@@ -19,7 +19,7 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**

libc/calls/futimes.c

@@ -21,7 +21,7 @@
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/struct/timeval.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**

libc/calls/getcwd.greg.c

@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/nt/files.h"
 #include "libc/stdio/sysparam.h"