Release Cosmopolitan v3.5.0

We now have a C++ red-black tree implementation that implements standard
template library compatible APIs while compiling 10x faster than libcxx.
It's not as beautiful as the red-black tree implementation in Plinko but
this will get the job done and the test proves it upholds all invariants

This change also restores CheckForMemoryLeaks() support and fixes a real
actual bug I discovered with Doug Lea's dlmalloc_inspect_all() function.

.git-blame-ignore-revs

@@ -0,0 +1,27 @@
+# Run this command to always ignore formatting commits in git blame
+# git config blame.ignoreRevsFile .git-blame-ignore-revs
+
+# Upgraded clang-format to 19.0.0git
+89fc95fefd40413706ff1bdaac2e8d98b328dbf1
+# vim c++ filetype in modelines
+04c6bc478e082263d67c41bedbd033dde2d429eb
+# Ran clang-format
+f032b5570b4cd87c6bb4abb54c0b98e69c939955
+# Applied clang-format update to repo
+6e6fc38935054db0534d5af4fb99c6193305b946
+# revert retabbing
+2b315626f3af765cdfbc61114647412cdb798b3a
+# more modeline errata
+3a8e01a77a7c97af0b16fb1651b230cee7f7d4c6
+# fix more vi modelines
+2fc507c98f53a76718f61f9a36602f86b5ac0cc9
+# flip et/noet in modelines
+e16a7d8f3b8f906c3ef76e79f57f3adfc7f25186
+# fix vi modelines
+394d998315f613a888cc6b6c051d4163bdf5cd6f
+# clang-format
+c0eacf2eb1e1c0b3bd4f71f12fef258f5b249c3f
+# ape-m1 formatting cleanup
+da8baf2aa5ce93b958aca90a0ae69f537806324b
+# Run clang-format on most sources
+369f9740de4534c28d0e81ab2afc99decbb9a3e6

.github/ISSUE_TEMPLATE/01-bug-low.yml

@@ -0,0 +1,59 @@
+name: Low Severity Bugs
+description: Used to report low severity bugs in cosmopolitan (e.g. cosmetic issues, non critical UI glitches)
+title: "Bug: "
+labels: ["bug", "low severity"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report! 
+        Please include information about your system, the steps to reproduce the bug, 
+        and the version of cosmopolitan that you are using. 
+        If possible, please provide a minimal code example that reproduces the bug.
+        You may also consider using function call tracing `--ftrace` or the lighter system call tracing `--strace`
+        for additional technical logging that may allow us to narrow down where the fault occurred.
+  - type: input
+    id: contact
+    attributes:
+      label: Contact Details
+      description: How can we get in touch with you if we need more info?
+      placeholder: ex. [email protected]
+    validations:
+      required: false
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+      description: Also tell us, what did you expect to happen?
+      placeholder: Tell us what you see!
+    validations:
+      required: true
+  - type: textarea
+    id: version
+    attributes:
+      label: Version
+      description: What version of our software are you running? (use `--version` to get a version string)
+      placeholder: "cosmocc (GCC) 12.3.0"
+    validations:
+      required: true
+  - type: dropdown
+    id: operating-system
+    attributes:
+      label: What operating system are you seeing the problem on?
+      multiple: true
+      options:
+        - Linux
+        - Mac
+        - Windows
+        - FreeBSD
+        - OpenBSD
+        - NetBSD
+        - BIOS
+    validations:
+      required: false
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell

.github/ISSUE_TEMPLATE/02-bug-medium.yml

@@ -0,0 +1,59 @@
+name: Medium Severity Bug
+description: Used to report medium severity bugs in cosmopolitan (e.g. Malfunctioning Features but generally still useable)
+title: "Bug: "
+labels: ["bug", "medium severity"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report! 
+        Please include information about your system, the steps to reproduce the bug, 
+        and the version of cosmopolitan that you are using. 
+        If possible, please provide a minimal code example that reproduces the bug.
+        You may also consider using function call tracing `--ftrace` or the lighter system call tracing `--strace`
+        for additional technical logging that may allow us to narrow down where the fault occurred.
+  - type: input
+    id: contact
+    attributes:
+      label: Contact Details
+      description: How can we get in touch with you if we need more info?
+      placeholder: ex. [email protected]
+    validations:
+      required: false
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+      description: Also tell us, what did you expect to happen?
+      placeholder: Tell us what you see!
+    validations:
+      required: true
+  - type: textarea
+    id: version
+    attributes:
+      label: Version
+      description: What version of our software are you running? (use `--version` to get a version string)
+      placeholder: "cosmocc (GCC) 12.3.0"
+    validations:
+      required: true
+  - type: dropdown
+    id: operating-system
+    attributes:
+      label: What operating system are you seeing the problem on?
+      multiple: true
+      options:
+        - Linux
+        - Mac
+        - Windows
+        - FreeBSD
+        - OpenBSD
+        - NetBSD
+        - BIOS
+    validations:
+      required: false
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell

.github/ISSUE_TEMPLATE/03-bug-high.yml

@@ -0,0 +1,59 @@
+name: High Severity Bug
+description: Used to report high severity bugs in cosmopolitan (e.g. Malfunctioning features hindering important common workflow)
+title: "Bug: "
+labels: ["bug", "high severity"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report! 
+        Please include information about your system, the steps to reproduce the bug, 
+        and the version of cosmopolitan that you are using. 
+        If possible, please provide a minimal code example that reproduces the bug.
+        You may also consider using function call tracing `--ftrace` or the lighter system call tracing `--strace`
+        for additional technical logging that may allow us to narrow down where the fault occurred.
+  - type: input
+    id: contact
+    attributes:
+      label: Contact Details
+      description: How can we get in touch with you if we need more info?
+      placeholder: ex. [email protected]
+    validations:
+      required: false
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+      description: Also tell us, what did you expect to happen?
+      placeholder: Tell us what you see!
+    validations:
+      required: true
+  - type: textarea
+    id: version
+    attributes:
+      label: Version
+      description: What version of our software are you running? (use `--version` to get a version string)
+      placeholder: "cosmocc (GCC) 12.3.0"
+    validations:
+      required: true
+  - type: dropdown
+    id: operating-system
+    attributes:
+      label: What operating system are you seeing the problem on?
+      multiple: true
+      options:
+        - Linux
+        - Mac
+        - Windows
+        - FreeBSD
+        - OpenBSD
+        - NetBSD
+        - BIOS
+    validations:
+      required: false
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell

.github/ISSUE_TEMPLATE/04-bug-critical.yml

@@ -0,0 +1,59 @@
+name: Critical Severity Bug
+description: Used to report critical severity bugs in cosmopolitan (e.g. Crashing, Corrupted, Dataloss)
+title: "Bug: "
+labels: ["bug", "critical severity"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report! 
+        Please include information about your system, the steps to reproduce the bug, 
+        and the version of cosmopolitan that you are using. 
+        If possible, please provide a minimal code example that reproduces the bug.
+        You may also consider using function call tracing `--ftrace` or the lighter system call tracing `--strace`
+        for additional technical logging that may allow us to narrow down where the fault occurred.
+  - type: input
+    id: contact
+    attributes:
+      label: Contact Details
+      description: How can we get in touch with you if we need more info?
+      placeholder: ex. [email protected]
+    validations:
+      required: false
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+      description: Also tell us, what did you expect to happen?
+      placeholder: Tell us what you see!
+    validations:
+      required: true
+  - type: textarea
+    id: version
+    attributes:
+      label: Version
+      description: What version of our software are you running? (use `--version` to get a version string)
+      placeholder: "cosmocc (GCC) 12.3.0"
+    validations:
+      required: true
+  - type: dropdown
+    id: operating-system
+    attributes:
+      label: What operating system are you seeing the problem on?
+      multiple: true
+      options:
+        - Linux
+        - Mac
+        - Windows
+        - FreeBSD
+        - OpenBSD
+        - NetBSD
+        - BIOS
+    validations:
+      required: false
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell

.github/ISSUE_TEMPLATE/05-enhancement.yml

@@ -0,0 +1,51 @@
+name: Enhancement template
+description: Used to request enhancements for cosmopolitan
+title: "Feature Request: "
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        [Please post your idea first in Discussion if there is not yet a consensus for this enhancement request. This will help to keep this issue tracker focused on enhancements that the community has agreed needs to be implemented.](https://github.com/jart/cosmopolitan/discussions/categories/ideas)
+
+  - type: checkboxes
+    id: prerequisites
+    attributes:
+      label: Prerequisites
+      description: Please confirm the following before submitting your enhancement request.
+      options:
+        - label: I am running the latest code. Mention the version if possible as well.
+          required: true
+        - label: I carefully followed the [README.md](https://github.com/jart/cosmopolitan/blob/master/README.md).
+          required: true
+        - label: I searched using keywords relevant to my issue to make sure that I am creating a new issue that is not already open (or closed).
+          required: true
+        - label: I reviewed the [Discussions](https://github.com/jart/cosmopolitan/discussions), and have a new and useful enhancement to share.
+          required: true
+
+  - type: textarea
+    id: feature-description
+    attributes:
+      label: Feature Description
+      description: Please provide a detailed written description of what you were trying to do, and what you expected `cosmopolitan` to do as an enhancement.
+      placeholder: Detailed description of the enhancement
+    validations:
+      required: true
+
+  - type: textarea
+    id: motivation
+    attributes:
+      label: Motivation
+      description: Please provide a detailed written description of reasons why this feature is necessary and how it is useful to `cosmopolitan` users.
+      placeholder: Explanation of why this feature is needed and its benefits
+    validations:
+      required: true
+
+  - type: textarea
+    id: possible-implementation
+    attributes:
+      label: Possible Implementation
+      description: If you have an idea as to how it can be implemented, please write a detailed description. Feel free to give links to external sources or share visuals that might be helpful to understand the details better.
+      placeholder: Detailed description of potential implementation
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/06-research.yml

@@ -0,0 +1,52 @@
+name: Research
+description: Track new technical research area
+title: "Research: "
+labels: ["research"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Don't forget to check for any [duplicate research issue tickets](https://github.com/jart/cosmopolitan/issues?q=is%3Aopen+is%3Aissue+label%3A%22research+%F0%9F%94%AC%22)
+
+  - type: checkboxes
+    id: research-stage
+    attributes:
+      label: Research Stage
+      description: Track general state of this research ticket
+      options:
+        - label: Background Research (Let's try to avoid reinventing the wheel)
+        - label: Hypothesis Formed (How do you think this will work and it's effect?)
+        - label: Strategy / Implementation Forming
+        - label: Analysis of results
+        - label: Debrief / Documentation (So people in the future can learn from us)
+
+  - type: textarea
+    id: background
+    attributes:
+      label: Previous existing literature and research
+      description: Whats the current state of the art and whats the motivation for this research?
+
+  - type: textarea
+    id: hypothesis
+    attributes:
+      label: Hypothesis
+      description: How do you think this will work and it's effect?
+
+  - type: textarea
+    id: implementation
+    attributes:
+      label: Implementation
+      description: Got an approach? e.g. a PR ready to go?
+
+  - type: textarea
+    id: analysis
+    attributes:
+      label: Analysis
+      description: How does the proposed implementation behave?
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell

.github/ISSUE_TEMPLATE/07-refactor.yml

@@ -0,0 +1,28 @@
+name: Refactor (Maintainers)
+description: Used to track refactoring opportunities
+title: "Refactor: "
+labels: ["refactor"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Don't forget to [check for existing refactor issue tickets](https://github.com/jart/cosmopolitan/issues?q=is%3Aopen+is%3Aissue+label%3Arefactoring) in case it's already covered.
+        Also you may want to check [Pull request refactor label as well](https://github.com/jart/cosmopolitan/pulls?q=is%3Aopen+is%3Apr+label%3Arefactoring) for duplicates too.
+
+  - type: textarea
+    id: background-description
+    attributes:
+      label: Background Description
+      description: Please provide a detailed written description of the pain points you are trying to solve.
+      placeholder: Detailed description behind your motivation to request refactor
+    validations:
+      required: true
+
+  - type: textarea
+    id: possible-approaches
+    attributes:
+      label: Possible Refactor Approaches
+      description: If you have some idea of possible approaches to solve this problem. You may want to make it a todo list.
+      placeholder: Your idea of possible refactoring opportunity/approaches
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,15 @@
+blank_issues_enabled: true
+contact_links:
+  - name: FAQ
+    url: https://github.com/jart/cosmopolitan/wiki/FAQ
+    about: Is your question a common one? You may want to check here first.
+  - name: Got an idea?
+    url: https://github.com/jart/cosmopolitan/discussions/categories/ideas
+    about: Pop it there. It may then become an enhancement ticket.
+  - name: Got a question?
+    url: https://github.com/jart/cosmopolitan/discussions/categories/q-a
+    about: Ask a question there!
+  - name: Want to contribute?
+    url: https://github.com/jart/cosmopolitan/wiki/contribute
+    about: Head to the contribution guide page of the wiki for areas you can help with
+

.github/labeler.yml

@@ -0,0 +1,49 @@
+# https://github.com/actions/labeler
+
+documentation:
+    - changed-files:
+        - any-glob-to-any-file:
+            - README.md
+            - LICENSE
+            - CONTRIBUTING.md
+            - libc/README.md
+            - tool/cosmocc/README.md
+            - third_party/getopt/README.txt
+build:
+    - changed-files:
+        - any-glob-to-any-file:
+            - build/**
+            - Makefile
+            - '*/*.mk'
+examples:
+    - changed-files:
+        - any-glob-to-any-file: examples/**
+devops:
+    - changed-files:
+        - any-glob-to-any-file:
+            - .github/**
+            - .clang-format
+dsp:
+    - changed-files:
+        - any-glob-to-any-file:
+            - dsp/**
+ape:
+    - changed-files:
+        - any-glob-to-any-file:
+            - ape/**
+libc:
+    - changed-files:
+        - any-glob-to-any-file:
+            - libc/**
+net:
+    - changed-files:
+        - any-glob-to-any-file:
+            - net/**
+third_party:
+    - changed-files:
+        - any-glob-to-any-file:
+            - third_party/**
+tool:
+    - changed-files:
+        - any-glob-to-any-file:
+            - tool/**

.github/workflows/labeler.yml

@@ -0,0 +1,17 @@
+name: "Pull Request Labeler"
+on:
+- pull_request_target
+
+jobs:
+  labeler:
+    permissions:
+      contents: read
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        repository: "jart/cosmopolitan"
+    - uses: actions/labeler@v5
+      with:
+        configuration-path: '.github/labeler.yml'

.vscode/c_cpp_properties.json

@@ -1,108 +0,0 @@
-{
-	"configurations": [
-		{
-			"name": "Win32",
-			"includePath": [
-				"${workspaceFolder}"
-			],
-			"cStandard": "c11",
-			"cppStandard": "c++11",
-			"forcedInclude": ["${workspaceFolder}/.vscode/vscode.h"],
-			"defines": [
-				"libcesque=",
-				"pureconst=",
-				"paramsnonnull(x)=",
-				"alignas(x)",
-				"alignof(x)",
-				"artificial=",
-				"__wur=",
-				"mayalias=",
-				"forceinline=",
-				"forcealign(x)=",
-				"scanfesque(x)=",
-				"strftimeesque(x)=",
-				"wontreturn=",
-				"textreal=",
-				"mallocesque=",
-				"callocesque=",
-				"vallocesque=",
-				"reallocesque=",
-				"strlenesque=",
-				"memcpyesque=",
-				"hasatleast=",
-				"noinline=",
-				"textexit=",
-				"returnstwice=",
-				"textwindows=",
-				"privileged=",
-				"dontinstrument=",
-				"nodebuginfo=",
-				"interruptfn=",
-				"optimizespeed=",
-				"forcealignargpointer=",
-				"dontasan=",
-				"dontubsan=",
-				"donothing=",
-				"nosideeffect=",
-				"unreachable=",,
-				"notpossible=",
-				"thatispacked=",
-				"dontthrow=",
-				"dontcallback=",
-				"relegated=",
-				"hidden=",
-				"textstartup=",
-				"returnsnonnull=",
-				"returnspointerwithnoaliases=",
-				"printfesque(x)=",
-				"attributeallocsize(x)=",
-				"returnsaligned(x)=",
-				"attributeallocalign(x)=",
-				"nullterminated(x)="
-			]
-		},
-		{
-			"name": "Linux",
-			"includePath": [
-				"${workspaceFolder}"
-			],
-			"cStandard": "gnu17",
-			"compilerPath": "${workspaceFolder}/o/third_party/gcc/bin/x86_64-linux-musl-gcc",
-			"compilerArgs": [
-				"-Wall",
-				"-Werror",
-				"-fdebug-prefix-map=${workspaceFolder}=",
-				"-frecord-gcc-switches",
-				"-Wa,-W",
-				"-Wa,-I.",
-				"-Wa,--noexecstack",
-				"-Og",
-				"-g",
-				"-gdescribe-dies",
-				"-msse3",
-				"-mno-red-zone",
-				"-fno-math-errno",
-				"-fno-trapping-math",
-				"-fno-fp-int-builtin-inexact",
-				"-fno-ident",
-				"-fno-common",
-				"-fno-gnu-unique",
-				"-fstrict-aliasing",
-				"-fstrict-overflow",
-				"-fno-semantic-interposition",
-				"-mno-omit-leaf-frame-pointer",
-				"-fno-jump-tables",
-				"-nostdinc",
-				"-iquote."
-			],
-			"forcedInclude": [
-				"libc/integral/normalize.inc"
-			],
-			"defines": [
-				"COSMO",
-				"MODE="
-			]
-		}
-	],
-	"version": 4
-}

.vscode/vscode.h

@@ -1,2 +0,0 @@
-#define __VSCODE_INTELLISENSE__ 1
-#include "libc/integral/normalize.inc"

Makefile

@@ -133,7 +133,7 @@ endif
 
 ifneq ($(findstring aarch64,$(MODE)),)
 ARCH = aarch64
-HOSTS ?= pi pi5 studio freebsdarm
+HOSTS ?= pi studio freebsdarm
 else
 ARCH = x86_64
 HOSTS ?= freebsd rhel7 xnu openbsd netbsd win10
@@ -149,9 +149,9 @@ export MODE
 export SOURCE_DATE_EPOCH
 export TMPDIR
 
-COSMOCC = .cosmocc/3.3.3
+COSMOCC = .cosmocc/3.3.5
 TOOLCHAIN = $(COSMOCC)/bin/$(ARCH)-linux-cosmo-
-DOWNLOAD := $(shell build/download-cosmocc.sh $(COSMOCC) 3.3.3 e4d0fa63cd79cc3bfff6c2d015f1776db081409907625aea8ad40cefc1996d08)
+DOWNLOAD := $(shell build/download-cosmocc.sh $(COSMOCC) 3.3.5 db78fd8d3f8706e9dff4be72bf71d37a3f12062f212f407e1c33bc4af3780dd0)
 
 AS = $(TOOLCHAIN)as
 CC = $(TOOLCHAIN)gcc
@@ -174,6 +174,7 @@ all:	o
 o:	o/$(MODE)
 o/$(MODE):			\
 	o/$(MODE)/ape		\
+	o/$(MODE)/ctl		\
 	o/$(MODE)/dsp		\
 	o/$(MODE)/net		\
 	o/$(MODE)/libc		\
@@ -255,10 +256,11 @@ include third_party/nsync/mem/BUILD.mk		# │  You can now use stdio
 include libc/proc/BUILD.mk			# │  You can now use threads
 include libc/dlopen/BUILD.mk			# │  You can now use processes
 include libc/thread/BUILD.mk			# │  You can finally call malloc()
+include ctl/BUILD.mk				# │
 include third_party/zlib/BUILD.mk		# │
 include libc/stdio/BUILD.mk			# │
 include tool/hello/BUILD.mk			# │
-include libc/time/BUILD.mk			# │
+include third_party/tz/BUILD.mk			# │
 include net/BUILD.mk				# │
 include third_party/vqsort/BUILD.mk		# │
 include libc/log/BUILD.mk			# │
@@ -299,6 +301,7 @@ include tool/viz/lib/BUILD.mk
 include tool/args/BUILD.mk
 include test/math/BUILD.mk
 include test/posix/BUILD.mk
+include test/ctl/BUILD.mk
 include test/libcxx/BUILD.mk
 include test/tool/args/BUILD.mk
 include third_party/linenoise/BUILD.mk
@@ -362,7 +365,6 @@ include test/libc/fmt/BUILD.mk
 include test/libc/time/BUILD.mk
 include test/libc/proc/BUILD.mk
 include test/libc/stdio/BUILD.mk
-include test/libc/release/BUILD.mk
 include test/libc/BUILD.mk
 include test/net/http/BUILD.mk
 include test/net/https/BUILD.mk
@@ -440,7 +442,7 @@ COSMOPOLITAN_OBJECTS =			\
 	LIBC_X				\
 	THIRD_PARTY_GETOPT		\
 	LIBC_LOG			\
-	LIBC_TIME			\
+	THIRD_PARTY_TZ			\
 	THIRD_PARTY_OPENMP		\
 	THIRD_PARTY_MUSL		\
 	THIRD_PARTY_ZLIB_GZ		\
@@ -452,6 +454,7 @@ COSMOPOLITAN_OBJECTS =			\
 	LIBC_THREAD			\
 	LIBC_PROC			\
 	THIRD_PARTY_NSYNC_MEM		\
+	CTL				\
 	LIBC_MEM			\
 	THIRD_PARTY_DLMALLOC		\
 	LIBC_DLOPEN			\
@@ -505,7 +508,6 @@ COSMOPOLITAN_H_PKGS =			\
 	LIBC_STR			\
 	LIBC_SYSV			\
 	LIBC_THREAD			\
-	LIBC_TIME			\
 	LIBC_TINYMATH			\
 	LIBC_X				\
 	LIBC_VGA			\
@@ -521,6 +523,7 @@ COSMOPOLITAN_H_PKGS =			\
 
 COSMOCC_PKGS =				\
 	$(COSMOPOLITAN_H_PKGS)		\
+	CTL				\
 	THIRD_PARTY_AARCH64		\
 	THIRD_PARTY_LIBCXX		\
 	THIRD_PARTY_LIBCXXABI		\
@@ -543,15 +546,6 @@ COSMOPOLITAN_H_ROOT_HDRS =						\
 	libc/integral/normalize.inc					\
 	$(foreach x,$(COSMOPOLITAN_H_PKGS),$($(x)_HDRS))
 
-o/cosmopolitan.h.txt: Makefile
-	$(file >$@, $(call uniq,$(COSMOPOLITAN_H_ROOT_HDRS)))
-
-o/cosmopolitan.h: o/cosmopolitan.h.txt					\
-		$(wildcard libc/integral/*)				\
-		$(foreach x,$(COSMOPOLITAN_H_PKGS),$($(x)_HDRS))	\
-		$(foreach x,$(COSMOPOLITAN_H_PKGS),$($(x)_INCS))
-	@$(COMPILE) -AROLLUP -T$@ build/bootstrap/rollup @$< >>$@
-
 o/cosmopolitan.html: private .UNSANDBOXED = 1
 o/cosmopolitan.html:							\
 		o/$(MODE)/third_party/chibicc/chibicc.dbg		\
@@ -573,7 +567,6 @@ $(SRCS):					\
 
 ifeq ($(ARCH), x86_64)
 TOOLCHAIN_ARTIFACTS =				\
-	o/cosmopolitan.h			\
 	o/$(MODE)/ape/ape.lds			\
 	o/$(MODE)/libc/crt/crt.o		\
 	o/$(MODE)/ape/ape.elf			\

ape/BUILD.mk

@@ -162,7 +162,6 @@ o/$(MODE)/ape/ape-no-modify-self.o:		\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/thread/tls.h		\
-		libc/intrin/asancodes.h		\
 		libc/macho.internal.h		\
 		libc/macros.internal.h		\
 		libc/nexgen32e/uart.internal.h	\
@@ -189,7 +188,6 @@ o/$(MODE)/ape/ape-copy-self.o:			\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/thread/tls.h		\
-		libc/intrin/asancodes.h		\
 		libc/macho.internal.h		\
 		libc/macros.internal.h		\
 		libc/nexgen32e/uart.internal.h	\
@@ -254,7 +252,24 @@ o/$(MODE)/ape:	$(APE_CHECKS)			\
 endif
 
 # these assembly files are safe to build on aarch64
-o/$(MODE)/ape/ape.o: ape/ape.S
+o/$(MODE)/ape/ape.o:				\
+		ape/ape.S			\
+		ape/ape.h			\
+		libc/dce.h			\
+		libc/elf/def.h			\
+		ape/relocations.h		\
+		libc/thread/tls.h		\
+		ape/ape.internal.h		\
+		ape/macros.internal.h		\
+		libc/macho.internal.h		\
+		libc/macros.internal.h		\
+		libc/sysv/consts/prot.h		\
+		libc/nt/pedef.internal.h	\
+		libc/runtime/pc.internal.h	\
+		libc/runtime/e820.internal.h	\
+		libc/runtime/mman.internal.h	\
+		libc/nexgen32e/uart.internal.h	\
+		libc/calls/metalfile.internal.h
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 
 o/$(MODE)/ape/ape.lds:				\

ape/aarch64.lds

@@ -1,6 +1,7 @@
 /*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
 │ vi: set et sts=2 sw=2 fenc=utf-8                                         :vi │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/sysv/consts/prot.h"
 #include "libc/thread/tls.h"
 
 ENTRY(_start)
@@ -285,15 +286,18 @@ SECTIONS {
 
 ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000;
 ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : 8 * 1024 * 1024;
-ape_stack_align = DEFINED(ape_stack_align) ? ape_stack_align : 16;
+ape_stack_align = DEFINED(ape_stack_align) ? MAX(ape_stack_align, 16) : 16;
+ape_stack_prot = PROT_READ | PROT_WRITE;
 ape_stack_round = -ape_stack_align;
 
+ASSERT(ape_stack_align < 1048576, "stack align too big");
+ASSERT(!(ape_stack_align & (ape_stack_align - 1)), "stack align must be two power");
+
 _tls_size = _tbss_end - _tdata_start;
 _tdata_size = _tdata_end - _tdata_start;
 _tbss_size = _tbss_end - _tbss_start;
 _tbss_offset = _tbss_start - _tdata_start;
 _tls_content = (_tdata_end - _tdata_start) + (_tbss_end - _tbss_start);
-_tls_align = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
-
-ASSERT(ALIGNOF(.tdata) <= TLS_ALIGNMENT && ALIGNOF(.tbss) <= TLS_ALIGNMENT,
-       "_Thread_local _Alignof can't exceed TLS_ALIGNMENT");
+_tdata_align = ALIGNOF(.tdata);
+_tbss_align = ALIGNOF(.tbss);
+_tls_align = MAX(TLS_ALIGNMENT, MAX(ALIGNOF(.tdata), ALIGNOF(.tbss)));

ape/ape-m1.c

@@ -146,6 +146,9 @@ struct Syslib {
 #define AT_RANDOM                   25
 #define AT_EXECFN                   31
 
+#define EF_APE_MODERN      0x101ca75
+#define EF_APE_MODERN_MASK 0x1ffffff
+
 #define AUXV_WORDS 31
 
 /* from the xnu codebase */
@@ -799,7 +802,7 @@ __attribute__((__noreturn__)) static void Spawn(const char *exe, int fd,
 }
 
 static const char *TryElf(struct ApeLoader *M, union ElfEhdrBuf *ebuf,
-                          const char *exe, int fd, long *sp, long *auxv,
+                          char *exe, int fd, long *sp, long *auxv,
                           char *execfn) {
   long i, rc;
   unsigned size;
@@ -820,6 +823,10 @@ static const char *TryElf(struct ApeLoader *M, union ElfEhdrBuf *ebuf,
   if (e->e_machine != EM_AARCH64) {
     return "couldn't find ELF header with ARM64 machine type";
   }
+  if ((e->e_flags & EF_APE_MODERN_MASK) != EF_APE_MODERN && sp[0] > 0) {
+    /* change argv[0] to resolved path for older binaries */
+    ((char **)(sp + 1))[0] = exe;
+  }
   if (e->e_phentsize != sizeof(struct ElfPhdr)) {
     Pexit(exe, 0, "e_phentsize is wrong");
   }

ape/ape.S

@@ -1,5 +1,5 @@
 /*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8 nofixeol                        :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2020 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
@@ -196,7 +196,7 @@ ape_mz:
 	.quad	ape_elf_entry			//  18: e_entry
 	.quad	ape_elf_phoff			//  20: e_phoff
 	.quad	ape_elf_shoff			//  28: e_shoff
-	.long	0				//  30: e_flags
+	.long	0x101ca75			//  30: ape e_flags
 	.short	64				//  34: e_ehsize
 	.short	56				//  36: e_phentsize
 	.short	ape_elf_phnum			//  38: e_phnum
@@ -669,7 +669,7 @@ apesh:	.ascii	"\n@\n#'\"\n"			// sixth edition shebang
 	.shstub	    ape_elf_entry,8		//  18: e_entry
 	.shstub	    ape_elf_phoff,8		//  20: e_phoff
 	.shstub	    ape_elf_shoff,8		//  28: e_shoff
-	.ascii	    "\\0\\0\\0\\0"		//  30: e_flags
+	.ascii	    "\\165\\312\\1\\1"		//  30: ape e_flags
 	.ascii	    "\\100\\0"			//  34: e_ehsize
 	.ascii	    "\\070\\0"			//  36: e_phentsize
 	.shstub	    ape_elf_phnum,2		//  38: e_phnum
@@ -1036,7 +1036,7 @@ ape_pe:	.ascin	"PE",4
 	.quad	ape_pe_base		// ImageBase
 	.long	ape_pe_sectionalignment	// SectionAlignment
 	.long	ape_pe_filealignment	// FileAlignment
-	.short	v_ntversion		// MajorOperatingSystemVersion
+	.short	10			// MajorOperatingSystemVersion
 	.short	0			// MinorOperatingSystemVersion
 	.short	0			// MajorImageVersion
 	.short	0			// MinorImageVersion

ape/ape.lds

@@ -553,7 +553,9 @@ _tdata_size = _tdata_end - _tdata_start;
 _tbss_size = _tbss_end - _tbss_start;
 _tbss_offset = _tbss_start - _tdata_start;
 _tls_content = (_tdata_end - _tdata_start) + (_tbss_end - _tbss_start);
-_tls_align = 1;
+_tdata_align = ALIGNOF(.tdata);
+_tbss_align = ALIGNOF(.tbss);
+_tls_align = MAX(TLS_ALIGNMENT, MAX(ALIGNOF(.tdata), ALIGNOF(.tbss)));
 
 ape_cod_offset = 0;
 ape_cod_vaddr = ADDR(.head);
@@ -586,9 +588,12 @@ ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000;
 ape_stack_paddr = ape_ram_paddr + ape_ram_filesz;
 ape_stack_filesz = 0;
 ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : 8 * 1024 * 1024;
-ape_stack_align = DEFINED(ape_stack_align) ? ape_stack_align : 16;
+ape_stack_align = DEFINED(ape_stack_align) ? MAX(ape_stack_align, 16) : 16;
 ape_stack_round = -ape_stack_align;
 
+ASSERT(ape_stack_align < 1048576, "stack align too big");
+ASSERT(!(ape_stack_align & (ape_stack_align - 1)), "stack align must be two power");
+
 ape_note_offset = ape_cod_offset + (ape_note - ape_cod_vaddr);
 ape_note_filesz = ape_note_end - ape_note;
 ape_note_memsz = ape_note_filesz;
@@ -713,7 +718,6 @@ ape_idataz = LINK_WINDOWS ? RVA(ape_idata_iat) : 0;
 ape_idata_iatsize = LINK_WINDOWS ? ape_idata_iatend - ape_idata_iat : 0;
 ape_idata = LINK_WINDOWS ? RVA(ape_idata_idt) : 0;
 ape_idata_idtsize = LINK_WINDOWS ? ape_idata_idtend - ape_idata_idt : 0;
-v_ntversion = LINK_WINDOWS ? 6 : 1;
 v_ntdllchar = LINK_WINDOWS ? 288 : 0;
 v_ntsubversion = LINK_WINDOWS ? 6 : 5;
 v_ntsubsystem = (LINK_WINDOWS

ape/apeinstall.sh

@@ -137,13 +137,20 @@ if [ x"$(uname -s)" = xLinux ]; then
     echo done >&2
   fi
 
+  uname_r="$(uname -r)"
+  if printf '%s\n%s\n' 5.12 "$uname_r" | sort -CV; then
+    FLAGS=FP
+  else
+    FLAGS=F
+  fi
+
   echo >&2
   echo registering APE with binfmt_misc >&2
   echo you may need to edit configs to persist across reboot >&2
-  echo '$SUDO sh -c "echo '"'"':APE:M::MZqFpD::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
-  $SUDO sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
-  echo '$SUDO sh -c "echo '"'"':APE-jart:M::jartsr::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
-  $SUDO sh -c "echo ':APE-jart:M::jartsr::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
+  echo '$SUDO sh -c "echo '"'"':APE:M::MZqFpD::/usr/bin/ape:'"$FLAGS'"' >/proc/sys/fs/binfmt_misc/register"' >&2
+  $SUDO sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:$FLAGS' >/proc/sys/fs/binfmt_misc/register" || exit
+  echo '$SUDO sh -c "echo '"'"':APE-jart:M::jartsr::/usr/bin/ape:'"$FLAGS'"' >/proc/sys/fs/binfmt_misc/register"' >&2
+  $SUDO sh -c "echo ':APE-jart:M::jartsr::/usr/bin/ape:$FLAGS' >/proc/sys/fs/binfmt_misc/register" || exit
   echo done >&2
 
   if [ x"$(cat /proc/sys/fs/binfmt_misc/status)" = xdisabled ]; then

ape/loader.c

@@ -152,6 +152,9 @@
 #define PR_SET_MM                   35
 #define PR_SET_MM_EXE_FILE          13
 
+#define EF_APE_MODERN      0x101ca75
+#define EF_APE_MODERN_MASK 0x1ffffff
+
 #define READ32(S)                                                      \
   ((unsigned)(255 & (S)[3]) << 030 | (unsigned)(255 & (S)[2]) << 020 | \
    (unsigned)(255 & (S)[1]) << 010 | (unsigned)(255 & (S)[0]) << 000)
@@ -834,6 +837,10 @@ static const char *TryElf(struct ApeLoader *M, union ElfEhdrBuf *ebuf,
     return "couldn't find ELF header with x86-64 machine type";
   }
 #endif
+  if ((e->e_flags & EF_APE_MODERN_MASK) != EF_APE_MODERN && sp[0] > 0) {
+    /* change argv[0] to resolved path for older binaries */
+    ((char **)(sp + 1))[0] = exe;
+  }
   if (e->e_phentsize != sizeof(struct ElfPhdr)) {
     Pexit(os, exe, 0, "e_phentsize is wrong");
   }

ape/macros.internal.h

@@ -84,9 +84,10 @@
 /* clang-format on */
 #elif defined(__LINKER__)
 
-#define BCX_NIBBLE(X) ((((X)&0xf) > 0x9) ? ((X)&0xf) + 0x37 : ((X)&0xf) + 0x30)
-#define BCX_OCTET(X)  ((BCX_NIBBLE((X) >> 4) << 8) | (BCX_NIBBLE((X) >> 0) << 0))
-#define BCX_INT16(X)  ((BCX_OCTET((X) >> 8) << 16) | (BCX_OCTET((X) >> 0) << 0))
+#define BCX_NIBBLE(X) \
+  ((((X) & 0xf) > 0x9) ? ((X) & 0xf) + 0x37 : ((X) & 0xf) + 0x30)
+#define BCX_OCTET(X) ((BCX_NIBBLE((X) >> 4) << 8) | (BCX_NIBBLE((X) >> 0) << 0))
+#define BCX_INT16(X) ((BCX_OCTET((X) >> 8) << 16) | (BCX_OCTET((X) >> 0) << 0))
 #define BCXSTUB(SYM, X)                      \
   HIDDEN(SYM##_bcx0 = BCX_INT16((X) >> 48)); \
   HIDDEN(SYM##_bcx1 = BCX_INT16((X) >> 32)); \
@@ -98,12 +99,12 @@
  *
  * <p>This allows linker scripts to generate printf commands.
  */
-#define BCO_OCTET(X) (((X)&0x7) + 0x30)
+#define BCO_OCTET(X) (((X) & 0x7) + 0x30)
 #define BCOB_UNIT(X)                                           \
   ((BCO_OCTET((X) >> 0) << 24) | (BCO_OCTET((X) >> 3) << 16) | \
-   (BCO_OCTET(((X)&0xff) >> 6) << 8) | 0x5c)
+   (BCO_OCTET(((X) & 0xff) >> 6) << 8) | 0x5c)
 
-#define PFBYTE(SYM, X, I) HIDDEN(SYM##_bcs##I = BCOB_UNIT((X) >> ((I)*8)))
+#define PFBYTE(SYM, X, I) HIDDEN(SYM##_bcs##I = BCOB_UNIT((X) >> ((I) * 8)))
 #define PFSTUB2(SYM, X) \
   HIDDEN(SYM = (X));    \
   PFBYTE(SYM, X, 0);    \
@@ -140,23 +141,16 @@
    : (X) < 10000000  ? BCD_RIGHT(BCD_SMEAR((X) / 1000))  \
    : (X) < 100000000 ? BCD_RIGHT(BCD_SMEAR((X) / 10000)) \
                      : 0xffffffffffffffff)
-#define BCD_RIGHT(X) \
-  (((X)) < 10000     ? 0x20202020                  \
-   : (X) < 100000    ? 0x20202030 +                \
-                       (X) % 10                    \
-   : (X) < 1000000   ? 0x20203030 +                \
-                       ((X) / 10) % 10 +           \
-                       (X) % 10 * 0x100            \
-   : (X) < 10000000  ? 0x20303030 +                \
-                       ((X) / 100) % 10 +          \
-                       ((X) / 10) % 10 * 0x100 +   \
-                       (X) % 10 * 0x10000          \
-   : (X) < 100000000 ? 0x30303030 +                \
-                       ((X) / 1000) % 10 +         \
-                       ((X) / 100) % 10 * 0x100 +  \
-                       ((X) / 10) % 10 * 0x10000 + \
-                       (X) % 10 * 0x1000000        \
-                     : 0xffffffffffffffff)
+#define BCD_RIGHT(X)                                                   \
+  (((X)) < 10000    ? 0x20202020                                       \
+   : (X) < 100000   ? 0x20202030 + (X) % 10                            \
+   : (X) < 1000000  ? 0x20203030 + ((X) / 10) % 10 + (X) % 10 * 0x100  \
+   : (X) < 10000000 ? 0x20303030 + ((X) / 100) % 10 +                  \
+                          ((X) / 10) % 10 * 0x100 + (X) % 10 * 0x10000 \
+   : (X) < 100000000                                                   \
+       ? 0x30303030 + ((X) / 1000) % 10 + ((X) / 100) % 10 * 0x100 +   \
+             ((X) / 10) % 10 * 0x10000 + (X) % 10 * 0x1000000          \
+       : 0xffffffffffffffff)
 
 /**
  * Laying out the GDT entries for a TSS for bare metal operation.
@@ -165,15 +159,11 @@
   HIDDEN(SYM##_desc_ent0 = TSSDESC_ENT0(BASE, LIM)); \
   HIDDEN(SYM##_desc_ent1 = TSSDESC_ENT1(BASE));      \
   ASSERT((LIM) >= 0 && (LIM) <= 0xffff, "bare metal TSS is suspiciously fat")
-#define TSSDESC_ENT0(BASE, LIM)                \
-  (((LIM)        <<  0 & 0x000000000000ffff) | \
-   ((BASE)       << 16 & 0x000000ffffff0000) | \
-    0x89         << 40                       | \
-   ((LIM)  >> 16 << 48 & 0x000f000000000000) | \
-    0x2          << 52                       | \
+#define TSSDESC_ENT0(BASE, LIM)                                              \
+  (((LIM) << 0 & 0x000000000000ffff) | ((BASE) << 16 & 0x000000ffffff0000) | \
+   0x89 << 40 | ((LIM) >> 16 << 48 & 0x000f000000000000) | 0x2 << 52 |       \
    ((BASE) >> 24 << 56 & 0xff00000000000000))
-#define TSSDESC_ENT1(BASE)                     \
-   ((BASE) >> 32 <<  0 & 0x00000000ffffffff)
+#define TSSDESC_ENT1(BASE) ((BASE) >> 32 << 0 & 0x00000000ffffffff)
 
 #endif /* __ASSEMBLER__ */
 #endif /* APE_MACROS_H_ */

ape/sections.internal.h

@@ -16,6 +16,8 @@ extern unsigned char _tdata_end[] __attribute__((__weak__));
 extern unsigned char _tbss_start[] __attribute__((__weak__));
 extern unsigned char _tbss_end[] __attribute__((__weak__));
 extern unsigned char _tls_align[] __attribute__((__weak__));
+extern unsigned char _tdata_align[] __attribute__((__weak__));
+extern unsigned char _tbss_align[] __attribute__((__weak__));
 extern unsigned char __test_start[] __attribute__((__weak__));
 extern unsigned char __ro[] __attribute__((__weak__));
 extern unsigned char __data_start[] __attribute__((__weak__));

build/config.mk

@@ -11,20 +11,20 @@
 #
 ifeq ($(MODE),)
 ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
+CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CCFLAGS += -O2 $(BACKTRACES)
 CONFIG_CPPFLAGS += -DSYSDEBUG
 TARGET_ARCH ?= -msse3
 endif
 ifeq ($(MODE), x86_64)
 ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
+CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CCFLAGS += -O2 $(BACKTRACES)
 CONFIG_CPPFLAGS += -DSYSDEBUG
 endif
 ifeq ($(MODE), aarch64)
 ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
+CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CCFLAGS += -O2 $(BACKTRACES)
 CONFIG_CPPFLAGS += -DSYSDEBUG
 endif
@@ -38,13 +38,13 @@ endif
 #
 ifeq ($(MODE), zero)
 ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
+CONFIG_OFLAGS ?= -g -ggdb
 OVERRIDE_CFLAGS += -O0
 OVERRIDE_CXXFLAGS += -O0
 CONFIG_CPPFLAGS += -DSYSDEBUG
 endif
 ifeq ($(MODE), aarch64-zero)
-CONFIG_OFLAGS ?= -g
+CONFIG_OFLAGS ?= -g -ggdb
 OVERRIDE_CFLAGS += -O0 -fdce
 OVERRIDE_CXXFLAGS += -O0 -fdce
 CONFIG_CPPFLAGS += -DSYSDEBUG
@@ -81,7 +81,7 @@ endif
 #
 ifeq ($(MODE), opt)
 ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
+CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
 CONFIG_CCFLAGS += $(BACKTRACES) -O3 -fmerge-all-constants
 TARGET_ARCH ?= -march=native
@@ -98,7 +98,7 @@ endif
 #   - Turns off support for other operating systems
 #
 ifeq ($(MODE), optlinux)
-CONFIG_OFLAGS ?= -g
+CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
 CONFIG_CCFLAGS += -O3 -fmerge-all-constants
 CONFIG_COPTS += -mred-zone
@@ -127,32 +127,10 @@ TARGET_ARCH ?= -msse3
 PYFLAGS += -O1
 endif
 
-# Asan Mode
-#
-# Safer binaries good for backend production serving.
-#
-#   - `make MODE=asan`
-#   - Memory safety
-#   - Production worthy
-#   - Backtraces
-#   - Debuggability
-#   - Larger binaries
-#
-ifeq ($(MODE), asan)
-ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
-CONFIG_CPPFLAGS += -D__SANITIZE_ADDRESS__
-CONFIG_CCFLAGS += $(BACKTRACES) -O2 -DSYSDEBUG
-CONFIG_COPTS += -fsanitize=address
-TARGET_ARCH ?= -msse3
-QUOTA ?= -C64 -L300
-endif
-
 # Debug Mode
 #
 #   - `make MODE=dbg`
 #   - Backtraces
-#   - Enables asan
 #   - Enables ubsan
 #   - Stack canaries
 #   - No optimization
@@ -160,17 +138,17 @@ endif
 #
 ifeq ($(MODE), dbg)
 ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
-CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_ADDRESS__ -D__SANITIZE_UNDEFINED__
+CONFIG_OFLAGS ?= -g -ggdb
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__
 CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline
-CONFIG_COPTS += -fsanitize=address -fsanitize=undefined
+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
+CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__
 CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline -fdce
 CONFIG_COPTS += -fsanitize=undefined
@@ -189,7 +167,7 @@ endif
 #
 ifeq ($(MODE), sysv)
 ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g
+CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
 CONFIG_CPPFLAGS += -DSYSDEBUG -DSUPPORT_VECTOR=121
 TARGET_ARCH ?= -msse3

build/definitions.mk

@@ -60,16 +60,10 @@ TMPSAFE = $(TMPDIR)/
 endif
 
 BACKTRACES =								\
+	-fno-schedule-insns2						\
 	-fno-optimize-sibling-calls					\
 	-mno-omit-leaf-frame-pointer
 
-ifneq ($(ARCH), aarch64)
-BACKTRACES += -fno-schedule-insns2
-endif
-
-SANITIZER =								\
-	-fsanitize=address
-
 NO_MAGIC =								\
 	-ffreestanding							\
 	-fno-stack-protector						\
@@ -148,12 +142,14 @@ DEFAULT_CFLAGS =							\
 	-std=gnu2x
 
 DEFAULT_CXXFLAGS =							\
+	-std=gnu++20							\
 	-fno-rtti							\
 	-fno-exceptions							\
 	-fuse-cxa-atexit						\
 	-Wno-int-in-bool-context					\
 	-Wno-narrowing							\
-	-Wno-literal-suffix
+	-Wno-literal-suffix						\
+	-isystem third_party/libcxx
 
 DEFAULT_ASFLAGS =							\
 	-W								\
@@ -260,12 +256,12 @@ LD.libs =								\
 	$(LIBS)
 
 COMPILE.c.flags = $(cc.flags) $(copt.flags) $(cpp.flags) $(c.flags)
-COMPILE.cxx.flags = $(cc.flags) $(copt.flags) $(cpp.flags) $(cxx.flags)
+COMPILE.cxx.flags = $(cc.flags) $(copt.flags) $(cxx.flags) $(cpp.flags)
 COMPILE.i.flags = $(cc.flags) $(copt.flags) $(c.flags)
 COMPILE.ii.flags = $(cc.flags) $(copt.flags) $(cxx.flags)
 LINK.flags = $(DEFAULT_LDFLAGS) $(CONFIG_LDFLAGS) $(LDFLAGS)
 OBJECTIFY.c.flags = $(cc.flags) $(o.flags) $(S.flags) $(cpp.flags) $(copt.flags) $(c.flags)
-OBJECTIFY.cxx.flags = $(cc.flags) $(o.flags) $(S.flags) $(cpp.flags) $(copt.flags) $(cxx.flags)
+OBJECTIFY.cxx.flags = $(cc.flags) $(o.flags) $(S.flags) $(cxx.flags) $(cpp.flags) $(copt.flags)
 OBJECTIFY.s.flags = $(ASONLYFLAGS) $(s.flags)
 OBJECTIFY.S.flags = $(cc.flags) $(o.flags) $(S.flags) $(cpp.flags)
 PREPROCESS.flags = -E $(copt.flags) $(cc.flags) $(cpp.flags)

build/objdump

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

ctl/.clang-format

@@ -0,0 +1,13 @@
+---
+BasedOnStyle: Mozilla
+IndentWidth: 4
+ColumnLimit: 80
+---
+Language: Cpp
+AllowShortFunctionsOnASingleLine: false
+AlignTrailingComments: false
+AlignEscapedNewlines: DontAlign
+AlwaysBreakTemplateDeclarations: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+FixNamespaceComments: true
+---

ctl/BUILD.mk

@@ -0,0 +1,48 @@
+#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
+#── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
+
+PKGS += CTL
+
+CTL_ARTIFACTS += CTL_A
+CTL = $(CTL_A_DEPS) $(CTL_A)
+CTL_A = o/$(MODE)/ctl/ctl.a
+CTL_A_FILES := $(wildcard ctl/*)
+CTL_A_HDRS = $(filter %.h,$(CTL_A_FILES))
+CTL_A_SRCS = $(filter %.cc,$(CTL_A_FILES))
+CTL_A_OBJS = $(CTL_A_SRCS:%.cc=o/$(MODE)/%.o)
+
+CTL_A_CHECKS =						\
+	$(CTL_A).pkg					\
+	$(CTL_A_HDRS:%=o/$(MODE)/%.okk)			\
+
+CTL_A_DIRECTDEPS =					\
+	LIBC_INTRIN					\
+	LIBC_MEM					\
+	LIBC_STR					\
+
+CTL_A_DEPS := $(call uniq,$(foreach x,$(CTL_A_DIRECTDEPS),$($(x))))
+
+$(CTL_A):	ctl/					\
+		$(CTL_A).pkg				\
+		$(CTL_A_OBJS)
+
+$(CTL_A).pkg:						\
+		$(CTL_A_OBJS)				\
+		$(foreach x,$(CTL_A_DIRECTDEPS),$($(x)_A).pkg)
+
+$(CTL_A_OBJS): private					\
+		OVERRIDE_CXXFLAGS +=			\
+			-Wframe-larger-than=4096	\
+			-Walloca-larger-than=4096	\
+			-ffunction-sections		\
+			-fdata-sections			\
+
+CTL_LIBS = $(foreach x,$(CTL_ARTIFACTS),$($(x)))
+CTL_SRCS = $(foreach x,$(CTL_ARTIFACTS),$($(x)_SRCS))
+CTL_HDRS = $(foreach x,$(CTL_ARTIFACTS),$($(x)_HDRS))
+CTL_CHECKS = $(foreach x,$(CTL_ARTIFACTS),$($(x)_CHECKS))
+CTL_OBJS = $(foreach x,$(CTL_ARTIFACTS),$($(x)_OBJS))
+$(CTL_OBJS): $(BUILD_FILES) ctl/BUILD.mk
+
+.PHONY: o/$(MODE)/ctl
+o/$(MODE)/ctl: $(CTL_CHECKS)

ctl/equal.h

@@ -0,0 +1,64 @@
+// -*-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_EQUAL_H_
+#define CTL_EQUAL_H_
+
+namespace ctl {
+
+template<class InputIt1, class InputIt2>
+bool
+equal(InputIt1 first1, InputIt1 last1, InputIt2 first2)
+{
+    for (; first1 != last1; ++first1, ++first2) {
+        if (!(*first1 == *first2)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// Overload that takes a predicate
+template<class InputIt1, class InputIt2, class BinaryPredicate>
+bool
+equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate pred)
+{
+    for (; first1 != last1; ++first1, ++first2) {
+        if (!pred(*first1, *first2)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// Overloads that take two ranges (C++14 and later)
+template<class InputIt1, class InputIt2>
+bool
+equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
+{
+    for (; first1 != last1 && first2 != last2; ++first1, ++first2) {
+        if (!(*first1 == *first2)) {
+            return false;
+        }
+    }
+    return first1 == last1 && first2 == last2;
+}
+
+template<class InputIt1, class InputIt2, class BinaryPredicate>
+bool
+equal(InputIt1 first1,
+      InputIt1 last1,
+      InputIt2 first2,
+      InputIt2 last2,
+      BinaryPredicate pred)
+{
+    for (; first1 != last1 && first2 != last2; ++first1, ++first2) {
+        if (!pred(*first1, *first2)) {
+            return false;
+        }
+    }
+    return first1 == last1 && first2 == last2;
+}
+
+} // namespace ctl
+
+#endif /* CTL_EQUAL_H_ */

ctl/initializer_list.h

@@ -0,0 +1,64 @@
+// -*-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 _LIBCPP_INITIALIZER_LIST
+#define _LIBCPP_INITIALIZER_LIST
+
+namespace std {
+
+template<class T>
+class initializer_list
+{
+    constexpr initializer_list(const T* b, size_t s) noexcept
+      : begin_(b), size_(s)
+    {
+    }
+
+  public:
+    typedef T value_type;
+    typedef const T& reference;
+    typedef const T& const_reference;
+    typedef size_t size_type;
+    typedef const T* iterator;
+    typedef const T* const_iterator;
+
+    constexpr initializer_list() noexcept : begin_(nullptr), size_(0)
+    {
+    }
+
+    constexpr size_t size() const noexcept
+    {
+        return size_;
+    }
+
+    constexpr const T* begin() const noexcept
+    {
+        return begin_;
+    }
+
+    constexpr const T* end() const noexcept
+    {
+        return begin_ + size_;
+    }
+
+  private:
+    const T* begin_;
+    size_t size_;
+};
+
+template<class T>
+inline constexpr const T*
+begin(initializer_list<T> i) noexcept
+{
+    return i.begin();
+}
+
+template<class T>
+inline constexpr const T*
+end(initializer_list<T> i) noexcept
+{
+    return i.end();
+}
+
+} // namespace std
+
+#endif // _LIBCPP_INITIALIZER_LIST

ctl/less.h

@@ -0,0 +1,38 @@
+// -*-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_LESS_H_
+#define CTL_LESS_H_
+#include "utility.h"
+
+namespace ctl {
+
+template<class T = void>
+struct less
+{
+    constexpr bool operator()(const T& lhs, const T& rhs) const
+    {
+        return lhs < rhs;
+    }
+
+    typedef T first_argument_type;
+    typedef T second_argument_type;
+    typedef bool result_type;
+};
+
+template<>
+struct less<void>
+{
+    template<class T, class U>
+    constexpr auto operator()(T&& lhs,
+                              U&& rhs) const -> decltype(ctl::forward<T>(lhs) <
+                                                         ctl::forward<U>(rhs))
+    {
+        return ctl::forward<T>(lhs) < ctl::forward<U>(rhs);
+    }
+
+    typedef void is_transparent;
+};
+
+} // namespace ctl
+
+#endif /* CTL_LESS_H_ */

ctl/map.h

@@ -0,0 +1,352 @@
+// -*-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_MAP_H_
+#define CTL_MAP_H_
+#include "set.h"
+
+namespace ctl {
+
+template<typename Key, typename Value, typename Compare = ctl::less<Key>>
+class map
+{
+    class EntryCompare
+    {
+      public:
+        explicit EntryCompare(Compare comp = Compare()) : comp_(comp)
+        {
+        }
+
+        bool operator()(const ctl::pair<const Key, Value>& lhs,
+                        const ctl::pair<const Key, Value>& rhs) const
+        {
+            return comp_(lhs.first, rhs.first);
+        }
+
+      private:
+        Compare comp_;
+    };
+
+    ctl::set<ctl::pair<const Key, Value>, EntryCompare> data_;
+
+  public:
+    using key_type = Key;
+    using mapped_type = Value;
+    using value_type = ctl::pair<const Key, Value>;
+    using size_type = typename ctl::set<value_type, EntryCompare>::size_type;
+    using difference_type =
+      typename ctl::set<value_type, EntryCompare>::difference_type;
+    using key_compare = Compare;
+    using value_compare = EntryCompare;
+    using iterator = typename ctl::set<value_type, EntryCompare>::iterator;
+    using const_iterator =
+      typename ctl::set<value_type, EntryCompare>::const_iterator;
+    using reverse_iterator =
+      typename ctl::set<value_type, EntryCompare>::reverse_iterator;
+    using const_reverse_iterator =
+      typename ctl::set<value_type, EntryCompare>::const_reverse_iterator;
+
+    map() : data_(EntryCompare())
+    {
+    }
+
+    explicit map(const Compare& comp) : data_(EntryCompare(comp))
+    {
+    }
+
+    map(const map& other) = default;
+    map(map&& other) noexcept = default;
+    map(std::initializer_list<value_type> init, const Compare& comp = Compare())
+      : data_(init, EntryCompare(comp))
+    {
+    }
+
+    template<typename InputIt>
+    map(InputIt first, InputIt last, const Compare& comp = Compare())
+      : data_(first, last, EntryCompare(comp))
+    {
+    }
+
+    map& operator=(const map& other) = default;
+    map& operator=(map&& other) noexcept = default;
+    map& operator=(std::initializer_list<value_type> ilist)
+    {
+        data_ = ilist;
+        return *this;
+    }
+
+    iterator begin() noexcept
+    {
+        return data_.begin();
+    }
+
+    const_iterator begin() const noexcept
+    {
+        return data_.begin();
+    }
+
+    const_iterator cbegin() const noexcept
+    {
+        return data_.cbegin();
+    }
+
+    iterator end() noexcept
+    {
+        return data_.end();
+    }
+
+    const_iterator end() const noexcept
+    {
+        return data_.end();
+    }
+
+    const_iterator cend() const noexcept
+    {
+        return data_.cend();
+    }
+
+    reverse_iterator rbegin() noexcept
+    {
+        return data_.rbegin();
+    }
+
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return data_.rbegin();
+    }
+
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return data_.crbegin();
+    }
+
+    reverse_iterator rend() noexcept
+    {
+        return data_.rend();
+    }
+
+    const_reverse_iterator rend() const noexcept
+    {
+        return data_.rend();
+    }
+
+    const_reverse_iterator crend() const noexcept
+    {
+        return data_.crend();
+    }
+
+    bool empty() const noexcept
+    {
+        return data_.empty();
+    }
+
+    size_type size() const noexcept
+    {
+        return data_.size();
+    }
+
+    size_type max_size() const noexcept
+    {
+        return data_.max_size();
+    }
+
+    Value& operator[](const Key& key)
+    {
+        return ((data_.insert(make_pair(key, Value()))).first)->second;
+    }
+
+    Value& operator[](Key&& key)
+    {
+        return ((data_.insert(make_pair(ctl::move(key), Value()))).first)
+          ->second;
+    }
+
+    Value& at(const Key& key)
+    {
+        auto it = find(key);
+        if (it == end())
+            __builtin_trap();
+        return it->second;
+    }
+
+    const Value& at(const Key& key) const
+    {
+        auto it = find(key);
+        if (it == end())
+            __builtin_trap();
+        return it->second;
+    }
+
+    ctl::pair<iterator, bool> insert(const value_type& value)
+    {
+        return data_.insert(value);
+    }
+
+    ctl::pair<iterator, bool> insert(value_type&& value)
+    {
+        return data_.insert(ctl::move(value));
+    }
+
+    template<typename P>
+    ctl::pair<iterator, bool> insert(P&& value)
+    {
+        return data_.insert(value_type(ctl::forward<P>(value)));
+    }
+
+    iterator insert(const_iterator hint, const value_type& value)
+    {
+        return data_.insert(hint, value);
+    }
+
+    iterator insert(const_iterator hint, value_type&& value)
+    {
+        return data_.insert(hint, ctl::move(value));
+    }
+
+    template<typename P>
+    iterator insert(const_iterator hint, P&& value)
+    {
+        return data_.insert(hint, value_type(ctl::forward<P>(value)));
+    }
+
+    template<typename InputIt>
+    void insert(InputIt first, InputIt last)
+    {
+        data_.insert(first, last);
+    }
+
+    void insert(std::initializer_list<value_type> ilist)
+    {
+        data_.insert(ilist);
+    }
+
+    template<typename... Args>
+    ctl::pair<iterator, bool> emplace(Args&&... args)
+    {
+        return data_.emplace(ctl::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    iterator emplace_hint(const_iterator hint, Args&&... args)
+    {
+        return data_.emplace_hint(hint, ctl::forward<Args>(args)...);
+    }
+
+    iterator erase(const_iterator pos)
+    {
+        return data_.erase(pos);
+    }
+
+    iterator erase(const_iterator first, const_iterator last)
+    {
+        return data_.erase(first, last);
+    }
+
+    size_type erase(const Key& key)
+    {
+        return data_.erase(make_pair(key, Value()));
+    }
+
+    void swap(map& other) noexcept
+    {
+        data_.swap(other.data_);
+    }
+
+    void clear() noexcept
+    {
+        data_.clear();
+    }
+
+    iterator find(const Key& key)
+    {
+        return data_.find(make_pair(key, Value()));
+    }
+
+    const_iterator find(const Key& key) const
+    {
+        return data_.find(make_pair(key, Value()));
+    }
+
+    size_type count(const Key& key) const
+    {
+        return data_.count(make_pair(key, Value()));
+    }
+
+    iterator lower_bound(const Key& key)
+    {
+        return data_.lower_bound(make_pair(key, Value()));
+    }
+
+    const_iterator lower_bound(const Key& key) const
+    {
+        return data_.lower_bound(make_pair(key, Value()));
+    }
+
+    iterator upper_bound(const Key& key)
+    {
+        return data_.upper_bound(make_pair(key, Value()));
+    }
+
+    const_iterator upper_bound(const Key& key) const
+    {
+        return data_.upper_bound(make_pair(key, Value()));
+    }
+
+    ctl::pair<iterator, iterator> equal_range(const Key& key)
+    {
+        return data_.equal_range(make_pair(key, Value()));
+    }
+
+    ctl::pair<const_iterator, const_iterator> equal_range(const Key& key) const
+    {
+        return data_.equal_range(make_pair(key, Value()));
+    }
+
+    key_compare key_comp() const
+    {
+        return data_.value_comp().comp;
+    }
+
+    value_compare value_comp() const
+    {
+        return data_.value_comp();
+    }
+
+    friend bool operator==(const map& lhs, const map& rhs)
+    {
+        return lhs.data_ == rhs.data_;
+    }
+
+    friend bool operator!=(const map& lhs, const map& rhs)
+    {
+        return !(lhs == rhs);
+    }
+
+    friend bool operator<(const map& lhs, const map& rhs)
+    {
+        return lhs.data_ < rhs.data_;
+    }
+
+    friend bool operator<=(const map& lhs, const map& rhs)
+    {
+        return !(rhs < lhs);
+    }
+
+    friend bool operator>(const map& lhs, const map& rhs)
+    {
+        return rhs < lhs;
+    }
+
+    friend bool operator>=(const map& lhs, const map& rhs)
+    {
+        return !(lhs < rhs);
+    }
+
+    friend void swap(map& lhs, map& rhs) noexcept
+    {
+        lhs.swap(rhs);
+    }
+};
+
+} // namespace ctl
+
+#endif // CTL_MAP_H_

ctl/new.cc

@@ -0,0 +1,113 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "new.h"
+
+#include "libc/mem/mem.h"
+
+COSMOPOLITAN_C_START_
+
+static void*
+_ctl_alloc(size_t n, size_t a)
+{
+    void* p;
+    if (!(p = memalign(a, n)))
+        __builtin_trap();
+    return p;
+}
+
+static void*
+_ctl_alloc1(size_t n)
+{
+    void* p;
+    if (!(p = malloc(n)))
+        __builtin_trap();
+    return p;
+}
+
+static void*
+_ctl_ret(size_t, void* p)
+{
+    return p;
+}
+
+static void
+_ctl_free(void* p)
+{
+    free(p);
+}
+
+static void
+_ctl_nop(void*, void*)
+{
+}
+
+COSMOPOLITAN_C_END_
+
+#undef __weak_reference
+#define __weak_reference(P, A) P __attribute__((weak, alias(#A)))
+
+/* The ISO says that these should be replaceable by user code. It also says
+   that the declarations for the first four (i.e. non placement-) operators
+   new are implicitly available in each translation unit, including the std
+   align_val_t parameter. (?) However, <new> also _defines_ the align_val_t
+   type so you can’t just write your own. Our way through this morass is to
+   supply ours as ctl::align_val_t and not implicitly declare anything, for
+   now. If you have any brain cells left after reading this comment then go
+   look at the eight operator delete weak references to free in the below. */
+
+__weak_reference(void*
+                 operator new(size_t, ctl::align_val_t),
+                 _ctl_alloc);
+
+__weak_reference(void*
+                 operator new[](size_t, ctl::align_val_t),
+                 _ctl_alloc);
+
+__weak_reference(void*
+                 operator new(size_t),
+                 _ctl_alloc1);
+
+__weak_reference(void*
+                 operator new[](size_t),
+                 _ctl_alloc1);
+
+// XXX clang-format currently mutilates these for some reason.
+// clang-format off
+
+__weak_reference(void* operator new(size_t, void*), _ctl_ret);
+__weak_reference(void* operator new[](size_t, void*), _ctl_ret);
+
+__weak_reference(void operator delete(void*) noexcept, _ctl_free);
+__weak_reference(void operator delete[](void*) noexcept, _ctl_free);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wattribute-alias="
+__weak_reference(void operator delete(void*, ctl::align_val_t) noexcept,
+                 _ctl_free);
+__weak_reference(void operator delete[](void*, ctl::align_val_t) noexcept,
+                 _ctl_free);
+__weak_reference(void operator delete(void*, size_t) noexcept, _ctl_free);
+__weak_reference(void operator delete[](void*, size_t) noexcept, _ctl_free);
+__weak_reference(void operator delete(void*, size_t, ctl::align_val_t) noexcept,
+                 _ctl_free);
+__weak_reference(void operator delete[](void*, size_t, ctl::align_val_t)
+                 noexcept, _ctl_free);
+#pragma GCC diagnostic pop
+
+__weak_reference(void operator delete(void*, void*) noexcept, _ctl_nop);
+__weak_reference(void operator delete[](void*, void*) noexcept, _ctl_nop);

ctl/new.h

@@ -0,0 +1,38 @@
+// -*-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_NEW_H_
+#define COSMOPOLITAN_CTL_NEW_H_
+
+#ifndef TINY
+__static_yoink("__demangle");
+#endif
+
+namespace ctl {
+
+enum class align_val_t : size_t
+{
+};
+
+} // namespace ctl
+
+void* operator new(size_t);
+void* operator new[](size_t);
+void* operator new(size_t, ctl::align_val_t);
+void* operator new[](size_t, ctl::align_val_t);
+
+// XXX clang-format currently mutilates these for some reason.
+// clang-format off
+
+void* operator new(size_t, void*);
+void* operator new[](size_t, void*);
+
+void operator delete(void*) noexcept;
+void operator delete[](void*) noexcept;
+void operator delete(void*, ctl::align_val_t) noexcept;
+void operator delete[](void*, ctl::align_val_t) noexcept;
+void operator delete(void*, size_t) noexcept;
+void operator delete[](void*, size_t) noexcept;
+void operator delete(void*, size_t, ctl::align_val_t) noexcept;
+void operator delete[](void*, size_t, ctl::align_val_t) noexcept;
+
+#endif // COSMOPOLITAN_CTL_NEW_H_

ctl/optional.h

@@ -0,0 +1,141 @@
+// -*-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_OPTIONAL_H_
+#define COSMOPOLITAN_CTL_OPTIONAL_H_
+#include "new.h"
+#include "utility.h"
+
+namespace ctl {
+
+template<typename T>
+class optional
+{
+  public:
+    using value_type = T;
+
+    ~optional()
+    {
+        if (present_)
+            value_.~T();
+    }
+
+    optional() noexcept : present_(false)
+    {
+    }
+
+    optional(const T& value) : present_(true)
+    {
+        new (&value_) T(value);
+    }
+
+    optional(T&& value) : present_(true)
+    {
+        new (&value_) T(ctl::move(value));
+    }
+
+    optional(const optional& other) : present_(other.present_)
+    {
+        if (other.present_)
+            new (&value_) T(other.value_);
+    }
+
+    optional(optional&& other) noexcept : present_(other.present_)
+    {
+        if (other.present_)
+            new (&value_) T(ctl::move(other.value_));
+    }
+
+    optional& operator=(const optional& other)
+    {
+        if (this != &other) {
+            reset();
+            if (other.present_)
+                new (&value_) T(other.value_);
+            present_ = other.present_;
+        }
+        return *this;
+    }
+
+    optional& operator=(optional&& other) noexcept
+    {
+        if (this != &other) {
+            reset();
+            if (other.present_)
+                new (&value_) T(ctl::move(other.value_));
+            present_ = other.present_;
+        }
+        return *this;
+    }
+
+    T& value() &
+    {
+        if (!present_)
+            __builtin_trap();
+        return value_;
+    }
+
+    const T& value() const&
+    {
+        if (!present_)
+            __builtin_trap();
+        return value_;
+    }
+
+    T&& value() &&
+    {
+        if (!present_)
+            __builtin_trap();
+        return ctl::move(value_);
+    }
+
+    explicit operator bool() const noexcept
+    {
+        return present_;
+    }
+
+    bool has_value() const noexcept
+    {
+        return present_;
+    }
+
+    void reset() noexcept
+    {
+        if (present_) {
+            value_.~T();
+            present_ = false;
+        }
+    }
+
+    template<typename... Args>
+    void emplace(Args&&... args)
+    {
+        reset();
+        present_ = true;
+        new (&value_) T(ctl::forward<Args>(args)...);
+    }
+
+    void swap(optional& other) noexcept
+    {
+        using ctl::swap;
+        if (present_ && other.present_) {
+            swap(value_, other.value_);
+        } else if (present_) {
+            other.emplace(ctl::move(value_));
+            reset();
+        } else if (other.present_) {
+            emplace(ctl::move(other.value_));
+            other.reset();
+        }
+    }
+
+  private:
+    union
+    {
+        T value_;
+    };
+    bool present_;
+};
+
+} // namespace ctl
+
+#endif // COSMOPOLITAN_CTL_OPTIONAL_H_

ctl/pair.h

@@ -0,0 +1,150 @@
+// -*-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_PAIR_H_
+#define CTL_PAIR_H_
+#include "utility.h"
+
+namespace ctl {
+
+template<typename T1, typename T2>
+struct pair
+{
+    using first_type = T1;
+    using second_type = T2;
+
+    T1 first;
+    T2 second;
+
+    constexpr pair() : first(), second()
+    {
+    }
+
+    constexpr pair(const T1& x, const T2& y) : first(x), second(y)
+    {
+    }
+
+    constexpr pair(const pair<T1, T2>& p) : first(p.first), second(p.second)
+    {
+    }
+
+    template<class U1, class U2>
+    constexpr pair(U1&& x, U2&& y)
+      : first(ctl::forward<U1>(x)), second(ctl::forward<U2>(y))
+    {
+    }
+
+    template<class U1, class U2>
+    constexpr pair(const pair<U1, U2>& p) : first(p.first), second(p.second)
+    {
+    }
+
+    constexpr pair(pair<T1, T2>&& p)
+      : first(ctl::move(p.first)), second(ctl::move(p.second))
+    {
+    }
+
+    template<class U1, class U2>
+    constexpr pair(pair<U1, U2>&& p)
+      : first(ctl::move(p.first)), second(ctl::move(p.second))
+    {
+    }
+
+    pair& operator=(const pair& other)
+    {
+        first = other.first;
+        second = other.second;
+        return *this;
+    }
+
+    pair& operator=(pair&& other) noexcept
+    {
+        first = ctl::move(other.first);
+        second = ctl::move(other.second);
+        return *this;
+    }
+
+    template<class U1, class U2>
+    pair& operator=(const pair<U1, U2>& other)
+    {
+        first = other.first;
+        second = other.second;
+        return *this;
+    }
+
+    template<class U1, class U2>
+    pair& operator=(pair<U1, U2>&& other)
+    {
+        first = ctl::move(other.first);
+        second = ctl::move(other.second);
+        return *this;
+    }
+
+    void swap(pair& other) noexcept
+    {
+        using ctl::swap;
+        swap(first, other.first);
+        swap(second, other.second);
+    }
+};
+
+template<class T1, class T2>
+constexpr pair<T1, T2>
+make_pair(T1&& t, T2&& u)
+{
+    return pair<T1, T2>(ctl::forward<T1>(t), ctl::forward<T2>(u));
+}
+
+// Comparison operators
+template<class T1, class T2>
+constexpr bool
+operator==(const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
+{
+    return lhs.first == rhs.first && lhs.second == rhs.second;
+}
+
+template<class T1, class T2>
+constexpr bool
+operator!=(const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<class T1, class T2>
+constexpr bool
+operator<(const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
+{
+    return lhs.first < rhs.first ||
+           (!(rhs.first < lhs.first) && lhs.second < rhs.second);
+}
+
+template<class T1, class T2>
+constexpr bool
+operator<=(const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
+{
+    return !(rhs < lhs);
+}
+
+template<class T1, class T2>
+constexpr bool
+operator>(const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
+{
+    return rhs < lhs;
+}
+
+template<class T1, class T2>
+constexpr bool
+operator>=(const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
+{
+    return !(lhs < rhs);
+}
+
+template<class T1, class T2>
+void
+swap(pair<T1, T2>& lhs, pair<T1, T2>& rhs) noexcept(noexcept(lhs.swap(rhs)))
+{
+    lhs.swap(rhs);
+}
+
+} // namespace ctl
+
+#endif // CTL_PAIR_H_

ctl/set.h

@@ -0,0 +1,945 @@
+// -*-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_SET_H_
+#define CTL_SET_H_
+#include "initializer_list.h"
+#include "less.h"
+#include "pair.h"
+
+namespace ctl {
+
+template<typename Key, typename Compare = less<Key>>
+class set
+{
+    struct rbtree
+    {
+        rbtree* left;
+        rbtree* right;
+        rbtree* parent;
+        bool is_red;
+        Key value;
+
+        rbtree(const Key& val)
+          : left(nullptr)
+          , right(nullptr)
+          , parent(nullptr)
+          , is_red(true)
+          , value(val)
+        {
+        }
+    };
+
+  public:
+    using key_type = Key;
+    using value_type = Key;
+    using size_type = size_t;
+    using node_type = rbtree;
+    using key_compare = Compare;
+    using value_compare = Compare;
+    using difference_type = ptrdiff_t;
+    using reference = value_type&;
+    using pointer = value_type*;
+    using const_pointer = const value_type*;
+    using const_reference = const value_type&;
+
+    class iterator
+    {
+      public:
+        using value_type = Key;
+        using difference_type = ptrdiff_t;
+        using pointer = Key*;
+        using reference = Key&;
+
+        iterator() : node_(nullptr)
+        {
+        }
+
+        reference operator*() const
+        {
+            return node_->value;
+        }
+
+        pointer operator->() const
+        {
+            return &(node_->value);
+        }
+
+        iterator& operator++()
+        {
+            if (node_ == nullptr)
+                return *this;
+            if (node_->right) {
+                node_ = leftmost(node_->right);
+            } else {
+                node_type* parent = node_->parent;
+                while (parent && node_ == parent->right) {
+                    node_ = parent;
+                    parent = parent->parent;
+                }
+                node_ = parent;
+            }
+            return *this;
+        }
+
+        iterator& operator--()
+        {
+            if (node_ == nullptr)
+                __builtin_trap();
+            if (node_->left) {
+                node_ = rightmost(node_->left);
+            } else {
+                node_type* parent = node_->parent;
+                for (;;) {
+                    if (parent == nullptr)
+                        break;
+                    if (node_ == parent->left) {
+                        node_ = parent;
+                        parent = parent->parent;
+                    } else {
+                        break;
+                    }
+                }
+                node_ = parent;
+            }
+            return *this;
+        }
+
+        iterator operator++(int)
+        {
+            iterator tmp = *this;
+            ++(*this);
+            return tmp;
+        }
+
+        iterator operator--(int)
+        {
+            iterator tmp = *this;
+            --(*this);
+            return tmp;
+        }
+
+        bool operator==(const iterator& other) const
+        {
+            return node_ == other.node_;
+        }
+
+        bool operator!=(const iterator& other) const
+        {
+            return !(*this == other);
+        }
+
+      private:
+        friend class set;
+        node_type* node_;
+
+        explicit iterator(node_type* node) : node_(node)
+        {
+        }
+    };
+
+    class reverse_iterator
+    {
+      public:
+        using value_type = Key;
+        using difference_type = ptrdiff_t;
+        using pointer = Key*;
+        using reference = Key&;
+
+        reverse_iterator() : node_(nullptr)
+        {
+        }
+
+        reference operator*() const
+        {
+            return node_->value;
+        }
+
+        pointer operator->() const
+        {
+            return &(node_->value);
+        }
+
+        reverse_iterator& operator++()
+        {
+            if (node_->left) {
+                node_ = rightmost(node_->left);
+            } else {
+                node_type* parent = node_->parent;
+                while (parent && node_ == parent->left) {
+                    node_ = parent;
+                    parent = parent->parent;
+                }
+                node_ = parent;
+            }
+            return *this;
+        }
+
+        reverse_iterator operator++(int)
+        {
+            reverse_iterator tmp = *this;
+            ++(*this);
+            return tmp;
+        }
+
+        reverse_iterator& operator--()
+        {
+            if (node_->right) {
+                node_ = leftmost(node_->right);
+            } else {
+                node_type* parent = node_->parent;
+                while (parent && node_ == parent->right) {
+                    node_ = parent;
+                    parent = parent->parent;
+                }
+                node_ = parent;
+            }
+            return *this;
+        }
+
+        reverse_iterator operator--(int)
+        {
+            reverse_iterator tmp = *this;
+            --(*this);
+            return tmp;
+        }
+
+        bool operator==(const reverse_iterator& other) const
+        {
+            return node_ == other.node_;
+        }
+
+        bool operator!=(const reverse_iterator& other) const
+        {
+            return !(*this == other);
+        }
+
+        iterator base() const
+        {
+            if (node_ == nullptr)
+                return iterator(leftmost(root_));
+            reverse_iterator tmp = *this;
+            ++tmp;
+            return iterator(tmp.node_);
+        }
+
+      private:
+        friend class set;
+        node_type* node_;
+
+        explicit reverse_iterator(node_type* node) : node_(node)
+        {
+        }
+    };
+
+    using const_iterator = iterator;
+    using const_reverse_iterator = reverse_iterator;
+
+    set() : root_(nullptr), size_(0), comp_(Compare())
+    {
+    }
+
+    explicit set(const Compare& comp) : root_(nullptr), size_(0), comp_(comp)
+    {
+    }
+
+    template<class InputIt>
+    set(InputIt first, InputIt last, const Compare& comp = Compare())
+      : root_(nullptr), size_(0), comp_(comp)
+    {
+        for (; first != last; ++first)
+            insert(*first);
+    }
+
+    set(const set& other) : root_(nullptr), size_(0)
+    {
+        if (other.root_) {
+            root_ = copier(other.root_);
+            size_ = other.size_;
+        }
+    }
+
+    set(set&& other) noexcept : root_(other.root_), size_(other.size_)
+    {
+        other.root_ = nullptr;
+        other.size_ = 0;
+    }
+
+    set(std::initializer_list<value_type> init, const Compare& comp = Compare())
+      : root_(nullptr), size_(0), comp_(comp)
+    {
+        for (const auto& value : init)
+            insert(value);
+    }
+
+    ~set()
+    {
+        clear();
+    }
+
+    set& operator=(const set& other)
+    {
+        if (this != &other) {
+            clear();
+            if (other.root_) {
+                root_ = copier(other.root_);
+                size_ = other.size_;
+            }
+        }
+        return *this;
+    }
+
+    set& operator=(set&& other) noexcept
+    {
+        if (this != &other) {
+            clear();
+            root_ = other.root_;
+            size_ = other.size_;
+            other.root_ = nullptr;
+            other.size_ = 0;
+        }
+        return *this;
+    }
+
+    bool empty() const noexcept
+    {
+        return size_ == 0;
+    }
+
+    size_type size() const noexcept
+    {
+        return size_;
+    }
+
+    iterator begin() noexcept
+    {
+        if (root_)
+            return iterator(leftmost(root_));
+        return iterator(nullptr);
+    }
+
+    const_iterator begin() const noexcept
+    {
+        if (root_)
+            return const_iterator(leftmost(root_));
+        return const_iterator(nullptr);
+    }
+
+    const_iterator cbegin() const noexcept
+    {
+        return begin();
+    }
+
+    reverse_iterator rbegin()
+    {
+        return reverse_iterator(rightmost(root_));
+    }
+
+    const_reverse_iterator rbegin() const
+    {
+        return const_reverse_iterator(rightmost(root_));
+    }
+
+    const_reverse_iterator crbegin() const
+    {
+        return const_reverse_iterator(rightmost(root_));
+    }
+
+    iterator end() noexcept
+    {
+        return iterator(nullptr);
+    }
+
+    const_iterator end() const noexcept
+    {
+        return const_iterator(nullptr);
+    }
+
+    const_iterator cend() const noexcept
+    {
+        return end();
+    }
+
+    reverse_iterator rend()
+    {
+        return reverse_iterator(nullptr);
+    }
+
+    const_reverse_iterator rend() const
+    {
+        return const_reverse_iterator(nullptr);
+    }
+
+    const_reverse_iterator crend() const
+    {
+        return const_reverse_iterator(nullptr);
+    }
+
+    void clear() noexcept
+    {
+        clearer(root_);
+        root_ = nullptr;
+        size_ = 0;
+    }
+
+    pair<iterator, bool> insert(value_type&& value)
+    {
+        return insert_node(new node_type(ctl::move(value)));
+    }
+
+    pair<iterator, bool> insert(const value_type& value)
+    {
+        return insert_node(new node_type(value));
+    }
+
+    iterator insert(const_iterator hint, const value_type& value)
+    {
+        return insert(value).first;
+    }
+
+    iterator insert(const_iterator hint, value_type&& value)
+    {
+        return insert(ctl::move(value)).first;
+    }
+
+    template<class InputIt>
+    void insert(InputIt first, InputIt last)
+    {
+        for (; first != last; ++first)
+            insert(*first);
+    }
+
+    void insert(std::initializer_list<value_type> ilist)
+    {
+        for (const auto& value : ilist)
+            insert(value);
+    }
+
+    template<class... Args>
+    pair<iterator, bool> emplace(Args&&... args)
+    {
+        value_type value(ctl::forward<Args>(args)...);
+        return insert(ctl::move(value));
+    }
+
+    iterator erase(iterator pos)
+    {
+        node_type* node = pos.node_;
+        iterator res = ++pos;
+        erase_node(node);
+        return res;
+    }
+
+    size_type erase(const key_type& key)
+    {
+        node_type* node = get_element(key);
+        if (node == nullptr)
+            return 0;
+        erase_node(node);
+        return 1;
+    }
+
+    iterator erase(const_iterator first, const_iterator last)
+    {
+        while (first != last)
+            first = erase(first);
+        return iterator(const_cast<node_type*>(last.node_));
+    }
+
+    void swap(set& other) noexcept
+    {
+        ctl::swap(root_, other.root_);
+        ctl::swap(size_, other.size_);
+    }
+
+    pair<iterator, iterator> equal_range(const key_type& key)
+    {
+        return { iterator(get_floor(key)), iterator(get_ceiling(key)) };
+    }
+
+    pair<const_iterator, const_iterator> equal_range(const key_type& key) const
+    {
+        return { const_iterator(get_floor(key)),
+                 const_iterator(get_ceiling(key)) };
+    }
+
+    iterator lower_bound(const key_type& key)
+    {
+        return iterator(get_floor(key));
+    }
+
+    const_iterator lower_bound(const key_type& key) const
+    {
+        return const_iterator(get_floor(key));
+    }
+
+    iterator upper_bound(const key_type& key)
+    {
+        return iterator(get_ceiling(key));
+    }
+
+    const_iterator upper_bound(const key_type& key) const
+    {
+        return const_iterator(get_ceiling(key));
+    }
+
+    size_type count(const key_type& key) const
+    {
+        return !!get_element(key);
+    }
+
+    iterator find(const key_type& key)
+    {
+        return iterator(get_element(key));
+    }
+
+    const_iterator find(const key_type& key) const
+    {
+        return const_iterator(get_element(key));
+    }
+
+    template<class... Args>
+    iterator emplace_hint(const_iterator hint, Args&&... args)
+    {
+        return emplace(ctl::forward<Args>(args)...).first;
+    }
+
+    void check() const
+    {
+        size_type count = 0;
+        if (root_ != nullptr) {
+            if (root_->is_red)
+                // ILLEGAL TREE: root node must be black
+                __builtin_trap();
+            int black_height = -1;
+            checker(root_, nullptr, 0, black_height);
+            count = tally(root_);
+        }
+        if (count != size_)
+            // ILLEGAL TREE: unexpected number of nodes
+            __builtin_trap();
+    }
+
+  private:
+    static node_type* leftmost(node_type* node) noexcept
+    {
+        while (node && node->left)
+            node = node->left;
+        return node;
+    }
+
+    static node_type* rightmost(node_type* node) noexcept
+    {
+        while (node && node->right)
+            node = node->right;
+        return node;
+    }
+
+    static void clearer(node_type* node) noexcept
+    {
+        node_type* right;
+        for (; node; node = right) {
+            right = node->right;
+            clearer(node->left);
+            delete node;
+        }
+    }
+
+    static 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->right = copier(node->right);
+        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)
+    {
+        if (node == nullptr)
+            return 0;
+        return 1 + tally(node->left) + tally(node->right);
+    }
+
+    template<typename K>
+    node_type* get_element(const K& key) const
+    {
+        node_type* current = root_;
+        while (current != nullptr) {
+            if (comp_(key, current->value)) {
+                current = current->left;
+            } else if (comp_(current->value, key)) {
+                current = current->right;
+            } else {
+                return current;
+            }
+        }
+        return nullptr;
+    }
+
+    template<typename K>
+    node_type* get_floor(const K& key) const
+    {
+        node_type* result = nullptr;
+        node_type* current = root_;
+        while (current != nullptr) {
+            if (!comp_(current->value, key)) {
+                result = current;
+                current = current->left;
+            } else {
+                current = current->right;
+            }
+        }
+        return result;
+    }
+
+    template<typename K>
+    node_type* get_ceiling(const K& key) const
+    {
+        node_type* result = nullptr;
+        node_type* current = root_;
+        while (current != nullptr) {
+            if (comp_(key, current->value)) {
+                result = current;
+                current = current->left;
+            } else {
+                current = current->right;
+            }
+        }
+        return result;
+    }
+
+    pair<iterator, bool> insert_node(node_type* node)
+    {
+        if (root_ == nullptr) {
+            root_ = node;
+            root_->is_red = false;
+            size_++;
+            return { iterator(root_), true };
+        }
+        node_type* current = root_;
+        node_type* parent = nullptr;
+        while (current != nullptr) {
+            parent = current;
+            if (comp_(node->value, current->value)) {
+                current = current->left;
+            } else if (comp_(current->value, node->value)) {
+                current = current->right;
+            } else {
+                delete node; // already exists
+                return { iterator(current), false };
+            }
+        }
+        if (comp_(node->value, parent->value)) {
+            parent->left = node;
+        } else {
+            parent->right = node;
+        }
+        node->parent = parent;
+        size_++;
+        rebalance_after_insert(node);
+        return { iterator(node), true };
+    }
+
+    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) {
+            x = node->right;
+            transplant(node, node->right);
+            x_parent = node->parent;
+        } else if (node->right == nullptr) {
+            x = node->left;
+            transplant(node, node->left);
+            x_parent = node->parent;
+        } else {
+            y = leftmost(node->right);
+            y_original_color = y->is_red;
+            x = y->right;
+            if (y->parent == node) {
+                if (x)
+                    x->parent = y;
+                x_parent = y;
+            } else {
+                transplant(y, y->right);
+                y->right = node->right;
+                y->right->parent = y;
+                x_parent = y->parent;
+            }
+            transplant(node, y);
+            y->left = node->left;
+            y->left->parent = y;
+            y->is_red = node->is_red;
+        }
+        if (!y_original_color)
+            rebalance_after_erase(x, x_parent);
+        delete node;
+        --size_;
+    }
+
+    void left_rotate(node_type* x)
+    {
+        node_type* y = x->right;
+        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 {
+            x->parent->right = y;
+        }
+        y->left = x;
+        x->parent = y;
+    }
+
+    void right_rotate(node_type* y)
+    {
+        node_type* x = y->left;
+        y->left = x->right;
+        if (x->right != nullptr)
+            x->right->parent = y;
+        x->parent = y->parent;
+        if (y->parent == nullptr) {
+            root_ = x;
+        } else if (y == y->parent->right) {
+            y->parent->right = x;
+        } else {
+            y->parent->left = x;
+        }
+        x->right = y;
+        y->parent = x;
+    }
+
+    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 {
+            u->parent->right = v;
+        }
+        if (v != nullptr)
+            v->parent = u->parent;
+    }
+
+    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
+            if (black_height == -1) {
+                black_height = black_count;
+            } else if (black_count != black_height) {
+                // ILLEGAL TREE: Black height mismatch
+                __builtin_trap();
+            }
+            return;
+        }
+        if (node->parent != parent)
+            // ILLEGAL TREE: Parent link is incorrect
+            __builtin_trap();
+        if (parent) {
+            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) {
+            black_count++;
+        } 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->right, node, black_count, black_height);
+    }
+
+    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_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;
+                    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;
+                    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 = node->parent->parent;
+                } else {
+                    if (node == node->parent->left) {
+                        node = node->parent;
+                        right_rotate(node);
+                    }
+                    node->parent->is_red = false;
+                    node->parent->parent->is_red = true;
+                    left_rotate(node->parent->parent);
+                }
+            }
+        }
+        root_->is_red = false;
+    }
+
+    void rebalance_after_erase(node_type* node, node_type* parent)
+    {
+        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;
+                    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;
+                    node = parent;
+                    parent = node->parent;
+                } else {
+                    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;
+                    left_rotate(parent);
+                    node = root_;
+                    break;
+                }
+            } else {
+                node_type* sibling = parent->left;
+                if (sibling->is_red) {
+                    sibling->is_red = false;
+                    parent->is_red = true;
+                    right_rotate(parent);
+                    sibling = parent->left;
+                }
+                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;
+                        left_rotate(sibling);
+                        sibling = parent->left;
+                    }
+                    sibling->is_red = parent->is_red;
+                    parent->is_red = false;
+                    sibling->left->is_red = false;
+                    right_rotate(parent);
+                    node = root_;
+                    break;
+                }
+            }
+        }
+        if (node != nullptr)
+            node->is_red = false;
+    }
+
+    node_type* root_;
+    size_type size_;
+    Compare comp_;
+};
+
+template<class Key, typename Compare = less<Key>>
+bool
+operator==(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
+{
+    if (lhs.size() != rhs.size())
+        return false;
+    auto i = lhs.cbegin();
+    auto j = rhs.cbegin();
+    for (; i != lhs.end(); ++i, ++j) {
+        if (!(*i == *j))
+            return false;
+    }
+    return true;
+}
+
+template<class Key, typename Compare = less<Key>>
+bool
+operator<(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
+{
+    auto i = lhs.cbegin();
+    auto j = rhs.cbegin();
+    for (; i != lhs.end() && j != rhs.end(); ++i, ++j) {
+        if (Compare()(*i, *j))
+            return true;
+        if (Compare()(*j, *i))
+            return false;
+    }
+    return i == lhs.end() && j != rhs.end();
+}
+
+template<class Key, typename Compare = less<Key>>
+bool
+operator!=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<class Key, typename Compare = less<Key>>
+bool
+operator<=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
+{
+    return !(rhs < lhs);
+}
+
+template<class Key, typename Compare = less<Key>>
+bool
+operator>(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
+{
+    return rhs < lhs;
+}
+
+template<class Key, typename Compare = less<Key>>
+bool
+operator>=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
+{
+    return !(lhs < rhs);
+}
+
+template<class Key, typename Compare = less<Key>>
+void
+swap(set<Key, Compare>& lhs, set<Key, Compare>& rhs) noexcept;
+
+} // namespace ctl
+
+#endif // CTL_SET_H_

ctl/strcat.cc

@@ -0,0 +1,49 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "string.h"
+
+#include <stdckdint.h>
+#include <string.h>
+
+namespace ctl {
+
+string
+strcat(const string_view lhs, const string_view rhs) noexcept
+{
+    string res;
+    size_t need;
+    if (ckd_add(&need, lhs.n, rhs.n))
+        __builtin_trap();
+    if (ckd_add(&need, need, 1))
+        __builtin_trap();
+    res.reserve(need);
+    if (lhs.n)
+        memcpy(res.data(), lhs.p, lhs.n);
+    if (rhs.n)
+        memcpy(res.data() + lhs.n, rhs.p, rhs.n);
+    if (res.isbig()) {
+        res.big()->n = lhs.n + rhs.n;
+    } else {
+        res.small()->rem = __::sso_max - lhs.n - rhs.n;
+    }
+    res.data()[res.size()] = 0;
+    return res;
+}
+
+} // namespace ctl

ctl/strcmp.cc

@@ -0,0 +1,43 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "string_view.h"
+
+#include <string.h>
+
+namespace ctl {
+
+int
+strcmp(const string_view lhs, const string_view rhs) noexcept
+{
+    int r;
+    size_t m = lhs.n;
+    if ((m = rhs.n < m ? rhs.n : m)) {
+        if (!m)
+            return 0;
+        if ((r = memcmp(lhs.p, rhs.p, m)))
+            return r;
+    }
+    if (lhs.n == rhs.n)
+        return 0;
+    if (m < lhs.n)
+        return +1;
+    return -1;
+}
+
+} // namespace ctl

ctl/string.cc

@@ -0,0 +1,387 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "string.h"
+
+#include <__atomic/fence.h>
+#include <stdckdint.h>
+
+namespace ctl {
+
+void
+string::destroy_big() noexcept
+{
+    auto* b = big();
+    if (b->n) {
+        if (b->n >= b->c)
+            __builtin_trap();
+        if (b->p[b->n])
+            __builtin_trap();
+    }
+    if (b->c && !b->p)
+        __builtin_trap();
+    free(b->p);
+}
+
+void
+string::init_big(const string& s) noexcept
+{
+    char* p2;
+#ifndef NDEBUG
+    if (!s.isbig())
+        __builtin_trap();
+#endif
+    if (s.size() >= s.capacity() >> 1) {
+        if (!(p2 = (char*)malloc(s.capacity())))
+            __builtin_trap();
+        set_big_string(p2, s.size(), s.capacity());
+    } else {
+        init_big(string_view(s));
+    }
+}
+
+void
+string::init_big(const string_view s) noexcept
+{
+    size_t need;
+    char* p2;
+    if (ckd_add(&need, s.n, 1 /* nul */ + 15))
+        __builtin_trap();
+    need &= -16;
+    if (!(p2 = (char*)malloc(need)))
+        __builtin_trap();
+    memcpy(p2, s.p, s.n);
+    p2[s.n] = 0;
+    set_big_string(p2, s.n, need);
+}
+
+void
+string::init_big(const size_t n, const char ch) noexcept
+{
+    size_t need;
+    char* p2;
+    if (ckd_add(&need, n, 1 /* nul */ + 15))
+        __builtin_trap();
+    need &= -16;
+    if (!(p2 = (char*)malloc(need)))
+        __builtin_trap();
+    memset(p2, ch, n);
+    p2[n] = 0;
+    set_big_string(p2, n, need);
+}
+
+const char*
+string::c_str() const noexcept
+{
+    if (!size())
+        return "";
+    if (size() >= capacity())
+        __builtin_trap();
+    if (data()[size()])
+        __builtin_trap();
+    return data();
+}
+
+void
+string::reserve(size_t c2) noexcept
+{
+    char* p2;
+    size_t n = size();
+    if (c2 < n + 1)
+        c2 = n + 1;
+    if (c2 <= __::string_size)
+        return;
+    if (ckd_add(&c2, c2, 15))
+        __builtin_trap();
+    c2 &= -16;
+    if (!isbig()) {
+        if (!(p2 = (char*)malloc(c2)))
+            __builtin_trap();
+        memcpy(p2, data(), __::string_size);
+    } else {
+        if (!(p2 = (char*)realloc(big()->p, c2)))
+            __builtin_trap();
+    }
+    std::atomic_signal_fence(std::memory_order_seq_cst);
+    set_big_string(p2, n, c2);
+}
+
+void
+string::resize(const size_t n2, const char ch) noexcept
+{
+    size_t c2;
+    if (ckd_add(&c2, n2, 1))
+        __builtin_trap();
+    reserve(c2);
+    if (n2 > size())
+        memset(data() + size(), ch, n2 - size());
+    if (isbig()) {
+        big()->p[big()->n = n2] = 0;
+    } else {
+        set_small_size(n2);
+        data()[size()] = 0;
+    }
+}
+
+void
+string::append(const char ch) noexcept
+{
+    size_t n2;
+    if (ckd_add(&n2, size(), 2))
+        __builtin_trap();
+    if (n2 > capacity()) {
+        size_t c2 = capacity();
+        if (ckd_add(&c2, c2, c2 >> 1))
+            __builtin_trap();
+        reserve(c2);
+    }
+    data()[size()] = ch;
+    if (isbig()) {
+        ++big()->n;
+    } else {
+        --small()->rem;
+    }
+    data()[size()] = 0;
+}
+
+void
+string::grow(const size_t size) noexcept
+{
+    size_t need;
+    if (ckd_add(&need, this->size(), size))
+        __builtin_trap();
+    if (ckd_add(&need, need, 1))
+        __builtin_trap();
+    if (need <= capacity())
+        return;
+    size_t c2 = capacity();
+    if (!c2)
+        __builtin_trap();
+    while (c2 < need)
+        if (ckd_add(&c2, c2, c2 >> 1))
+            __builtin_trap();
+    reserve(c2);
+}
+
+void
+string::append(const char ch, const size_t size) noexcept
+{
+    grow(size);
+    if (size)
+        memset(data() + this->size(), ch, size);
+    if (isbig()) {
+        big()->n += size;
+    } else {
+        small()->rem -= size;
+    }
+    data()[this->size()] = 0;
+}
+
+void
+string::append(const void* data, const size_t size) noexcept
+{
+    grow(size);
+    if (size)
+        memcpy(this->data() + this->size(), data, size);
+    if (isbig()) {
+        big()->n += size;
+    } else {
+        small()->rem -= size;
+    }
+    this->data()[this->size()] = 0;
+}
+
+void
+string::pop_back() noexcept
+{
+    if (!size())
+        __builtin_trap();
+    if (isbig()) {
+        --big()->n;
+    } else {
+        ++small()->rem;
+    }
+    data()[size()] = 0;
+}
+
+string&
+string::operator=(string s) noexcept
+{
+    swap(s);
+    return *this;
+}
+
+bool
+string::operator==(const string_view s) const noexcept
+{
+    if (size() != s.n)
+        return false;
+    if (!s.n)
+        return true;
+    return !memcmp(data(), s.p, s.n);
+}
+
+bool
+string::operator!=(const string_view s) const noexcept
+{
+    if (size() != s.n)
+        return true;
+    if (!s.n)
+        return false;
+    return !!memcmp(data(), s.p, s.n);
+}
+
+bool
+string::contains(const string_view s) const noexcept
+{
+    if (!s.n)
+        return true;
+    return !!memmem(data(), size(), s.p, s.n);
+}
+
+bool
+string::ends_with(const string_view s) const noexcept
+{
+    if (size() < s.n)
+        return false;
+    if (!s.n)
+        return true;
+    return !memcmp(data() + size() - s.n, s.p, s.n);
+}
+
+bool
+string::starts_with(const string_view s) const noexcept
+{
+    if (size() < s.n)
+        return false;
+    if (!s.n)
+        return true;
+    return !memcmp(data(), s.p, s.n);
+}
+
+size_t
+string::find(const char ch, const size_t pos) const noexcept
+{
+    char* q;
+    if ((q = (char*)memchr(data(), ch, size())))
+        return q - data();
+    return npos;
+}
+
+size_t
+string::find(const string_view s, const size_t pos) const noexcept
+{
+    char* q;
+    if (pos > size())
+        __builtin_trap();
+    if ((q = (char*)memmem(data() + pos, size() - pos, s.p, s.n)))
+        return q - data();
+    return npos;
+}
+
+string
+string::substr(const size_t pos, size_t count) const noexcept
+{
+    size_t last;
+    if (pos > size())
+        __builtin_trap();
+    if (count > size() - pos)
+        count = size() - pos;
+    if (ckd_add(&last, pos, count))
+        last = size();
+    if (last > size())
+        __builtin_trap();
+    return string(data() + pos, count);
+}
+
+string&
+string::replace(const size_t pos,
+                const size_t count,
+                const string_view s) noexcept
+{
+    size_t last;
+    if (ckd_add(&last, pos, count))
+        __builtin_trap();
+    if (last > size())
+        __builtin_trap();
+    size_t need;
+    if (ckd_add(&need, pos, s.n))
+        __builtin_trap();
+    size_t extra = size() - last;
+    if (ckd_add(&need, need, extra))
+        __builtin_trap();
+    size_t c2;
+    if (ckd_add(&c2, need, 1))
+        __builtin_trap();
+    reserve(c2);
+    if (extra)
+        memmove(data() + pos + s.n, data() + last, extra);
+    memcpy(data() + pos, s.p, s.n);
+    if (isbig()) {
+        big()->p[big()->n = need] = 0;
+    } else {
+        set_small_size(need);
+        data()[size()] = 0;
+    }
+    return *this;
+}
+
+string&
+string::insert(const size_t i, const string_view s) noexcept
+{
+    if (i > size())
+        __builtin_trap();
+    size_t extra = size() - i;
+    size_t need;
+    if (ckd_add(&need, size(), s.n))
+        __builtin_trap();
+    if (ckd_add(&need, need, 1))
+        __builtin_trap();
+    reserve(need);
+    if (extra)
+        memmove(data() + i + s.n, data() + i, extra);
+    memcpy(data() + i, s.p, s.n);
+    if (isbig()) {
+        big()->n += s.n;
+    } else {
+        small()->rem -= s.n;
+    }
+    data()[size()] = 0;
+    return *this;
+}
+
+string&
+string::erase(const size_t pos, size_t count) noexcept
+{
+    if (pos > size())
+        __builtin_trap();
+    if (count > size() - pos)
+        count = size() - pos;
+    size_t extra = size() - (pos + count);
+    if (extra)
+        memmove(data() + pos, data() + pos + count, extra);
+    if (isbig()) {
+        big()->n = pos + extra;
+    } else {
+        set_small_size(pos + extra);
+    }
+    data()[size()] = 0;
+    return *this;
+}
+
+} // namespace ctl

ctl/string.h

@@ -0,0 +1,400 @@
+// -*-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_STRING_H_
+#define CTL_STRING_H_
+#include "string_view.h"
+
+namespace ctl {
+
+class string;
+
+string strcat(string_view, string_view) noexcept __wur;
+
+namespace __ {
+
+constexpr size_t string_size = 3 * sizeof(size_t);
+constexpr size_t sso_max = string_size - 1;
+constexpr size_t big_mask = ~(1ull << (8ull * sizeof(size_t) - 1ull));
+
+struct small_string
+{
+    char buf[sso_max];
+    // interpretation is: size == sso_max - rem
+    unsigned char rem;
+#if 0
+    size_t rem : 7;
+    size_t big : 1 /* = 0 */;
+#endif
+};
+
+struct big_string
+{
+    char* p;
+    size_t n;
+    // interpretation is: capacity == c & big_mask
+    size_t c;
+#if 0
+    size_t c : sizeof(size_t) * 8 - 1;
+    size_t big : 1 /* = 1 */;
+#endif
+};
+
+} // namespace __
+
+class string
+{
+  public:
+    using iterator = char*;
+    using const_iterator = const char*;
+    static constexpr size_t npos = -1;
+
+    string() noexcept
+    {
+        __builtin_memset(blob, 0, sizeof(size_t) * 2);
+        // equivalent to set_small_size(0) but also zeroes memory
+        *(((size_t*)blob) + 2) = __::sso_max << (sizeof(size_t) - 1) * 8;
+    }
+
+    string(const string_view s) noexcept
+    {
+        if (s.n <= __::sso_max) {
+            __builtin_memcpy(blob, s.p, s.n);
+            __builtin_memset(blob + s.n, 0, __::sso_max - s.n);
+            set_small_size(s.n);
+        } else {
+            init_big(s);
+        }
+    }
+
+    explicit string(const size_t n, const char ch = 0) noexcept
+    {
+        if (n <= __::sso_max) {
+            __builtin_memset(blob, ch, n);
+            __builtin_memset(blob + n, 0, __::sso_max - n);
+            set_small_size(n);
+        } else {
+            init_big(n, ch);
+        }
+    }
+
+    string(const char* const p) noexcept
+      : string(string_view(p, __builtin_strlen(p)))
+    {
+    }
+
+    string(const string& r) noexcept
+    {
+        if (r.size() <= __::sso_max) {
+            __builtin_memcpy(blob, r.data(), __::string_size);
+            set_small_size(r.size());
+        } else {
+            init_big(r);
+        }
+    }
+
+    string(const char* const p, const size_t n) noexcept
+      : string(string_view(p, n))
+    {
+    }
+
+    ~string() /* noexcept */
+    {
+        if (isbig())
+            destroy_big();
+    }
+
+    string& operator=(string) noexcept;
+    const char* c_str() const noexcept;
+
+    void pop_back() noexcept;
+    void grow(size_t) noexcept;
+    void reserve(size_t) noexcept;
+    void resize(size_t, char = 0) noexcept;
+    void append(char) noexcept;
+    void append(char, size_t) noexcept;
+    void append(unsigned long) noexcept;
+    void append(const void*, size_t) noexcept;
+    string& insert(size_t, string_view) noexcept;
+    string& erase(size_t = 0, size_t = npos) noexcept;
+    string substr(size_t = 0, size_t = npos) const noexcept;
+    string& replace(size_t, size_t, string_view) noexcept;
+    bool operator==(string_view) const noexcept;
+    bool operator!=(string_view) const noexcept;
+    bool contains(string_view) const noexcept;
+    bool ends_with(string_view) const noexcept;
+    bool starts_with(string_view) const noexcept;
+    size_t find(char, size_t = 0) const noexcept;
+    size_t find(string_view, size_t = 0) const noexcept;
+
+    void swap(string& s) noexcept
+    {
+        ctl::swap(blob, s.blob);
+    }
+
+    string(string&& s) noexcept
+    {
+        __builtin_memcpy(blob, s.blob, __::string_size);
+        s.set_small_size(0);
+    }
+
+    void clear() noexcept
+    {
+        if (isbig()) {
+            big()->n = 0;
+        } else {
+            set_small_size(0);
+        }
+    }
+
+    bool empty() const noexcept
+    {
+        return isbig() ? !big()->n : small()->rem >= __::sso_max;
+    }
+
+    char* data() noexcept
+    {
+        return isbig() ? big()->p : small()->buf;
+    }
+
+    const char* data() const noexcept
+    {
+        return isbig() ? big()->p : small()->buf;
+    }
+
+    size_t size() const noexcept
+    {
+#if 0
+        if (!isbig() && small()->rem > __::sso_max)
+            __builtin_trap();
+#endif
+        return isbig() ? big()->n : __::sso_max - small()->rem;
+    }
+
+    size_t length() const noexcept
+    {
+        return size();
+    }
+
+    size_t capacity() const noexcept
+    {
+#if 0
+        if (isbig() && big()->c <= __::sso_max)
+            __builtin_trap();
+#endif
+        return isbig() ? __::big_mask & big()->c : __::string_size;
+    }
+
+    iterator begin() noexcept
+    {
+        return data();
+    }
+
+    iterator end() noexcept
+    {
+        return data() + size();
+    }
+
+    const_iterator cbegin() const noexcept
+    {
+        return data();
+    }
+
+    const_iterator cend() const noexcept
+    {
+        return data() + size();
+    }
+
+    char& front()
+    {
+        if (!size())
+            __builtin_trap();
+        return data()[0];
+    }
+
+    const char& front() const
+    {
+        if (!size())
+            __builtin_trap();
+        return data()[0];
+    }
+
+    char& back()
+    {
+        if (!size())
+            __builtin_trap();
+        return data()[size() - 1];
+    }
+
+    const char& back() const
+    {
+        if (!size())
+            __builtin_trap();
+        return data()[size() - 1];
+    }
+
+    char& operator[](size_t i) noexcept
+    {
+        if (i >= size())
+            __builtin_trap();
+        return data()[i];
+    }
+
+    const char& operator[](const size_t i) const noexcept
+    {
+        if (i >= size())
+            __builtin_trap();
+        return data()[i];
+    }
+
+    void push_back(const char ch) noexcept
+    {
+        append(ch);
+    }
+
+    void append(const string_view s) noexcept
+    {
+        append(s.p, s.n);
+    }
+
+    operator string_view() const noexcept
+    {
+        return string_view(data(), size());
+    }
+
+    string& operator=(const char* s) noexcept
+    {
+        clear();
+        append(s);
+        return *this;
+    }
+
+    string& operator=(const string_view s) noexcept
+    {
+        clear();
+        append(s);
+        return *this;
+    }
+
+    string& operator+=(const char x) noexcept
+    {
+        append(x);
+        return *this;
+    }
+
+    string& operator+=(const string_view s) noexcept
+    {
+        append(s);
+        return *this;
+    }
+
+    string operator+(const string_view s) const noexcept
+    {
+        return strcat(*this, s);
+    }
+
+    int compare(const string_view s) const noexcept
+    {
+        return strcmp(*this, s);
+    }
+
+    bool operator<(const string_view s) const noexcept
+    {
+        return compare(s) < 0;
+    }
+
+    bool operator<=(const string_view s) const noexcept
+    {
+        return compare(s) <= 0;
+    }
+
+    bool operator>(const string_view s) const noexcept
+    {
+        return compare(s) > 0;
+    }
+
+    bool operator>=(const string_view s) const noexcept
+    {
+        return compare(s) >= 0;
+    }
+
+  private:
+    void destroy_big() noexcept;
+    void init_big(const string&) noexcept;
+    void init_big(string_view) noexcept;
+    void init_big(size_t, char) noexcept;
+
+    bool isbig() const noexcept
+    {
+        return *(blob + __::sso_max) & 0x80;
+    }
+
+    void set_small_size(const size_t size) noexcept
+    {
+        if (size > __::sso_max)
+            __builtin_trap();
+        __s.rem = __::sso_max - size;
+    }
+
+    void set_big_string(char* const p, const size_t n, const size_t c2) noexcept
+    {
+        if (c2 > __::big_mask)
+            __builtin_trap();
+        __b.p = p;
+        __b.n = n;
+        __b.c = c2 | ~__::big_mask;
+    }
+
+    __::small_string* small() noexcept
+    {
+        if (isbig())
+            __builtin_trap();
+        return &__s;
+    }
+
+    const __::small_string* small() const noexcept
+    {
+        if (isbig())
+            __builtin_trap();
+        return &__s;
+    }
+
+    __::big_string* big() noexcept
+    {
+        if (!isbig())
+            __builtin_trap();
+        return &__b;
+    }
+
+    const __::big_string* big() const noexcept
+    {
+        if (!isbig())
+            __builtin_trap();
+        return &__b;
+    }
+
+    friend string strcat(string_view, string_view) noexcept;
+
+    union
+    {
+        __::big_string __b;
+        __::small_string __s;
+        char blob[__::string_size];
+    };
+};
+
+static_assert(sizeof(string) == __::string_size);
+static_assert(sizeof(__::small_string) == __::string_size);
+static_assert(sizeof(__::big_string) == __::string_size);
+
+} // namespace ctl
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+inline ctl::string
+operator"" s(const char* s, size_t n)
+{
+    return ctl::string(s, n);
+}
+#pragma GCC diagnostic pop
+
+#endif // CTL_STRING_H_

ctl/string_view.cc

@@ -0,0 +1,111 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "string_view.h"
+
+#include <stdckdint.h>
+#include <string.h>
+
+#include "string.h"
+
+namespace ctl {
+
+size_t
+string_view::find(const char ch, const size_t pos) const noexcept
+{
+    char* q;
+    if (n && (q = (char*)memchr(p, ch, n)))
+        return q - p;
+    return npos;
+}
+
+size_t
+string_view::find(const string_view s, const size_t pos) const noexcept
+{
+    char* q;
+    if (pos > n)
+        __builtin_trap();
+    if ((q = (char*)memmem(p + pos, n - pos, s.p, s.n)))
+        return q - p;
+    return npos;
+}
+
+string_view
+string_view::substr(const size_t pos, size_t count) const noexcept
+{
+    size_t last;
+    if (pos > n)
+        __builtin_trap();
+    if (count > n - pos)
+        count = n - pos;
+    if (ckd_add(&last, pos, count))
+        last = n;
+    if (last > n)
+        __builtin_trap();
+    return string_view(p + pos, count);
+}
+
+bool
+string_view::operator==(const string_view s) const noexcept
+{
+    if (n != s.n)
+        return false;
+    if (!n)
+        return true;
+    return !memcmp(p, s.p, n);
+}
+
+bool
+string_view::operator!=(const string_view s) const noexcept
+{
+    if (n != s.n)
+        return true;
+    if (!n)
+        return false;
+    return !!memcmp(p, s.p, n);
+}
+
+bool
+string_view::contains(const string_view s) const noexcept
+{
+    if (!s.n)
+        return true;
+    return !!memmem(p, n, s.p, s.n);
+}
+
+bool
+string_view::ends_with(const string_view s) const noexcept
+{
+    if (n < s.n)
+        return false;
+    if (!s.n)
+        return true;
+    return !memcmp(p + n - s.n, s.p, s.n);
+}
+
+bool
+string_view::starts_with(const string_view s) const noexcept
+{
+    if (n < s.n)
+        return false;
+    if (!s.n)
+        return true;
+    return !memcmp(p, s.p, s.n);
+}
+
+} // namespace ctl

ctl/string_view.h

@@ -0,0 +1,160 @@
+// -*-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_
+#include "utility.h"
+
+namespace ctl {
+
+struct string_view;
+
+int
+strcmp(const string_view, const string_view) noexcept;
+
+struct string_view
+{
+    const char* p;
+    size_t n;
+
+    using iterator = const char*;
+    using const_iterator = const char*;
+    static constexpr size_t npos = -1;
+
+    constexpr string_view() noexcept : p(nullptr), n(0)
+    {
+    }
+
+    constexpr string_view(const char* s) noexcept
+      : p(s), n(s ? __builtin_strlen(s) : 0)
+    {
+    }
+
+    constexpr string_view(const char* s, const size_t n) noexcept : p(s), n(n)
+    {
+    }
+
+    inline constexpr ~string_view() noexcept
+    {
+    }
+
+    bool operator==(string_view) const noexcept;
+    bool operator!=(string_view) const noexcept;
+    bool contains(string_view) const noexcept;
+    bool ends_with(string_view) const noexcept;
+    bool starts_with(string_view) const noexcept;
+    string_view substr(size_t = 0, size_t = npos) const noexcept;
+    size_t find(char, size_t = 0) const noexcept;
+    size_t find(string_view, size_t = 0) const noexcept;
+
+    constexpr string_view& operator=(const string_view s) noexcept
+    {
+        p = s.p;
+        n = s.n;
+        return *this;
+    }
+
+    constexpr bool empty() const noexcept
+    {
+        return !n;
+    }
+
+    constexpr const char* data() const noexcept
+    {
+        return p;
+    }
+
+    constexpr size_t size() const noexcept
+    {
+        return n;
+    }
+
+    constexpr size_t length() const noexcept
+    {
+        return n;
+    }
+
+    constexpr const char& operator[](const size_t i) const noexcept
+    {
+        if (i >= n)
+            __builtin_trap();
+        return p[i];
+    }
+
+    constexpr void remove_prefix(const size_t count)
+    {
+        if (count > n)
+            __builtin_trap();
+        p += count;
+        n -= count;
+    }
+
+    constexpr void remove_suffix(const size_t count)
+    {
+        if (count > n)
+            __builtin_trap();
+        n -= count;
+    }
+
+    constexpr const char& front() const
+    {
+        if (!n)
+            __builtin_trap();
+        return p[0];
+    }
+
+    constexpr const char& back() const
+    {
+        if (!n)
+            __builtin_trap();
+        return p[n - 1];
+    }
+
+    constexpr const_iterator begin() noexcept
+    {
+        return p;
+    }
+
+    constexpr const_iterator end() noexcept
+    {
+        return p + n;
+    }
+
+    constexpr const_iterator cbegin() const noexcept
+    {
+        return p;
+    }
+
+    constexpr const_iterator cend() const noexcept
+    {
+        return p + n;
+    }
+
+    int compare(const string_view s) const noexcept
+    {
+        return strcmp(*this, s);
+    }
+
+    bool operator<(const string_view s) const noexcept
+    {
+        return compare(s) < 0;
+    }
+
+    bool operator<=(const string_view s) const noexcept
+    {
+        return compare(s) <= 0;
+    }
+
+    bool operator>(const string_view s) const noexcept
+    {
+        return compare(s) > 0;
+    }
+
+    bool operator>=(const string_view s) const noexcept
+    {
+        return compare(s) >= 0;
+    }
+};
+
+} // namespace ctl
+
+#endif // COSMOPOLITAN_CTL_STRINGVIEW_H_

ctl/unique_ptr.cc

@@ -0,0 +1,19 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "unique_ptr.h"

ctl/unique_ptr.h

@@ -0,0 +1,163 @@
+// -*-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_UNIQUE_PTR_H_
+#define COSMOPOLITAN_CTL_UNIQUE_PTR_H_
+#include "utility.h"
+#include <__type_traits/is_convertible.h>
+
+namespace ctl {
+
+template<typename T>
+struct default_delete
+{
+    constexpr default_delete() noexcept = default;
+    template<typename U>
+    constexpr default_delete(default_delete<U>&&) noexcept
+    {
+    }
+    constexpr void operator()(T* const p) const noexcept
+    {
+        delete p;
+    }
+};
+
+template<typename T>
+struct default_delete<T[]>
+{
+    constexpr default_delete() noexcept = default;
+    template<typename U>
+    constexpr default_delete(default_delete<U>&&) noexcept
+    {
+    }
+    constexpr void operator()(T* const p) const noexcept
+    {
+        delete[] p;
+    }
+};
+
+template<typename T, typename D = default_delete<T>>
+struct unique_ptr
+{
+    using pointer = T*;
+    using element_type = T;
+    using deleter_type = D;
+
+    pointer p;
+    [[no_unique_address]] deleter_type d;
+
+    constexpr unique_ptr(const nullptr_t = nullptr) noexcept : p(nullptr), d()
+    {
+    }
+
+    constexpr unique_ptr(const pointer p) noexcept : p(p), d()
+    {
+    }
+
+    constexpr unique_ptr(const pointer p, auto&& d) noexcept
+      : p(p), d(ctl::forward<decltype(d)>(d))
+    {
+    }
+
+    template<typename U, typename E>
+        requires std::is_convertible_v<U, T> && std::is_convertible_v<E, D>
+    constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept
+      : p(u.p), d(ctl::move(u.d))
+    {
+        u.p = nullptr;
+    }
+
+    unique_ptr(const unique_ptr&) = delete;
+
+    constexpr ~unique_ptr() /* noexcept */
+    {
+        if (p)
+            d(p);
+    }
+
+    constexpr unique_ptr& operator=(unique_ptr r) noexcept
+    {
+        swap(r);
+        return *this;
+    }
+
+    constexpr pointer release() noexcept
+    {
+        pointer r = p;
+        p = nullptr;
+        return r;
+    }
+
+    constexpr void reset(const pointer p2 = pointer()) noexcept
+    {
+        const pointer r = p;
+        p = p2;
+        if (r)
+            d(r);
+    }
+
+    constexpr void swap(unique_ptr& r) noexcept
+    {
+        using ctl::swap;
+        swap(p, r.p);
+        swap(d, r.d);
+    }
+
+    constexpr pointer get() const noexcept
+    {
+        return p;
+    }
+
+    constexpr deleter_type& get_deleter() noexcept
+    {
+        return d;
+    }
+
+    constexpr const deleter_type& get_deleter() const noexcept
+    {
+        return d;
+    }
+
+    constexpr explicit operator bool() const noexcept
+    {
+        return p;
+    }
+
+    element_type& operator*() const noexcept(noexcept(*ctl::declval<pointer>()))
+    {
+        if (!p)
+            __builtin_trap();
+        return *p;
+    }
+
+    pointer operator->() const noexcept
+    {
+        if (!p)
+            __builtin_trap();
+        return p;
+    }
+};
+
+template<typename T, typename... Args>
+constexpr unique_ptr<T>
+make_unique(Args&&... args)
+{
+    return unique_ptr<T>(new T(ctl::forward<Args>(args)...));
+}
+
+template<typename T>
+constexpr unique_ptr<T>
+make_unique_for_overwrite()
+{
+#if 0
+    // You'd think that it'd work like this, but std::unique_ptr does not.
+    return unique_ptr<T>(
+      static_cast<T*>(::operator new(sizeof(T), align_val_t(alignof(T)))));
+#else
+    return unique_ptr<T>(new T);
+#endif
+}
+
+// TODO(mrdomino): specializations for T[]
+
+} // namespace ctl
+#endif // COSMOPOLITAN_CTL_UNIQUE_PTR_H_

ctl/utility.cc

@@ -0,0 +1,19 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "utility.h"

ctl/utility.h

@@ -0,0 +1,61 @@
+// -*-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_UTILITY_H_
+#define COSMOPOLITAN_CTL_UTILITY_H_
+
+namespace ctl {
+
+namespace __ {
+
+template<typename T>
+struct no_infer_
+{
+    typedef T type;
+};
+
+template<typename T>
+using no_infer = typename no_infer_<T>::type;
+
+} // namespace __
+
+template<typename T>
+constexpr T&&
+move(T& t) noexcept
+{
+    return static_cast<T&&>(t);
+}
+
+template<typename T>
+constexpr T&&
+forward(__::no_infer<T>& t) noexcept
+{
+    return static_cast<T&&>(t);
+}
+
+template<typename T>
+// TODO(mrdomino): requires move_constructible<T> && move_assignable<T>
+constexpr void
+swap(T& a, T& b) noexcept
+{
+    T t(ctl::move(a));
+    a = ctl::move(b);
+    b = ctl::move(t);
+}
+
+template<typename T, size_t N>
+// TODO(mrdomino): requires is_swappable
+constexpr void
+swap(T (&a)[N], T (&b)[N]) noexcept
+{
+    for (size_t i = 0; i < N; ++i) {
+        swap(a[i], b[i]);
+    }
+}
+
+template<typename T>
+T&&
+declval() noexcept;
+
+} // namespace ctl
+
+#endif // COSMOPOLITAN_CTL_UTILITY_H_

ctl/vector.h

@@ -0,0 +1,245 @@
+// -*-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_OPTIONAL_H_
+#define COSMOPOLITAN_CTL_OPTIONAL_H_
+#include "new.h"
+#include "utility.h"
+
+namespace ctl {
+
+template<typename T>
+struct vector
+{
+    size_t n = 0;
+    size_t c = 0;
+    T* p = nullptr;
+
+    using iterator = T*;
+    using const_iterator = const T*;
+
+    vector() = default;
+
+    ~vector()
+    {
+        delete[] p;
+    }
+
+    vector(const vector& other)
+    {
+        n = other.n;
+        c = other.c;
+        p = new T[c];
+        for (size_t i = 0; i < n; ++i)
+            new (&p[i]) T(other.p[i]);
+    }
+
+    vector(vector&& other) noexcept
+    {
+        n = other.n;
+        c = other.c;
+        p = other.p;
+        other.n = 0;
+        other.c = 0;
+        other.p = nullptr;
+    }
+
+    explicit vector(size_t count, const T& value = T())
+    {
+        n = count;
+        c = count;
+        p = new T[c];
+        for (size_t i = 0; i < n; ++i)
+            new (&p[i]) T(value);
+    }
+
+    vector& operator=(const vector& other)
+    {
+        if (this != &other) {
+            T* newData = new T[other.c];
+            for (size_t i = 0; i < other.n; ++i) {
+                newData[i] = other.p[i];
+            }
+            delete[] p;
+            p = newData;
+            n = other.n;
+            c = other.c;
+        }
+        return *this;
+    }
+
+    vector& operator=(vector&& other) noexcept
+    {
+        if (this != &other) {
+            delete[] p;
+            p = other.p;
+            n = other.n;
+            c = other.c;
+            other.p = nullptr;
+            other.n = 0;
+            other.c = 0;
+        }
+        return *this;
+    }
+
+    bool empty() const
+    {
+        return !n;
+    }
+
+    size_t size() const
+    {
+        return n;
+    }
+
+    size_t capacity() const
+    {
+        return c;
+    }
+
+    T& operator[](size_t i)
+    {
+        if (i >= n)
+            __builtin_trap();
+        return p[i];
+    }
+
+    const T& operator[](size_t i) const
+    {
+        if (i >= n)
+            __builtin_trap();
+        return p[i];
+    }
+
+    iterator begin()
+    {
+        return p;
+    }
+
+    iterator end()
+    {
+        return p + n;
+    }
+
+    const_iterator cbegin() const
+    {
+        return p;
+    }
+
+    const_iterator cend() const
+    {
+        return p + n;
+    }
+
+    T& front()
+    {
+        if (!n)
+            __builtin_trap();
+        return p[0];
+    }
+
+    const T& front() const
+    {
+        if (!n)
+            __builtin_trap();
+        return p[0];
+    }
+
+    T& back()
+    {
+        if (!n)
+            __builtin_trap();
+        return p[n - 1];
+    }
+
+    const T& back() const
+    {
+        if (!n)
+            __builtin_trap();
+        return p[n - 1];
+    }
+
+    void clear()
+    {
+        for (size_t i = 0; i < n; ++i)
+            p[i].~T();
+        n = 0;
+    }
+
+    void reserve(size_t c2)
+    {
+        if (c2 <= c)
+            return;
+        T* newP = new T[c2];
+        for (size_t i = 0; i < n; ++i)
+            newP[i] = ctl::move(p[i]);
+        delete[] p;
+        p = newP;
+        c = c2;
+    }
+
+    void push_back(const T& e)
+    {
+        if (n == c) {
+            size_t c2 = c + 1;
+            c2 += c2 >> 1;
+            reserve(c2);
+        }
+        new (&p[n]) T(e);
+        ++n;
+    }
+
+    void push_back(T&& e)
+    {
+        if (n == c) {
+            size_t c2 = c + 1;
+            c2 += c2 >> 1;
+            reserve(c2);
+        }
+        new (&p[n]) T(ctl::forward<T>(e));
+        ++n;
+    }
+
+    template<typename... Args>
+    void emplace_back(Args&&... args)
+    {
+        if (n == c) {
+            size_t c2 = c + 1;
+            c2 += c2 >> 1;
+            reserve(c2);
+        }
+        new (&p[n]) T(ctl::forward<Args>(args)...);
+        ++n;
+    }
+
+    void pop_back()
+    {
+        if (n > 0) {
+            --n;
+            p[n].~T();
+        }
+    }
+
+    void resize(size_t n2)
+    {
+        if (n2 > n) {
+            reserve(n2);
+            for (size_t i = n; i < n2; ++i)
+                new (&p[i]) T();
+        } else if (n2 < n) {
+            for (size_t i = n2; i < n; ++i)
+                p[i].~T();
+        }
+        n = n2;
+    }
+
+    void swap(vector& other) noexcept
+    {
+        ctl::swap(n, other.n);
+        ctl::swap(c, other.c);
+        ctl::swap(p, other.p);
+    }
+};
+
+} // namespace ctl
+
+#endif // COSMOPOLITAN_CTL_OPTIONAL_H_

dsp/core/core.h

@@ -9,8 +9,8 @@ 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 *dct(float[restrict hasatleast 8][8], unsigned, float, float, float, float,
+          float);
 void *dctjpeg(float[restrict hasatleast 8][8], unsigned);
 double det3(const double[3][3]) nosideeffect;
 void *inv3(double[restrict 3][3], const double[restrict 3][3], double);

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[restrict 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],

dsp/core/gamma.c

@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/core/core.h"
 #include "dsp/core/gamma.h"
+#include "dsp/core/core.h"
 #include "libc/math.h"
 
 double rgb2stdpc(double x, double g) {

dsp/mpeg/BUILD.mk

@@ -35,7 +35,6 @@ DSP_MPEG_A_DIRECTDEPS =				\
 	LIBC_STDIO				\
 	LIBC_STR				\
 	LIBC_SYSV				\
-	LIBC_TIME				\
 	LIBC_TINYMATH				\
 	THIRD_PARTY_COMPILER_RT
 

dsp/mpeg/buffer.h

@@ -64,7 +64,8 @@ forceinline bool plm_buffer_has(plm_buffer_t *b, size_t bits) {
 }
 
 forceinline int plm_buffer_read(plm_buffer_t *self, int count) {
-  if (!plm_buffer_has(self, count)) return 0;
+  if (!plm_buffer_has(self, count))
+    return 0;
   int value = 0;
   while (count) {
     int current_byte = self->bytes[self->bit_index >> 3];

dsp/mpeg/demux.h

@@ -3,8 +3,8 @@
 #include "dsp/mpeg/mpeg.h"
 COSMOPOLITAN_C_START_
 
-#define START_PACK 0xBA
-#define START_END 0xB9
+#define START_PACK   0xBA
+#define START_END    0xB9
 #define START_SYSTEM 0xBB
 
 typedef struct plm_demux_t {

dsp/mpeg/mpeg1.c

@@ -39,7 +39,7 @@
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
-#include "libc/time/time.h"
+#include "libc/time.h"
 #include "libc/x/x.h"
 __static_yoink("pl_mpeg_notice");
 

dsp/scale/BUILD.mk

@@ -31,7 +31,6 @@ DSP_SCALE_A_DIRECTDEPS =			\
 	LIBC_NEXGEN32E				\
 	LIBC_RUNTIME				\
 	LIBC_STR				\
-	LIBC_TIME				\
 	LIBC_TINYMATH				\
 	LIBC_X
 

dsp/tty/BUILD.mk

@@ -38,7 +38,6 @@ DSP_TTY_A_DIRECTDEPS =				\
 	LIBC_SOCK				\
 	LIBC_SYSV				\
 	LIBC_TINYMATH				\
-	LIBC_TIME				\
 	LIBC_X
 
 DSP_TTY_A_DEPS :=				\

dsp/tty/altbuf.c

@@ -24,9 +24,13 @@
  * The alternate buffer trick lets one restore the console exactly as it
  * was, once the program is done running.
  */
-int ttyenablealtbuf(int ttyfd) { return ttysend(ttyfd, "\e[?1049h"); }
+int ttyenablealtbuf(int ttyfd) {
+  return ttysend(ttyfd, "\e[?1049h");
+}
 
 /**
  * Asks teletypewriter to restore blinking box thing.
  */
-int ttydisablealtbuf(int ttyfd) { return ttysend(ttyfd, "\e[?1049l"); }
+int ttydisablealtbuf(int ttyfd) {
+  return ttysend(ttyfd, "\e[?1049l");
+}

dsp/tty/savecursor.c

@@ -21,9 +21,13 @@
 /**
  * Asks teletypewriter to push current position.
  */
-int ttysavecursor(int ttyfd) { return ttysend(ttyfd, "\e[s"); }
+int ttysavecursor(int ttyfd) {
+  return ttysend(ttyfd, "\e[s");
+}
 
 /**
  * Asks teletypewriter to pop previous position.
  */
-int ttyrestorecursor(int ttyfd) { return ttysend(ttyfd, "\e[u"); }
+int ttyrestorecursor(int ttyfd) {
+  return ttysend(ttyfd, "\e[u");
+}

dsp/tty/setbgfg16.c

@@ -39,8 +39,12 @@ static char *setansibgfg(char *p, unsigned bg, unsigned fg) {
   return p;
 }
 
-char *setbg16_(char *p, struct TtyRgb bg) { return setansibgfg(p, bg.xt, -1u); }
-char *setfg16_(char *p, struct TtyRgb fg) { return setansibgfg(p, -1u, fg.xt); }
+char *setbg16_(char *p, struct TtyRgb bg) {
+  return setansibgfg(p, bg.xt, -1u);
+}
+char *setfg16_(char *p, struct TtyRgb fg) {
+  return setansibgfg(p, -1u, fg.xt);
+}
 char *setbgfg16_(char *p, struct TtyRgb bg, struct TtyRgb fg) {
   return setansibgfg(p, bg.xt, fg.xt);
 }

dsp/tty/ttyraw.c

@@ -87,7 +87,7 @@ static textexit void ttyraw_onexit(void) {
   ttyraw_disable();
 }
 
-static relegated void ttyraw_onsig(int sig, struct siginfo *info,
+static relegated void ttyraw_onsig(int sig, siginfo_t *info,
                                    struct ucontext *ctx) {
   size_t i;
   if (g_ttyraw.noreentry)

examples/BUILD.mk

@@ -65,7 +65,6 @@ EXAMPLES_DIRECTDEPS =						\
 	LIBC_SYSV_CALLS						\
 	LIBC_TESTLIB						\
 	LIBC_THREAD						\
-	LIBC_TIME						\
 	LIBC_TINYMATH						\
 	LIBC_VGA						\
 	LIBC_X							\
@@ -89,8 +88,10 @@ EXAMPLES_DIRECTDEPS =						\
 	THIRD_PARTY_SED						\
 	THIRD_PARTY_STB						\
 	THIRD_PARTY_TR						\
+	THIRD_PARTY_TZ						\
 	THIRD_PARTY_VQSORT					\
 	THIRD_PARTY_XED						\
+	THIRD_PARTY_LIBCXXABI					\
 	THIRD_PARTY_ZLIB					\
 	TOOL_ARGS						\
 	TOOL_BUILD_LIB						\
@@ -154,7 +155,8 @@ o/$(MODE)/examples/picol.dbg:					\
 	@$(APELINK)
 
 o/$(MODE)/usr/share/dict/words.zip.o: private ZIPOBJ_FLAGS += -C2
-o/$(MODE)/examples/wut.o: private COPTS += -fopenmp
+
+o/$(MODE)/examples/blas.o: private COPTS += -O3 -fopenmp
 
 $(EXAMPLES_OBJS): examples/BUILD.mk
 

examples/blas.cc

@@ -0,0 +1,221 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <unistd.h>
+#include <cinttypes>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include "libc/assert.h"
+
+// high performance high accuracy matrix multiplication in ansi c
+
+#define MATH __target_clones("avx512f,fma")
+
+namespace {
+namespace ansiBLAS {
+
+static constexpr int KN = 8;
+
+struct Vector {
+  double v[KN];
+};
+
+Vector load(const float *p) {
+  Vector x;
+  for (int i = 0; i < KN; ++i)
+    x.v[i] = p[i];
+  return x;
+}
+
+Vector madd(Vector x, Vector y, Vector s) {
+  for (int i = 0; i < KN; ++i)
+    s.v[i] = fma(x.v[i], y.v[i], s.v[i]);
+  return s;
+}
+
+float hsum(Vector x) {
+  double s = 0;
+  for (int i = 0; i < KN; ++i)
+    s += x.v[i];
+  return s;
+}
+
+struct ansiBLAS {
+ public:
+  ansiBLAS(int k, const float *A, int lda, const float *B, int ldb, float *C,
+           int ldc, int ith, int nth)
+      : k(k),
+        A(A),
+        lda(lda),
+        B(B),
+        ldb(ldb),
+        C(C),
+        ldc(ldc),
+        ith(ith),
+        nth(nth) {
+  }
+
+  void matmul(int m, int n) {
+    mnpack(0, m, 0, n);
+  }
+
+ private:
+  void mnpack(int m0, int m, int n0, int n) {
+    int mc, nc, mp, np;
+    if (m - m0 <= 0 || n - n0 <= 0)
+      return;
+    if (m - m0 >= 4 && n - n0 >= 3) {
+      mc = 4;
+      nc = 3;
+      gemm<4, 3>(m0, m, n0, n);
+    } else {
+      mc = 1;
+      nc = 1;
+      gemm<1, 1>(m0, m, n0, n);
+    }
+    mp = m0 + (m - m0) / mc * mc;
+    np = n0 + (n - n0) / nc * nc;
+    mnpack(mp, m, n0, np);
+    mnpack(m0, m, np, n);
+  }
+
+  template <int RM, int RN>
+  MATH void gemm(int m0, int m, int n0, int n) {
+    int ytiles = (m - m0) / RM;
+    int xtiles = (n - n0) / RN;
+    int tiles = xtiles * ytiles;
+    int duty = (tiles + nth - 1) / nth;
+    int start = duty * ith;
+    int end = start + duty;
+    if (end > tiles)
+      end = tiles;
+    for (int job = start; job < end; ++job) {
+      int ii = m0 + job / xtiles * RM;
+      int jj = n0 + job % xtiles * RN;
+      Vector Cv[RN][RM] = {};
+      for (int l = 0; l < k; l += KN)
+        for (int j = 0; j < RN; ++j)
+          for (int i = 0; i < RM; ++i)
+            Cv[j][i] = madd(load(A + lda * (ii + i) + l),  //
+                            load(B + ldb * (jj + j) + l),  //
+                            Cv[j][i]);
+      for (int j = 0; j < RN; ++j)
+        for (int i = 0; i < RM; ++i)
+          C[ldc * (jj + j) + (ii + i)] = hsum(Cv[j][i]);
+    }
+  }
+
+  const int k;
+  const float *const A;
+  const int lda;
+  const float *const B;
+  const int ldb;
+  float *const C;
+  const int ldc;
+  const int ith;
+  const int nth;
+};
+
+void sgemm(int m, int n, int k,      //
+           const float *A, int lda,  //
+           const float *B, int ldb,  //
+           float *C, int ldc) {
+  int nth = sysconf(_SC_NPROCESSORS_ONLN);
+#pragma omp parallel for
+  for (int ith = 0; ith < nth; ++ith) {
+    ansiBLAS tb{k, A, lda, B, ldb, C, ldc, ith, nth};
+    tb.matmul(m, n);
+  }
+}
+
+}  // namespace ansiBLAS
+
+long micros(void) {
+  struct timespec ts;
+  clock_gettime(CLOCK_REALTIME, &ts);
+  return ts.tv_sec * 1000000 + (ts.tv_nsec + 999) / 1000;
+}
+
+unsigned rand32(void) {
+  /* Knuth, D.E., "The Art of Computer Programming," Vol 2,
+     Seminumerical Algorithms, Third Edition, Addison-Wesley, 1998,
+     p. 106 (line 26) & p. 108 */
+  static unsigned long long lcg = 1;
+  lcg *= 6364136223846793005;
+  lcg += 1442695040888963407;
+  return lcg >> 32;
+}
+
+float float01(unsigned x) {  // (0,1)
+  return 1.f / 8388608 * ((x >> 9) + .5f);
+}
+
+float numba(void) {  // (-1,1)
+  return float01(rand32()) * 2 - 1;
+}
+
+void fill(int m, int n, float *A, int lda) {
+  for (int j = 0; j < n; ++j)
+    for (int i = 0; i < m; ++i)
+      A[lda * j + i] = numba();
+}
+
+float *new_matrix(int m, int n, int *lda) {
+  void *ptr = 0;
+  int b = 64 / sizeof(float);
+  *lda = (n + b - 1) & -b;
+  posix_memalign(&ptr, 4096, sizeof(float) * m * *lda);
+  return (float *)ptr;
+}
+
+}  // namespace
+
+void barrier(void) {
+}
+void (*pBarrier)(void) = barrier;
+
+#define BENCH(x)                                                           \
+  do {                                                                     \
+    x;                                                                     \
+    int N = 10;                                                            \
+    long t1 = micros();                                                    \
+    for (long i = 0; i < N; ++i) {                                         \
+      pBarrier();                                                          \
+      x;                                                                   \
+    }                                                                      \
+    long t2 = micros();                                                    \
+    printf("%8" PRId64 " µs %s %g gigaflops\n", (t2 - t1 + N - 1) / N, #x, \
+           1e6 / ((t2 - t1 + N - 1) / N) * m * n * k * 2 * 1e-9);          \
+  } while (0)
+
+int main() {
+  int m = 1024;
+  int n = 1024;
+  int k = 1024;
+  int lda, ldb, ldc;
+  float *A = new_matrix(m, k, &lda);
+  float *B = new_matrix(n, k, &ldb);
+  float *C = new_matrix(n, m, &ldc);
+  fill(k, n, A, lda);
+  fill(k, m, B, ldb);
+  BENCH(ansiBLAS::sgemm(m, n, k, A, lda, B, ldb, C, ldc));
+  assert(C[0] == -0x1.20902ap+4);
+  assert(C[1] == -0x1.bf7726p+4);
+  free(C);
+  free(B);
+  free(A);
+}

examples/crashreport.c

@@ -7,6 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
+#include "libc/calls/calls.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/math.h"
 #include "libc/runtime/runtime.h"
@@ -26,6 +27,13 @@
  *     o//examples/crashreport.com
  */
 
+int Divide(int x, int y) {
+  volatile int z = 0;  // force creation of stack frame
+  return x / y + z;
+}
+
+int (*pDivide)(int, int) = Divide;
+
 dontubsan int main(int argc, char *argv[]) {
   kprintf("----------------\n");
   kprintf(" THIS IS A TEST \n");
@@ -34,12 +42,7 @@ dontubsan int main(int argc, char *argv[]) {
 
   ShowCrashReports();
 
-  volatile double a = 0;
-  volatile double b = 23;
-  volatile double c = exp(b) / a;
-  (void)c;
-
-  volatile int x = 0;
-  volatile int y = 1 / x;
-  return y;
+  pDivide(1, 0);
+  pDivide(2, 0);
+  pDivide(3, 0);
 }

examples/crashreport2.cc

@@ -7,6 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
+#include "libc/calls/calls.h"
 #include "libc/math.h"
 #include "libc/runtime/runtime.h"
 
@@ -18,6 +19,17 @@ void crash(long x0, long x1, long x2,  //
 void (*pCrash)(long, long, long, double, double, double) = crash;
 
 int main(int argc, char *argv[]) {
+
+  // // by default we launch an addr2line subprocess to print backtraces
+  // // with line numbers. you can force it to use the embedded solution
+  // setenv("ADDR2LINE", "", true);
+
+  // // using a seccomp sandbox is another way to force embedded backtraces
+  // pledge("stdio", NULL);
+
+  // enable the crash reporting feature
   ShowCrashReports();
+
+  // time to die
   pCrash(1, 2, 3, NAN, NAN, NAN);
 }

examples/date.c

@@ -9,19 +9,30 @@
 #endif
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/timespec.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/macros.internal.h"
+#include "libc/nt/enum/timezoneid.h"
+#include "libc/nt/struct/timezoneinformation.h"
+#include "libc/nt/time.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/time/struct/tm.h"
+#include "libc/thread/threads.h"
+#include "libc/time.h"
 
 /**
  * @fileoverview High performance ISO-8601 timestamp formatter.
+ *
+ * The strftime() function is very slow. This goes much faster.
+ * Consider using something like this instead for your loggers.
  */
 
 char *GetTimestamp(void) {
   int x;
   struct timespec ts;
-  _Thread_local static long last;
-  _Thread_local static char s[27];
-  _Thread_local static struct tm tm;
+  thread_local static long last;
+  thread_local static char s[32];
+  thread_local static struct tm tm;
   clock_gettime(0, &ts);
   if (ts.tv_sec != last) {
     localtime_r(&ts.tv_sec, &tm);
@@ -61,11 +72,21 @@ char *GetTimestamp(void) {
   s[23] = '0' + x / 100000 % 10;
   s[24] = '0' + x / 10000 % 10;
   s[25] = '0' + x / 1000 % 10;
+  s[26] = tm.tm_gmtoff < 0 ? '-' : '+';
+  x = ABS(tm.tm_gmtoff) / 60 / 60;
+  s[27] = '0' + x / 10 % 10;
+  s[28] = '0' + x % 10;
+  x = ABS(tm.tm_gmtoff) / 60 % 60;
+  s[29] = '0' + x / 10 % 10;
+  s[30] = '0' + x % 10;
   return s;
 }
 
 int main(int argc, char *argv[]) {
   char buf[128], *p = buf;
+  // setenv("TZ", "UTC", true);
+  // setenv("TZ", "US/Eastern", true);
+  // setenv("TZ", "Asia/Kolkata", true);
   p = stpcpy(p, GetTimestamp());
   p = stpcpy(p, "\n");
   write(1, buf, p - buf);

examples/env.c

@@ -1,9 +1,9 @@
-#include "libc/stdio/stdio.h"
 #include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
 
 int main(int argc, char* argv[]) {
   fprintf(stderr, "%s (%s)\n", argv[0], GetProgramExecutableName());
-  for (char **p = environ; *p; ++p) {
+  for (char** p = environ; *p; ++p) {
     printf("%s\n", *p);
   }
   return 0;

examples/greenbean.c

@@ -23,6 +23,7 @@
 #include <sys/auxv.h>
 #include <sys/socket.h>
 #include <time.h>
+#include "libc/mem/leaks.h"
 
 /**
  * @fileoverview greenbean lightweight threaded web server
@@ -151,7 +152,7 @@ void *Worker(void *id) {
 
       // check that client message wasn't fragmented into more reads
       InitHttpMessage(&msg, kHttpRequest);
-      if ((inmsglen = ParseHttpMessage(&msg, buf, got)) <= 0) {
+      if ((inmsglen = ParseHttpMessage(&msg, buf, got, sizeof(buf))) <= 0) {
         if (!inmsglen) {
           LOG("%6H client sent fragmented message");
         } else {
@@ -411,7 +412,5 @@ int main(int argc, char *argv[]) {
   unassert(!pthread_mutex_destroy(&statuslock));
 
   // quality assurance
-  if (IsModeDbg()) {
-    CheckForMemoryLeaks();
-  }
+  CheckForMemoryLeaks();
 }

examples/hangman.c

@@ -42,7 +42,7 @@
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/time/time.h"
+#include "libc/time.h"
 #include "third_party/zlib/zlib.h"
 // clang-format off
 

examples/hiredis.c

@@ -7,11 +7,11 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/runtime/runtime.h"
+#include "third_party/hiredis/hiredis.h"
 #include "libc/fmt/conv.h"
+#include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "third_party/hiredis/hiredis.h"
 
 /**
  * @fileoverview Demo of using hiredis to connect to a Redis server

examples/kilo.c

@@ -71,7 +71,7 @@ Contact: [email protected]");
 #include "libc/sysv/consts/fileno.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/termios.h"
-#include "libc/time/time.h"
+#include "libc/time.h"
 
 /* Syntax highlight types */
 #define HL_NORMAL    0

examples/localtime.c

@@ -0,0 +1,15 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/time.h"
+
+int main(int argc, char *argv[]) {
+  int64_t t = 0;
+  localtime(&t);
+}

examples/nesemu1.cc

@@ -44,7 +44,7 @@
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/consts/w.h"
 #include "libc/thread/thread.h"
-#include "libc/time/time.h"
+#include "libc/time.h"
 #include "libc/x/xasprintf.h"
 #include "libc/x/xsigaction.h"
 #include "libc/zip.internal.h"
@@ -137,7 +137,7 @@ struct Action {
 
 struct Audio {
   size_t i;
-  int16_t p[FRAMESIZE];
+  int16_t p[65536];
 };
 
 struct Status {

examples/package/BUILD.mk

@@ -42,6 +42,7 @@ EXAMPLES_PACKAGE_OBJS =					\
 EXAMPLES_PACKAGE_DIRECTDEPS =				\
 	EXAMPLES_PACKAGE_LIB				\
 	LIBC_INTRIN					\
+	LIBC_MEM					\
 	LIBC_STDIO					\
 	LIBC_TINYMATH
 

examples/package/lib/BUILD.mk

@@ -71,6 +71,7 @@ EXAMPLES_PACKAGE_LIB_A_CHECKS =					\
 EXAMPLES_PACKAGE_LIB_A_DIRECTDEPS =				\
 	LIBC_INTRIN						\
 	LIBC_NEXGEN32E						\
+	LIBC_MEM						\
 	LIBC_STDIO
 
 # Evaluates variable as set of transitive package dependencies.

examples/parsefloat.c

@@ -1,31 +1,31 @@
 #include <stdio.h>
 
-#define PARSE_AND_PRINT(type, scan_fmt, print_fmt, str)       \
-  do {                                                        \
-    type val; int ret;                                        \
-    ret = sscanf(str, scan_fmt, &val);                        \
-    printf("\"%s\" => " print_fmt " = %d\n", str, val, ret);  \
+#define PARSE_AND_PRINT(type, scan_fmt, print_fmt, str)      \
+  do {                                                       \
+    type val;                                                \
+    int ret;                                                 \
+    ret = sscanf(str, scan_fmt, &val);                       \
+    printf("\"%s\" => " print_fmt " = %d\n", str, val, ret); \
   } while (0)
 
-int main()
-{
-    PARSE_AND_PRINT(float, "%f", "%f", "0.3715");
-    PARSE_AND_PRINT(float, "%f", "%f", ".3715");
-    PARSE_AND_PRINT(float, "%f", "%f", "3715");
-    PARSE_AND_PRINT(float, "%f", "%f", "111.11");
-    PARSE_AND_PRINT(float, "%f", "%f", "-2.22");
-    PARSE_AND_PRINT(float, "%f", "%f", "Nan");
-    PARSE_AND_PRINT(float, "%f", "%f", "nAn(2)");
-    PARSE_AND_PRINT(float, "%f", "%f", "-NAN(_asdfZXCV1234_)");
-    PARSE_AND_PRINT(float, "%f", "%f", "-nan");
-    PARSE_AND_PRINT(float, "%f", "%f", "+nan");
-    PARSE_AND_PRINT(float, "%f", "%f", "inF");
-    PARSE_AND_PRINT(float, "%f", "%f", "iNfINiTy");
-    PARSE_AND_PRINT(float, "%f", "%f", "+inf");
-    PARSE_AND_PRINT(float, "%f", "%f", "-inf");
-    PARSE_AND_PRINT(float, "%f", "%f", "0X1.BC70A3D70A3D7P+6");
-    PARSE_AND_PRINT(float, "%f", "%f", "1.18973e+4932zzz");
-    PARSE_AND_PRINT(float, "%f", "%.10f", "   -0.0000000123junk");
-    PARSE_AND_PRINT(float, "%f", "%f", "junk");
-    return 0;
+int main() {
+  PARSE_AND_PRINT(float, "%f", "%f", "0.3715");
+  PARSE_AND_PRINT(float, "%f", "%f", ".3715");
+  PARSE_AND_PRINT(float, "%f", "%f", "3715");
+  PARSE_AND_PRINT(float, "%f", "%f", "111.11");
+  PARSE_AND_PRINT(float, "%f", "%f", "-2.22");
+  PARSE_AND_PRINT(float, "%f", "%f", "Nan");
+  PARSE_AND_PRINT(float, "%f", "%f", "nAn(2)");
+  PARSE_AND_PRINT(float, "%f", "%f", "-NAN(_asdfZXCV1234_)");
+  PARSE_AND_PRINT(float, "%f", "%f", "-nan");
+  PARSE_AND_PRINT(float, "%f", "%f", "+nan");
+  PARSE_AND_PRINT(float, "%f", "%f", "inF");
+  PARSE_AND_PRINT(float, "%f", "%f", "iNfINiTy");
+  PARSE_AND_PRINT(float, "%f", "%f", "+inf");
+  PARSE_AND_PRINT(float, "%f", "%f", "-inf");
+  PARSE_AND_PRINT(float, "%f", "%f", "0X1.BC70A3D70A3D7P+6");
+  PARSE_AND_PRINT(float, "%f", "%f", "1.18973e+4932zzz");
+  PARSE_AND_PRINT(float, "%f", "%.10f", "   -0.0000000123junk");
+  PARSE_AND_PRINT(float, "%f", "%f", "junk");
+  return 0;
 }

examples/script.c

@@ -50,7 +50,7 @@
 #include "libc/sysv/consts/fileno.h"
 #include "libc/sysv/consts/s.h"
 #include "libc/sysv/consts/termios.h"
-#include "libc/time/time.h"
+#include "libc/time.h"
 #include "third_party/getopt/getopt.internal.h"
 // clang-format off
 

examples/setitimer.c

@@ -17,7 +17,7 @@
 #include "libc/sysv/consts/itimer.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
-#include "libc/time/time.h"
+#include "libc/time.h"
 
 volatile bool gotalrm;
 

examples/stat.c

@@ -8,16 +8,18 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/calls/struct/stat.h"
+#include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
 #include "libc/mem/gc.h"
+#include "libc/mem/mem.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/s.h"
-#include "libc/x/xiso8601.h"
+#include "libc/time.h"
 
 /**
  * @fileoverview File metadata viewer.
@@ -27,6 +29,23 @@
 
 bool numeric;
 
+char *xiso8601(struct timespec ts) {
+  struct tm tm;
+  if (!localtime_r(&ts.tv_sec, &tm))
+    return 0;
+  int len = 128;
+  char *res = malloc(len);
+  char *ptr = res;
+  char *end = res + len;
+  if (!res)
+    return 0;
+  ptr += strftime(ptr, end - ptr, "%Y-%m-%d %H:%M:%S", &tm);
+  ptr += snprintf(ptr, end - ptr, ".%09ld", ts.tv_nsec);
+  ptr += strftime(ptr, end - ptr, "%z %Z", &tm);
+  unassert(ptr + 1 <= end);
+  return res;
+}
+
 const char *DescribeFileType(unsigned mode) {
   switch (mode & S_IFMT) {
     case S_IFIFO:
@@ -74,16 +93,16 @@ void PrintFileMetadata(const char *pathname, struct stat *st) {
          "%-32s%s\n"
          "%-32s%s\n"
          "%-32s%s\n",
-         "bytes in file", st->st_size, "physical bytes", st->st_blocks * 512,
-         "device id w/ file", st->st_dev, "inode", st->st_ino,
-         "hard link count", st->st_nlink, "mode / permissions", st->st_mode,
-         DescribeFileType(st->st_mode), "owner id", st->st_uid, "group id",
-         st->st_gid, "flags", st->st_flags, "gen", st->st_gen,
-         "device id (if special)", st->st_rdev, "block size", st->st_blksize,
-         "access time", gc(xiso8601(&st->st_atim)), "modified time",
-         gc(xiso8601(&st->st_mtim)), "c[omplicated]time",
-         gc(xiso8601(&st->st_ctim)), "birthtime",
-         gc(xiso8601(&st->st_birthtim)));
+         "bytes in file:", st->st_size, "physical bytes:", st->st_blocks * 512,
+         "device id w/ file:", st->st_dev, "inode:", st->st_ino,
+         "hard link count:", st->st_nlink, "mode / permissions:", st->st_mode,
+         DescribeFileType(st->st_mode), "owner id:", st->st_uid,
+         "group id:", st->st_gid, "flags:", st->st_flags, "gen:", st->st_gen,
+         "device id (if special):", st->st_rdev, "block size:", st->st_blksize,
+         "access time:", gc(xiso8601(st->st_atim)),
+         "modified time:", gc(xiso8601(st->st_mtim)),
+         "c[omplicated]time:", gc(xiso8601(st->st_ctim)),
+         "[birthtime]:", gc(xiso8601(st->st_birthtim)));
 }
 
 int main(int argc, char *argv[]) {

examples/unbourne.c

@@ -2601,7 +2601,8 @@ static int shlex() {
       case 'y':
       case 'z':
         p = buf;
-        while (buf++, is_in_name(*buf));
+        while (buf++, is_in_name(*buf))
+          ;
         yylval.name = stalloc(buf - p + 1);
         *(char *)mempcpy(yylval.name, p, buf - p) = 0;
         value = ARITH_VAR;
@@ -3050,7 +3051,7 @@ static const char *updatepwd(const char *dir) {
   if (*dir != '/') {
     if (new[-1] != '/')
       USTPUTC('/', new);
-    if (new > lim &&*lim == '/')
+    if (new > lim && *lim == '/')
       lim++;
   } else {
     USTPUTC('/', new);
@@ -7757,7 +7758,8 @@ static int ulimitcmd(int argc, char **argv) {
         what = optc;
     }
   }
-  for (l = limits; l->option != what; l++);
+  for (l = limits; l->option != what; l++)
+    ;
   set = *argptr ? 1 : 0;
   if (set) {
     char *p = *argptr;
@@ -7986,7 +7988,8 @@ static void setparam(char **argv) {
   char **newparam;
   char **ap;
   int nparam;
-  for (nparam = 0; argv[nparam]; nparam++);
+  for (nparam = 0; argv[nparam]; nparam++)
+    ;
   ap = newparam = ckmalloc((nparam + 1) * sizeof *ap);
   while (*argv) {
     *ap++ = savestr(*argv++);
@@ -8664,7 +8667,8 @@ static void parsefname(void) {
     if (heredoclist == NULL)
       heredoclist = here;
     else {
-      for (p = heredoclist; p->next; p = p->next);
+      for (p = heredoclist; p->next; p = p->next)
+        ;
       p->next = here;
     }
   } else if (n->type == NTOFD || n->type == NFROMFD) {
@@ -8788,7 +8792,8 @@ static int xxreadtoken(void) {
       case '\t':
         continue;
       case '#':
-        while ((c = pgetc()) != '\n' && c != PEOF);
+        while ((c = pgetc()) != '\n' && c != PEOF)
+          ;
         pungetc();
         continue;
       case '\n':

examples/walk.c

@@ -9,11 +9,11 @@
 #endif
 #include "libc/errno.h"
 #include "libc/runtime/runtime.h"
+#include "libc/stdio/ftw.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/exit.h"
 #include "libc/sysv/consts/s.h"
-#include "libc/stdio/ftw.h"
 
 /**
  * @fileoverview Directory walker example.

examples/wall.c

@@ -16,7 +16,7 @@
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/o.h"
-#include "libc/time/struct/tm.h"
+#include "libc/time.h"
 #include "third_party/getopt/getopt.internal.h"
 #include "third_party/musl/passwd.h"
 

libc/BUILD.mk

@@ -4,10 +4,8 @@
 PKGS += LIBC
 
 LIBC_ISYSTEM = \
-libc/isystem/algorithm \
 libc/isystem/alloca.h \
 libc/isystem/ammintrin.h \
-libc/isystem/any \
 libc/isystem/ar.h \
 libc/isystem/arm_acle.h \
 libc/isystem/arm_bf16.h \
@@ -15,51 +13,16 @@ libc/isystem/arm_fp16.h \
 libc/isystem/arm_neon.h \
 libc/isystem/arpa/inet.h \
 libc/isystem/arpa/nameser.h \
-libc/isystem/array \
 libc/isystem/assert.h \
-libc/isystem/atomic \
-libc/isystem/bit \
-libc/isystem/bitset \
 libc/isystem/byteswap.h \
-libc/isystem/cassert \
-libc/isystem/ccomplex \
-libc/isystem/cctype \
-libc/isystem/cerrno \
-libc/isystem/cfenv \
-libc/isystem/cfloat \
-libc/isystem/charconv \
-libc/isystem/chrono \
-libc/isystem/cinttypes \
-libc/isystem/ciso646 \
-libc/isystem/climits \
-libc/isystem/clocale \
 libc/isystem/clzerointrin.h \
-libc/isystem/cmath \
-libc/isystem/codecvt \
-libc/isystem/compare \
-libc/isystem/complex \
 libc/isystem/complex.h \
-libc/isystem/condition_variable \
 libc/isystem/cosmo.h \
 libc/isystem/cpio.h \
 libc/isystem/cpuid.h \
 libc/isystem/crypt.h \
-libc/isystem/csetjmp \
-libc/isystem/csignal \
-libc/isystem/cstdarg \
-libc/isystem/cstdbool \
-libc/isystem/cstddef \
-libc/isystem/cstdint \
-libc/isystem/cstdio \
-libc/isystem/cstdlib \
-libc/isystem/cstring \
-libc/isystem/ctgmath \
-libc/isystem/ctime \
 libc/isystem/ctype.h \
-libc/isystem/cwchar \
-libc/isystem/cwctype \
 libc/isystem/cxxabi.h \
-libc/isystem/deque \
 libc/isystem/dirent.h \
 libc/isystem/dlfcn.h \
 libc/isystem/elf.h \
@@ -67,57 +30,37 @@ libc/isystem/emmintrin.h \
 libc/isystem/endian.h \
 libc/isystem/err.h \
 libc/isystem/errno.h \
-libc/isystem/exception \
-libc/isystem/execution \
 libc/isystem/fcntl.h \
 libc/isystem/features.h \
 libc/isystem/fenv.h \
-libc/isystem/filesystem \
 libc/isystem/float.h \
 libc/isystem/fnmatch.h \
-libc/isystem/forward_list \
-libc/isystem/fstream \
 libc/isystem/ftw.h \
-libc/isystem/functional \
-libc/isystem/future \
 libc/isystem/getopt.h \
 libc/isystem/glob.h \
 libc/isystem/grp.h \
 libc/isystem/iconv.h \
 libc/isystem/ifaddrs.h \
 libc/isystem/immintrin.h \
-libc/isystem/initializer_list \
 libc/isystem/inttypes.h \
-libc/isystem/iomanip \
-libc/isystem/ios \
-libc/isystem/iosfwd \
-libc/isystem/iostream \
 libc/isystem/iso646.h \
-libc/isystem/istream \
-libc/isystem/iterator \
 libc/isystem/langinfo.h \
 libc/isystem/libgen.h \
-libc/isystem/limits \
 libc/isystem/limits.h \
 libc/isystem/link.h \
 libc/isystem/linux/futex.h \
 libc/isystem/linux/limits.h \
 libc/isystem/linux/param.h \
 libc/isystem/linux/types.h \
-libc/isystem/list \
-libc/isystem/locale \
 libc/isystem/locale.h \
 libc/isystem/malloc.h \
-libc/isystem/map \
 libc/isystem/math.h \
-libc/isystem/memory \
 libc/isystem/memory.h \
 libc/isystem/mm3dnow.h \
 libc/isystem/mm_malloc.h \
 libc/isystem/mmintrin.h \
 libc/isystem/mntent.h \
 libc/isystem/monetary.h \
-libc/isystem/mutex \
 libc/isystem/mwaitxintrin.h \
 libc/isystem/net/ethernet.h \
 libc/isystem/net/if.h \
@@ -127,7 +70,6 @@ libc/isystem/netinet/in.h \
 libc/isystem/netinet/ip.h \
 libc/isystem/netinet/tcp.h \
 libc/isystem/netinet/udp.h \
-libc/isystem/new \
 libc/isystem/nl_types.h \
 libc/isystem/nmmintrin.h \
 libc/isystem/nsync.h \
@@ -141,12 +83,9 @@ libc/isystem/nsync_note.h \
 libc/isystem/nsync_once.h \
 libc/isystem/nsync_time.h \
 libc/isystem/nsync_waiter.h \
-libc/isystem/numeric \
 libc/isystem/omp-tools.h \
 libc/isystem/omp.h \
 libc/isystem/ompx.h \
-libc/isystem/optional \
-libc/isystem/ostream \
 libc/isystem/paths.h \
 libc/isystem/pmmintrin.h \
 libc/isystem/poll.h \
@@ -154,27 +93,17 @@ libc/isystem/popcntintrin.h \
 libc/isystem/pthread.h \
 libc/isystem/pty.h \
 libc/isystem/pwd.h \
-libc/isystem/queue \
-libc/isystem/random \
-libc/isystem/ratio \
-libc/isystem/regex \
 libc/isystem/regex.h \
 libc/isystem/resolv.h \
 libc/isystem/sched.h \
-libc/isystem/scoped_allocator \
 libc/isystem/search.h \
 libc/isystem/semaphore.h \
-libc/isystem/set \
 libc/isystem/setjmp.h \
 libc/isystem/sgxintrin.h \
 libc/isystem/shadow.h \
-libc/isystem/shared_mutex \
 libc/isystem/signal.h \
 libc/isystem/smmintrin.h \
-libc/isystem/span \
 libc/isystem/spawn.h \
-libc/isystem/sstream \
-libc/isystem/stack \
 libc/isystem/stdalign.h \
 libc/isystem/stdarg.h \
 libc/isystem/stdatomic.h \
@@ -182,18 +111,13 @@ libc/isystem/stdbool.h \
 libc/isystem/stdc-predef.h \
 libc/isystem/stdckdint.h \
 libc/isystem/stddef.h \
-libc/isystem/stdexcept \
 libc/isystem/stdint.h \
 libc/isystem/stdio.h \
 libc/isystem/stdio_ext.h \
 libc/isystem/stdlib.h \
 libc/isystem/stdnoreturn.h \
-libc/isystem/streambuf \
-libc/isystem/string \
 libc/isystem/string.h \
-libc/isystem/string_view \
 libc/isystem/strings.h \
-libc/isystem/strstream \
 libc/isystem/sys/auxv.h \
 libc/isystem/sys/cdefs.h \
 libc/isystem/sys/dir.h \
@@ -238,39 +162,26 @@ libc/isystem/sys/vfs.h \
 libc/isystem/sys/wait.h \
 libc/isystem/sysexits.h \
 libc/isystem/syslog.h \
-libc/isystem/system_error \
 libc/isystem/termios.h \
 libc/isystem/tgmath.h \
-libc/isystem/thread \
 libc/isystem/threads.h \
 libc/isystem/time.h \
 libc/isystem/tmmintrin.h \
-libc/isystem/tuple \
-libc/isystem/type_traits \
-libc/isystem/typeindex \
-libc/isystem/typeinfo \
 libc/isystem/uchar.h \
 libc/isystem/ucontext.h \
 libc/isystem/uio.h \
 libc/isystem/unistd.h \
-libc/isystem/unordered_map \
-libc/isystem/unordered_set \
 libc/isystem/unwind.h \
-libc/isystem/utility \
 libc/isystem/utime.h \
 libc/isystem/utmp.h \
 libc/isystem/utmpx.h \
-libc/isystem/valarray \
-libc/isystem/variant \
-libc/isystem/vector \
-libc/isystem/version \
 libc/isystem/wait.h \
 libc/isystem/wchar.h \
 libc/isystem/wctype.h \
 libc/isystem/winternl.h \
 libc/isystem/wmmintrin.h \
 libc/isystem/x86intrin.h \
-libc/isystem/xmmintrin.h
+libc/isystem/xmmintrin.h \
 
 LIBC_HDRS = $(filter %.h,$(LIBC_FILES)) $(LIBC_ISYSTEM)
 LIBC_HDRS_H = $(filter %.h,$(LIBC_HDRS))
@@ -300,7 +211,6 @@ o/$(MODE)/libc:	o/$(MODE)/libc/calls		\
 		o/$(MODE)/libc/sysv		\
 		o/$(MODE)/libc/testlib		\
 		o/$(MODE)/libc/thread		\
-		o/$(MODE)/libc/time		\
 		o/$(MODE)/libc/tinymath		\
 		o/$(MODE)/libc/vga		\
 		o/$(MODE)/libc/x		\

libc/calls/BUILD.mk

@@ -147,6 +147,13 @@ o/$(MODE)/libc/calls/pledge-linux.o: private		\
 			-fPIC				\
 			-ffreestanding
 
+# we want -Os because:
+#   it makes a big difference
+#   it gets called very rarely
+o/$(MODE)/libc/calls/sigcrashsig.o: private		\
+		CFLAGS +=				\
+			-Os
+
 # these assembly files are safe to build on aarch64
 o/$(MODE)/libc/calls/getcontext.o: libc/calls/getcontext.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<

libc/calls/asan.internal.h

@@ -1,27 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_ASAN_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_CALLS_ASAN_INTERNAL_H_
-#include "libc/calls/struct/timespec.h"
-#include "libc/calls/struct/timeval.h"
-#include "libc/intrin/asan.internal.h"
-#include "libc/intrin/asmflag.h"
-COSMOPOLITAN_C_START_
-
-forceinline bool __asan_is_valid_timespec(const struct timespec *ts) {
-#ifdef __x86_64__
-  bool zf;
-  asm(ZFLAG_ASM("cmpw\t$0,0x7fff8000(%1)")
-      : ZFLAG_CONSTRAINT(zf)
-      : "r"((intptr_t)ts >> 3)
-      : "memory");
-  return zf;
-#else
-  return __asan_is_valid(ts, sizeof(*ts));
-#endif
-}
-
-forceinline bool __asan_is_valid_timeval(const struct timeval *tv) {
-  return __asan_is_valid_timespec((const struct timespec *)tv);
-}
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_CALLS_ASAN_INTERNAL_H_ */

libc/calls/chdir.c

@@ -20,7 +20,6 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/asan.internal.h"
 #include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/log.h"
@@ -59,7 +58,7 @@ int chdir(const char *path) {
   if (_weaken(GetProgramExecutableName)) {
     _weaken(GetProgramExecutableName)();
   }
-  if (!path || (IsAsan() && !__asan_is_valid_str(path))) {
+  if (!path) {
     rc = efault();
   } else if (_weaken(__zipos_parseuri) &&
              _weaken(__zipos_parseuri)(path, &zipname) != -1) {

libc/calls/chroot.c

@@ -19,7 +19,6 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/asan.internal.h"
 #include "libc/intrin/strace.internal.h"
 #include "libc/sysv/errfuns.h"
 
@@ -49,7 +48,7 @@
  */
 int chroot(const char *path) {
   int rc;
-  if (!path || (IsAsan() && !__asan_is_valid_str(path))) {
+  if (!path) {
     rc = efault();
   } else {
     rc = sys_chroot(path);

libc/calls/clock_getres.c

@@ -16,14 +16,13 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/asan.internal.h"
 #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/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/time/time.h"
+#include "libc/time.h"
 
 static int sys_clock_getres_poly(int clock, struct timespec *ts, int64_t real,
                                  int64_t real_coarse, int64_t boot) {
@@ -63,7 +62,7 @@ static int sys_clock_getres_xnu(int clock, struct timespec *ts) {
  */
 int clock_getres(int clock, struct timespec *ts) {
   int rc;
-  if (!ts || (IsAsan() && !__asan_is_valid_timespec(ts))) {
+  if (!ts) {
     rc = efault();
   } else if (clock == 127) {
     rc = einval();  // 127 is used by consts.sh to mean unsupported

libc/calls/clock_settime.c

@@ -16,7 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/asan.internal.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/calls/struct/timeval.h"
@@ -35,7 +34,7 @@ int clock_settime(int clockid, const struct timespec *ts) {
   struct timeval tv;
   if (clockid == 127) {
     rc = einval();  // 127 is used by consts.sh to mean unsupported
-  } else if (!ts || (IsAsan() && !__asan_is_valid_timespec(ts))) {
+  } else if (!ts) {
     rc = efault();
   } else if (IsXnu()) {
     if (clockid == CLOCK_REALTIME) {

libc/calls/copy_file_range.c

@@ -27,7 +27,6 @@
 #include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/asan.internal.h"
 #include "libc/intrin/describeflags.internal.h"
 #include "libc/intrin/strace.internal.h"
 #include "libc/sysv/consts/sig.h"
@@ -109,11 +108,6 @@ ssize_t copy_file_range(int infd, int64_t *opt_in_out_inoffset, int outfd,
 
   if (!g_copy_file_range.ok) {
     rc = enosys();
-  } else if (IsAsan() && ((opt_in_out_inoffset &&
-                           !__asan_is_valid(opt_in_out_inoffset, 8)) ||
-                          (opt_in_out_outoffset &&
-                           !__asan_is_valid(opt_in_out_outoffset, 8)))) {
-    rc = efault();
   } else if (__isfdkind(outfd, kFdZip)) {
     rc = ebadf();
   } else if (__isfdkind(infd, kFdZip)) {

libc/calls/cp.internal.h

@@ -10,12 +10,12 @@ void end_cancelation_point(int);
 #define END_CANCELATION_POINT   (void)0
 #else
 #define BEGIN_CANCELATION_POINT \
-  do {                           \
-    int _Cp;                     \
+  do {                          \
+    int _Cp;                    \
   _Cp = begin_cancelation_point()
 #define END_CANCELATION_POINT \
   end_cancelation_point(_Cp); \
-  }                            \
+  }                           \
   while (0)
 #endif
 

libc/calls/dup.c

@@ -23,8 +23,8 @@
 #include "libc/dce.h"
 #include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
-#include "libc/sysv/errfuns.h"
 #include "libc/runtime/zipos.internal.h"
+#include "libc/sysv/errfuns.h"
 
 /**
  * Duplicates file descriptor.

libc/calls/dup2.c

@@ -76,7 +76,7 @@ int dup2(int oldfd, int newfd) {
       rc = oldfd;
   } else
 #endif
-  if (!IsWindows()) {
+      if (!IsWindows()) {
     if (__isfdkind(oldfd, kFdZip) || __isfdkind(newfd, kFdZip)) {
       if (__vforked) {
         return enotsup();

libc/calls/faccessat.c

@@ -22,7 +22,6 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/asan.internal.h"
 #include "libc/intrin/describeflags.internal.h"
 #include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
@@ -52,10 +51,8 @@
 int faccessat(int dirfd, const char *path, int amode, int flags) {
   int e, rc;
   struct ZiposUri zipname;
-  if (IsAsan() && !__asan_is_valid_str(path)) {
-    rc = efault();
-  } else if ((flags & ~(AT_SYMLINK_NOFOLLOW | AT_EACCESS)) ||
-             !(amode == F_OK || !(amode & ~(R_OK | W_OK | X_OK)))) {
+  if ((flags & ~(AT_SYMLINK_NOFOLLOW | AT_EACCESS)) ||
+      !(amode == F_OK || !(amode & ~(R_OK | W_OK | X_OK)))) {
     rc = einval();
   } else if (__isfdkind(dirfd, kFdZip)) {
     rc = enotsup();