Fully support old windows 8ib user space virtual memory

Addresses are converted in blocks(asan, automap, stack, ...), with the start and end addresses modified using (address & 0xffffff) | ((address >> 28) << 24).

Following addresses are only specified to frame accuracy with the last 4 hex digits chopped off.
null, loader, image and arena blocks have not been modified.
asan     [0x00007fff, 0x10007fff] ⇒ [0x00007fff, 0x01007fff] Not currently supported.
automap  [0x10008004, 0x1fe7fffb] ⇒ [0x01008004, 0x01e7fffb]
_mmi     [0x1fe7fffc, 0x1ffffffb] ⇒ [0x01e7fffc, 0x01fffffb] Listed as memtrack outside of the memtrack files.
fixedmap [0x30000004, 0x40000003] ⇒ [0x03000004, 0x04000003]
nsync    [0x6fc00004, 0x6fcffffb] ⇒ [0x06c00004, 0x06cffffb]
zipos    [0x6fd00004, 0x6fdffffb] ⇒ [0x06d00004, 0x06dffffb] I don't think this is used currently on the vista branch.
g_fds    [0x6fe00004, 0x6feffffb] ⇒ [0x06e00004, 0x06effffb]
winargs  [0x6ffffffe, 0x6fffffff] ⇒ [0x06fffffe, 0x06ffffff] Not entirely confident on if this is accurate.
stack    [0x70000000, 0x70000003] ⇒ [0x07000000, 0x07000003] Not entirely confident on if this is accurate.

This map is documented in memtrack64-8tib.txt with the original 128tib version renamed to memtrack64-128tib.txt.

Modified windows 8.1 check macro name to match existing windows 10 one.
Modified IsShadowFrame to correctly identify the asan block on old windows. Required as the asan block on 128tib virtual memory systems is larger than 2^43 - 1 and so all blocks were reporting as asan.

.clang-format

@@ -8,7 +8,6 @@ AlwaysBreakBeforeMultilineStrings: false
 AllowShortFunctionsOnASingleLine: false
 KeepEmptyLinesAtTheStartOfBlocks: true
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
-IncludeBlocks: Merge
 ---
 Language: Cpp
 AllowShortFunctionsOnASingleLine: false

.github/workflows/build.yml

@@ -4,10 +4,12 @@ on:
   push:
     branches:
       - "master"
+      - "vista"
       - "flake"
   pull_request:
     branches:
       - "master"
+      - "vista"
 
   # run workflow manually from the Actions tab
   workflow_dispatch:
@@ -21,11 +23,8 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: support ape bins 1
-        run: sudo cp build/bootstrap/ape.elf /usr/bin/ape
-
-      - name: support ape bins 2
-        run: sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
+      - name: support ape bins
+        run: sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
 
       - name: make matrix
         run: V=0 make -j2 MODE=${{ matrix.mode }}

Makefile

@@ -60,7 +60,7 @@
 #   build/config.mk
 
 SHELL      = build/bootstrap/cocmd.com
-HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 xnu win10
+HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 win10 xnu
 MAKEFLAGS += --no-builtin-rules
 
 .SUFFIXES:
@@ -68,12 +68,6 @@ MAKEFLAGS += --no-builtin-rules
 .FEATURES: output-sync
 .PHONY: all o bins check test depend tags
 
-ifneq ($(m),)
-ifeq ($(MODE),)
-MODE := $(m)
-endif
-endif
-
 all:	o
 o:	o/$(MODE)
 
@@ -92,10 +86,9 @@ o/$(MODE):			\
 .UNVEIL =			\
 	libc/integral		\
 	libc/disclaimer.inc	\
-	rwc:/dev/shm		\
 	rx:build/bootstrap	\
 	rx:o/third_party/gcc	\
-	/proc/stat		\
+	/proc/self/status	\
 	rw:/dev/null		\
 	w:o/stack.log		\
 	/etc/hosts		\
@@ -121,25 +114,21 @@ include libc/tinymath/tinymath.mk		# │  You can issue raw system calls
 include third_party/compiler_rt/compiler_rt.mk	# │
 include libc/str/str.mk				# │
 include third_party/xed/xed.mk			# │
-include third_party/puff/puff.mk		# │
 include third_party/zlib/zlib.mk		# │
-include third_party/double-conversion/dc.mk	# │
 include libc/elf/elf.mk				# │
 include ape/ape.mk				# │
 include libc/fmt/fmt.mk				# │
 include libc/vga/vga.mk				#─┘
 include libc/calls/calls.mk			#─┐
-include third_party/getopt/getopt.mk		# │
 include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
 include libc/crt/crt.mk				# │  You can issue system calls
 include third_party/nsync/nsync.mk		# │
 include third_party/dlmalloc/dlmalloc.mk	#─┘
 include libc/mem/mem.mk				#─┐
-include third_party/gdtoa/gdtoa.mk		# ├──DYNAMIC RUNTIME
-include third_party/nsync/mem/mem.mk		# │  You can now use stdio
-include libc/thread/thread.mk			# │  You can finally call malloc()
-include libc/zipos/zipos.mk			# │
-include libc/time/time.mk			# │
+include libc/zipos/zipos.mk			# ├──DYNAMIC RUNTIME
+include third_party/gdtoa/gdtoa.mk		# │  You can now use stdio
+include libc/time/time.mk			# │  You can finally call malloc()
+include libc/thread/thread.mk			# │
 include libc/stdio/stdio.mk			# │
 include third_party/libcxx/libcxx.mk		# │
 include net/net.mk				# │
@@ -153,6 +142,7 @@ include dsp/mpeg/mpeg.mk			# │
 include dsp/dsp.mk				# │
 include third_party/zlib/gz/gz.mk		# │
 include third_party/musl/musl.mk		# │
+include third_party/getopt/getopt.mk		# │
 include libc/libc.mk				#─┘
 include libc/sock/sock.mk			#─┐
 include dsp/tty/tty.mk				# ├──ONLINE RUNTIME
@@ -163,7 +153,6 @@ include net/https/https.mk			# │
 include third_party/regex/regex.mk		#─┘
 include third_party/tidy/tidy.mk
 include third_party/third_party.mk
-include third_party/nsync/testing/testing.mk
 include libc/testlib/testlib.mk
 include tool/viz/lib/vizlib.mk
 include tool/args/args.mk
@@ -171,14 +160,11 @@ include test/tool/args/test.mk
 include third_party/linenoise/linenoise.mk
 include third_party/maxmind/maxmind.mk
 include net/finger/finger.mk
-include third_party/double-conversion/test/test.mk
+include third_party/double-conversion/double-conversion.mk
 include third_party/lua/lua.mk
-include third_party/tr/tr.mk
 include third_party/sed/sed.mk
 include third_party/awk/awk.mk
-include third_party/hiredis/hiredis.mk
 include third_party/make/make.mk
-include third_party/ctags/ctags.mk
 include third_party/finger/finger.mk
 include third_party/argon2/argon2.mk
 include third_party/smallz4/smallz4.mk
@@ -195,7 +181,6 @@ include third_party/python/python.mk
 include tool/build/emucrt/emucrt.mk
 include tool/build/emubin/emubin.mk
 include tool/build/build.mk
-include tool/curl/curl.mk
 include examples/examples.mk
 include examples/pyapp/pyapp.mk
 include examples/pylife/pylife.mk
@@ -210,7 +195,6 @@ include tool/hash/hash.mk
 include tool/net/net.mk
 include tool/viz/viz.mk
 include tool/tool.mk
-include net/turfwar/turfwar.mk
 include test/libc/tinymath/test.mk
 include test/libc/intrin/test.mk
 include test/libc/mem/test.mk
@@ -281,103 +265,101 @@ o/$(MODE)/srcs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS
 o/$(MODE)/hdrs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(HDRS) $(INCS),$(file >>$@,$(x)))
 
-TAGS: private .UNSANDBOXED = 1
-TAGS:	o/$(MODE)/srcs-old.txt $(SRCS) o/$(MODE)/third_party/ctags/ctags.com
+TAGS: .UNSANDBOXED = 1
+TAGS:	o/$(MODE)/srcs-old.txt $(SRCS)
 	@$(RM) $@
-	@o/$(MODE)/third_party/ctags/ctags.com $(TAGSFLAGS) -L $< -o $@
+	@$(TAGS) $(TAGSFLAGS) -L $< -o $@
 
-HTAGS: private .UNSANDBOXED = 1
-HTAGS:	o/$(MODE)/hdrs-old.txt $(HDRS) o/$(MODE)/third_party/ctags/ctags.com
+HTAGS: .UNSANDBOXED = 1
+HTAGS:	o/$(MODE)/hdrs-old.txt $(HDRS)
 	@$(RM) $@
-	@build/htags o/$(MODE)/third_party/ctags/ctags.com -L $< -o $@
+	@build/htags -L $< -o $@
 
-loc: private .UNSANDBOXED = 1
+loc: .UNSANDBOXED = 1
 loc: o/$(MODE)/tool/build/summy.com
 	find -name \*.h -or -name \*.c -or -name \*.S | \
 	$(XARGS) wc -l | grep total | awk '{print $$1}' | $<
 
-# PLEASE: MAINTAIN TOPOLOGICAL ORDER
-# FROM HIGHEST LEVEL TO LOWEST LEVEL
-COSMOPOLITAN_OBJECTS =			\
-	NET_HTTP			\
-	LIBC_DNS			\
-	LIBC_SOCK			\
-	LIBC_NT_WS2_32			\
-	LIBC_NT_IPHLPAPI		\
-	LIBC_NT_MSWSOCK			\
-	LIBC_X				\
-	THIRD_PARTY_GETOPT		\
-	LIBC_LOG			\
-	LIBC_TIME			\
-	LIBC_ZIPOS			\
-	THIRD_PARTY_MUSL		\
-	LIBC_STDIO			\
-	THIRD_PARTY_GDTOA		\
-	THIRD_PARTY_REGEX		\
-	LIBC_THREAD			\
-	THIRD_PARTY_NSYNC_MEM		\
-	LIBC_MEM			\
-	THIRD_PARTY_DLMALLOC		\
-	LIBC_RUNTIME			\
-	THIRD_PARTY_NSYNC		\
-	LIBC_ELF			\
-	LIBC_CALLS			\
-	LIBC_SYSV_CALLS			\
-	LIBC_VGA			\
-	LIBC_NT_PSAPI			\
-	LIBC_NT_POWRPROF		\
-	LIBC_NT_PDH			\
-	LIBC_NT_GDI32			\
-	LIBC_NT_COMDLG32		\
-	LIBC_NT_URL			\
-	LIBC_NT_USER32			\
-	LIBC_NT_NTDLL			\
-	LIBC_NT_ADVAPI32		\
-	LIBC_NT_SYNCHRONIZATION		\
-	LIBC_FMT			\
-	THIRD_PARTY_PUFF		\
-	THIRD_PARTY_COMPILER_RT		\
-	LIBC_TINYMATH			\
-	THIRD_PARTY_XED			\
-	LIBC_STR			\
-	LIBC_SYSV			\
-	LIBC_INTRIN			\
-	LIBC_NT_KERNEL32		\
-	LIBC_NEXGEN32E
+COSMOPOLITAN_OBJECTS =		\
+	NET_HTTP		\
+	LIBC_DNS		\
+	LIBC_SOCK		\
+	LIBC_NT_WS2_32		\
+	LIBC_NT_IPHLPAPI	\
+	LIBC_NT_MSWSOCK		\
+	LIBC_X			\
+	THIRD_PARTY_GETOPT	\
+	LIBC_LOG		\
+	LIBC_TIME		\
+	LIBC_ZIPOS		\
+	THIRD_PARTY_ZLIB	\
+	THIRD_PARTY_MUSL	\
+	LIBC_STDIO		\
+	THIRD_PARTY_GDTOA	\
+	THIRD_PARTY_REGEX	\
+	LIBC_MEM		\
+	THIRD_PARTY_DLMALLOC	\
+	LIBC_RUNTIME		\
+	THIRD_PARTY_NSYNC	\
+	LIBC_ELF		\
+	LIBC_CALLS		\
+	LIBC_SYSV_CALLS		\
+	LIBC_NT_PSAPI		\
+	LIBC_NT_POWRPROF	\
+	LIBC_NT_PDH		\
+	LIBC_NT_GDI32		\
+	LIBC_NT_COMDLG32	\
+	LIBC_NT_URL		\
+	LIBC_NT_USER32		\
+	LIBC_NT_NTDLL		\
+	LIBC_NT_ADVAPI32	\
+	LIBC_FMT		\
+	THIRD_PARTY_COMPILER_RT	\
+	LIBC_THREAD		\
+	LIBC_TINYMATH		\
+	THIRD_PARTY_XED		\
+	LIBC_STR		\
+	LIBC_SYSV		\
+	LIBC_INTRIN		\
+	LIBC_NT_KERNEL32	\
+	LIBC_NEXGEN32E		\
+	LIBC_VGA
 
-COSMOPOLITAN_HEADERS =			\
-	APE				\
-	LIBC				\
-	LIBC_CALLS			\
-	LIBC_DNS			\
-	LIBC_ELF			\
-	LIBC_FMT			\
-	LIBC_INTRIN			\
-	LIBC_LOG			\
-	LIBC_MEM			\
-	LIBC_NEXGEN32E			\
-	LIBC_NT				\
-	LIBC_RUNTIME			\
-	LIBC_SOCK			\
-	LIBC_STDIO			\
-	THIRD_PARTY_NSYNC		\
-	THIRD_PARTY_XED			\
-	LIBC_STR			\
-	LIBC_SYSV			\
-	LIBC_THREAD			\
-	LIBC_TIME			\
-	LIBC_TINYMATH			\
-	LIBC_X				\
-	LIBC_ZIPOS			\
-	LIBC_VGA			\
-	NET_HTTP			\
-	THIRD_PARTY_DLMALLOC		\
-	THIRD_PARTY_GDTOA		\
-	THIRD_PARTY_GETOPT		\
-	THIRD_PARTY_MUSL		\
+COSMOPOLITAN_HEADERS =		\
+	APE			\
+	LIBC			\
+	LIBC_CALLS		\
+	LIBC_DNS		\
+	LIBC_ELF		\
+	LIBC_FMT		\
+	LIBC_INTRIN		\
+	LIBC_LOG		\
+	LIBC_MEM		\
+	LIBC_NEXGEN32E		\
+	LIBC_NT			\
+	LIBC_RUNTIME		\
+	LIBC_SOCK		\
+	LIBC_STDIO		\
+	THIRD_PARTY_NSYNC	\
+	THIRD_PARTY_XED		\
+	LIBC_STR		\
+	LIBC_SYSV		\
+	LIBC_THREAD		\
+	LIBC_TIME		\
+	LIBC_TINYMATH		\
+	LIBC_X			\
+	LIBC_ZIPOS		\
+	LIBC_VGA		\
+	NET_HTTP		\
+	THIRD_PARTY_DLMALLOC	\
+	THIRD_PARTY_GDTOA	\
+	THIRD_PARTY_GETOPT	\
+	THIRD_PARTY_MUSL	\
+	THIRD_PARTY_ZLIB	\
+	THIRD_PARTY_ZLIB_GZ	\
 	THIRD_PARTY_REGEX
 
-o/$(MODE)/cosmopolitan.a:		\
+o/$(MODE)/cosmopolitan.a:	\
 		$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS))
 
 o/cosmopolitan.h:							\
@@ -388,7 +370,7 @@ o/cosmopolitan.h:							\
 	$(file >$(TMPDIR)/$(subst /,_,$@),libc/integral/normalize.inc $(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS)))
 	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >$@
 
-o/cosmopolitan.html: private .UNSANDBOXED = 1
+o/cosmopolitan.html: .UNSANDBOXED = 1
 o/cosmopolitan.html:							\
 		o/$(MODE)/third_party/chibicc/chibicc.com.dbg		\
 		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))	\
@@ -407,15 +389,6 @@ $(SRCS):					\
 	libc/integral/lp64arg.inc		\
 	libc/integral/lp64.inc
 
-.PHONY: toolchain
-toolchain:	o/cosmopolitan.h				\
-		o/$(MODE)/ape/public/ape.lds			\
-		o/$(MODE)/libc/crt/crt.o			\
-		o/$(MODE)/ape/ape.o				\
-		o/$(MODE)/ape/ape-copy-self.o			\
-		o/$(MODE)/ape/ape-no-modify-self.o		\
-		o/$(MODE)/cosmopolitan.a
-
 # UNSPECIFIED PREREQUISITES TUTORIAL
 #
 # A build rule must exist for all files that make needs to consider in
@@ -440,9 +413,9 @@ $(SRCS):
 $(HDRS):
 $(INCS):
 .DEFAULT:
-	@$(ECHO)
-	@$(ECHO) NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@
-	@$(ECHO)
+	@$(ECHO) >&2
+	@$(ECHO) NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@ >&2
+	@$(ECHO) >&2
 	$(RM) o/$(MODE)/depend
 
 -include o/$(MODE)/depend

README.md

@@ -1,7 +1,10 @@
 ![Cosmopolitan Honeybadger](usr/share/img/honeybadger.png)
 
 [![build](https://github.com/jart/cosmopolitan/actions/workflows/build.yml/badge.svg)](https://github.com/jart/cosmopolitan/actions/workflows/build.yml)
-# Cosmopolitan
+# Cosmopolitan (Vista Edition)
+
+**This is a community supported legacy branch of Cosmopolitan 2.0 that's
+intended to preserve compatibility with Windows Vista and Windows 7.**
 
 [Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C
 a build-once run-anywhere language, like Java, except it doesn't need an
@@ -23,11 +26,11 @@ If you're doing your development work on Linux or BSD then you need just
 five files to get started. Here's what you do on Linux:
 
 ```sh
-wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-2.2.zip
-unzip cosmopolitan-amalgamation-2.2.zip
+wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-2.0.1.zip
+unzip cosmopolitan-amalgamation-2.0.1.zip
 printf 'main() { printf("hello world\\n"); }\n' >hello.c
 gcc -g -Os -static -nostdlib -nostdinc -fno-pie -no-pie -mno-red-zone \
-  -fno-omit-frame-pointer -pg -mnop-mcount -mno-tls-direct-seg-refs -gdwarf-4 \
+  -fno-omit-frame-pointer -pg -mnop-mcount -mno-tls-direct-seg-refs \
   -o hello.com.dbg hello.c -fuse-ld=bfd -Wl,-T,ape.lds -Wl,--gc-sections \
   -include cosmopolitan.h crt.o ape-no-modify-self.o cosmopolitan.a
 objcopy -S -O binary hello.com.dbg hello.com
@@ -57,13 +60,9 @@ sudo sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/status'
 
 Since we used the `ape-no-modify-self.o` bootloader (rather than
 `ape.o`) your executable will not modify itself when it's run. What
-it'll instead do, is extract a 4kb program (the [APE loader](https://justine.lol/apeloader/))
-to `${TMPDIR:-${HOME:-.}}` that maps your program into memory without
-needing to copy it. The APE loader must be in an executable location
-(e.g. not stored on a `noexec` mount) for it to run. See below for
-alternatives:
-
-It's possible to install the APE loader systemwide as follows.
+it'll instead do, is extract a 4kb program to `${TMPDIR:-${HOME:-.}}`
+that maps your program into memory without needing to copy it. It's
+possible to install the APE loader systemwide as follows.
 
 ```sh
 # System-Wide APE Install
@@ -104,7 +103,7 @@ heavyweight features like tracing to your binaries by default. In that
 case, you may want to consider using our build system:
 
 ```sh
-make m=tiny
+make -j8 MODE=tiny
 ```
 
 Which will cause programs such as `hello.com` and `life.com` to shrink
@@ -159,7 +158,7 @@ cd cosmopolitan
 This will build the entire repository and run all the tests:
 
 ```sh
-build/bootstrap/make.com
+build/bootstrap/make.com -j16
 o//examples/hello.com
 find o -name \*.com | xargs ls -rShal | less
 ```
@@ -178,7 +177,7 @@ having minimal deterministic builds. For example, if you wanted to build
 only hello.com then you could do that as follows:
 
 ```sh
-build/bootstrap/make.com o//examples/hello.com
+build/bootstrap/make.com -j16 o//examples/hello.com
 ```
 
 Sometimes it's desirable to build a subset of targets, without having to
@@ -187,7 +186,7 @@ directory name. For example, if you wanted to build only the targets and
 subtargets of the chibicc package including its tests, you would say:
 
 ```sh
-build/bootstrap/make.com o//third_party/chibicc
+build/bootstrap/make.com -j16 o//third_party/chibicc
 o//third_party/chibicc/chibicc.com --help
 ```
 
@@ -195,19 +194,18 @@ Cosmopolitan provides a variety of build modes. For example, if you want
 really tiny binaries (as small as 12kb in size) then you'd say:
 
 ```sh
-build/bootstrap/make.com m=tiny
+build/bootstrap/make.com -j16 MODE=tiny
 ```
 
 Here's some other build modes you can try:
 
 ```sh
-build/bootstrap/make.com m=dbg       # asan + ubsan + debug
-build/bootstrap/make.com m=asan      # production memory safety
-build/bootstrap/make.com m=opt       # -march=native optimizations
-build/bootstrap/make.com m=rel       # traditional release binaries
-build/bootstrap/make.com m=optlinux  # optimal linux-only performance
-build/bootstrap/make.com m=fastbuild # build 28% faster w/o debugging
-build/bootstrap/make.com m=tinylinux # tiniest linux-only 4kb binaries
+build/bootstrap/make.com -j16 MODE=dbg       # asan + ubsan + debug
+build/bootstrap/make.com -j16 MODE=asan      # production memory safety
+build/bootstrap/make.com -j16 MODE=opt       # -march=native optimizations
+build/bootstrap/make.com -j16 MODE=rel       # traditional release binaries
+build/bootstrap/make.com -j16 MODE=optlinux  # optimal linux-only performance
+build/bootstrap/make.com -j16 MODE=tinylinux # tiniest linux-only 4kb binaries
 ```
 
 For further details, see [//build/config.mk](build/config.mk).
@@ -243,38 +241,27 @@ You normally run the `.com.dbg` file under gdb. If you need to debug the
 gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
 ```
 
-## Discord Chatroom
-
-The Cosmopolitan development team collaborates on the Redbean Discord
-server. You're welcome to join us! <https://discord.gg/FwAVVu7eJ4>
-
 ## Support Vector
 
 | Platform        | Min Version | Circa |
 | :---            | ---:        | ---:  |
 | AMD             | K8 Venus    | 2005  |
 | Intel           | Core        | 2006  |
+| Windows         | Vista       | 2006  |
 | Linux           | 2.6.18      | 2007  |
-| Windows         | 8 [1]       | 2012  |
 | Mac OS X        | 15.6        | 2018  |
-| OpenBSD         | 6.4         | 2018  |
 | FreeBSD         | 13          | 2020  |
+| OpenBSD         | 6.4         | 2018  |
 | NetBSD          | 9.2         | 2021  |
 
-[1] See our [vista branch](https://github.com/jart/cosmopolitan/tree/vista)
-    for a community supported version of Cosmopolitan that works on Windows
-    Vista and Windows 7.
-
 ## Special Thanks
 
 Funding for this project is crowdsourced using
 [GitHub Sponsors](https://github.com/sponsors/jart) and
 [Patreon](https://www.patreon.com/jart). Your support is what makes this
 project possible. Thank you! We'd also like to give special thanks to
-the following groups and individuals:
+the following individuals:
 
 - [Joe Drumgoole](https://github.com/jdrumgoole)
-- [Rob Figueiredo](https://github.com/robfig)
-- [Wasmer](https://wasmer.io/)
 
 For publicly sponsoring our work at the highest tier.

ape/ape.S

@@ -35,7 +35,6 @@
 #include "ape/macros.internal.h"
 #include "ape/notice.inc"
 #include "ape/relocations.h"
-#include "libc/calls/metalfile.internal.h"
 #include "libc/dce.h"
 #include "libc/elf/def.h"
 #include "libc/macho.internal.h"
@@ -113,33 +112,7 @@ cstr:	.endobj	cstr,globl,hidden		# ←for gdb readability
 //
 //	@param	dl is drive number
 //	@noreturn
-ape_mz:
-#if SupportsWindows() || SupportsMetal()
-	.asciz	"MZqFpD='\n"		# Mark 'Zibo' Joseph Zbikowski
-//	# in real mode
-//	dec	%bp
-//	pop	%dx
-//	jno	0x4a
-//	jo	0x4a
-//
-//	# in legacy mode
-//	push	%ebp
-//	pop	%edx
-//	jno	0x4a
-//	jo	0x4a
-//
-//	# 64-bit mode
-//	rex.WRB
-//	pop	%r10
-//	jno	0x4a
-//	jo	0x4a
-#else
-//	Avoid virus scanner reputation damage when targeting System Five.
-	.asciz	"jartsr='\n"		# Justine Alexandra Roberts Tunney
-//	push	$0x61
-//	jb	0x78
-//	jae	0x78
-#endif
+ape_mz:	.asciz	"MZqFpD='\n"		# Mark 'Zibo' Joseph Zbikowski
 	.short	0x1000			# MZ: lowers upper bound load / 16
 	.short	0xf800			# MZ: roll greed on bss
 	.short	0			# MZ: lower bound on stack segment
@@ -152,15 +125,11 @@ ape_mz:
 	.org	0x24			# MZ: bytes reserved for you
 	.ascii	"JT"			# MZ: OEM identifier
 	.short	0			# MZ: OEM information
-	.ascii	"' <<'@'\n"
 	.org	0x40-4			# MZ: bytes reserved for you
 #if SupportsWindows() || SupportsMetal()
 	.long	RVA(ape_pe)		# PE: the new technology
 #else
 	.long	0
-	.org	0x78
-	pop	%rax
-	jmp	_start
 #endif
 	.endfn	ape_mz,globl,hidden
 
@@ -266,9 +235,8 @@ pc:	cld
 #endif
 	ljmp	$0,$REAL(1f)
 1:	mov	%cx,%ds
-	.set	mm,0x0500			# struct mman
-	mov	$IMAGE_BASE_REAL-mm,%cx		# clears bss
-	mov	$mm>>4,%ax
+	mov	$IMAGE_BASE_REAL-0x0500,%cx	# clears bss
+	mov	$0x0500>>4,%ax			# struct mman
 	mov	%ax,%es
 	xor	%ax,%ax
 	xor	%di,%di
@@ -281,10 +249,8 @@ pc:	cld
 	xor	%cx,%cx				# current cylinder
 	xor	%dh,%dh				# current head
 	mov	$v_ape_realsectors,%di		# total sectors
+	sub	$v_ape_realslacksectors,%di
 3:	call	pcread
-	mov	%es,%si				# addr += 512
-	add	$512>>4,%si
-	mov	%si,%es
 	dec	%di
 	jnz	3b
 6:	ljmp	$0,$REAL(realmodeloader)
@@ -362,7 +328,7 @@ dsknfo:	push	%bx
 	movpp	%es,%ds
 	xor	%si,%si
 	mov	%si,%es
-	mov	$mm+"struct mman::pc_drive_base_table",%si
+	mov	$0x1d10,%si		# mman::pc_drive_base_table
 	xchg	%si,%di
 	movsw	#→ headunloadtime, headloadtime
 	movsw	#→ shutofftime, bytespersector
@@ -373,7 +339,6 @@ dsknfo:	push	%bx
 	pop	%ds
 	xchg	%bx,%ax
 	stosw	#→ pc_drive_type, pc_drive_last_sector
-	scasb
 	xchg	%cx,%ax
 	stosw	#→ pc_drive_last_cylinder
 	xchg	%dx,%ax
@@ -412,12 +377,15 @@ pcread:	push	%ax
 	pop	%cx
 	pop	%ax
 	jc	9f
+	mov	%es,%si			# addr += 512
+	add	$512>>4,%si
+	mov	%si,%es
 	inc	%al			# ++sector
-	cmp	mm+"struct mman::pc_drive_last_sector",%al
+	cmp	0x1d1c,%al		# mman::pc_drive_last_sector
 	jbe	2f
 	mov	$1,%al
 	inc	%dh			# ++head
-	cmp	mm+"struct mman::pc_drive_last_head",%dh
+	cmp	0x1d20,%dh		# mman::pc_drive_last_head
 	jbe	2f
 	xor	%dh,%dh
 	inc	%cx			# ++cylinder
@@ -580,10 +548,7 @@ ape_disk:
 	the bourne executable & linkable format */
 
 #if SupportsWindows() || SupportsMetal() || SupportsXnu()
-apesh:	.ascii	"\n@\n#'\"\n"			# sixth edition shebang
-	.ascii	"m=\"$(uname -m)\"\n"
-
-	.ascii	"if [ \"$m\" = x86_64 ] || [ \"$m\" = amd64 ]; then\n"
+apesh:	.ascii	"'\n#'\"\n"			# sixth edition shebang
 //	Until all operating systems can be updated to support APE,
 //	we have a beautiful, yet imperfect workaround, which is to
 //	modify the binary to follow the local system's convention.
@@ -685,99 +650,17 @@ apesh:	.ascii	"\n@\n#'\"\n"			# sixth edition shebang
 	.ascii	"o=\"$t\"\n"
 	.ascii	"exec \"$o\" \"$@\"\n"
 #endif /* APE_NO_MODIFY_SELF */
-	.ascii	"exit $?\n"
+	.ascii	"R=$?\n"
+	.ascii	"if [ \"$(uname -m)\" != x86_64 ]; then\n"
+	.ascii	  "Q=\"$(command -v qemu-x86_64)\" &&\n"
+	.ascii	    "exec \"$Q\" \"$o\" \"$@\"\n"
+#ifndef APE_NO_MODIFY_SELF
+	.ascii	"else\n"			# means argv[0] was wrong
+	.ascii	"  exec \"$o\" \"$@\"\n"	# so do a path resolution
+#endif /* APE_NO_MODIFY_SELF */
 	.ascii	"fi\n"
-
-	.ascii	"PHDRS='' <<'@'\n"
+	.ascii	"exit $R\n"
 	.endobj	apesh
-//	elf program headers get inserted here
-//	because they need to be in the first 4096 bytes
-        .section .emush,"a",@progbits
-emush:	.ascii	"\n@\n#'\"\n"
-	.ascii	"s=\"$(uname -s)\"\n"
-
-//	our script is running on a non-x86_64 architecture
-//	1. `dd` out the appropriate blink vm blob
-//	2. gunzip the blink virtual machine executable
-//	3. relaunch this program inside the blink vm
-	.ascii	"o=\"$(command -v \"$0\")\"\n"
-	.ascii	"e=\"${TMPDIR:-${HOME:-.}}/.ape-blink-0.9.2\"\n"
-
-//	Blink for Apple Silicon, e.g. M1 Macbook
-	.ascii	"if [ \"$s\" = Darwin ] && [ \"$m\" = arm64 ]; then\n"
-	.ascii	"if ! [ -x \"$e\" ]; then\n"
-	.ascii	"echo \"extracting blink-darwin-arm64 to ${e}\" >&2\n"
-	.ascii	"dd if=\"$o\" bs=1 skip=$(("
-	.byte	blink_darwin_arm64_b9
-	.byte	blink_darwin_arm64_b8
-	.byte	blink_darwin_arm64_b7
-	.byte	blink_darwin_arm64_b6
-	.byte	blink_darwin_arm64_b5
-	.byte	blink_darwin_arm64_b4
-	.byte	blink_darwin_arm64_b3
-	.byte	blink_darwin_arm64_b2
-	.byte	blink_darwin_arm64_b1
-	.byte	blink_darwin_arm64_b0
-	.ascii	")) count=$(("
-	.byte	blink_darwin_arm64_size_b9
-	.byte	blink_darwin_arm64_size_b8
-	.byte	blink_darwin_arm64_size_b7
-	.byte	blink_darwin_arm64_size_b6
-	.byte	blink_darwin_arm64_size_b5
-	.byte	blink_darwin_arm64_size_b4
-	.byte	blink_darwin_arm64_size_b3
-	.byte	blink_darwin_arm64_size_b2
-	.byte	blink_darwin_arm64_size_b1
-	.byte	blink_darwin_arm64_size_b0
-	.ascii	")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n"
-	.ascii	"mv -f \"$e.$$\" \"$e\"\n"
-	.ascii	"chmod +x \"$e\"\n"
-	.ascii	"fi\n"
-	.ascii	"exec \"$e\" \"$o\" \"$@\"\n"
-	.ascii	"fi\n"
-
-//	Blink for Aarch64 Linux, e.g. Raspberry Pi
-	.ascii	"if [ \"$s\" = Linux ]; then\n"
-	.ascii	"if [ \"$m\" = aarch64 ] || [ \"$m\" = arm64 ]; then\n"
-	.ascii	"if ! [ -x \"$e\" ]; then\n"
-	.ascii	"echo \"extracting blink-aarch64 to ${e}\" >&2\n"
-	.ascii	"dd if=\"$o\" bs=1 skip=$(("
-	.byte	blink_aarch64_b9
-	.byte	blink_aarch64_b8
-	.byte	blink_aarch64_b7
-	.byte	blink_aarch64_b6
-	.byte	blink_aarch64_b5
-	.byte	blink_aarch64_b4
-	.byte	blink_aarch64_b3
-	.byte	blink_aarch64_b2
-	.byte	blink_aarch64_b1
-	.byte	blink_aarch64_b0
-	.ascii	")) count=$(("
-	.byte	blink_aarch64_size_b9
-	.byte	blink_aarch64_size_b8
-	.byte	blink_aarch64_size_b7
-	.byte	blink_aarch64_size_b6
-	.byte	blink_aarch64_size_b5
-	.byte	blink_aarch64_size_b4
-	.byte	blink_aarch64_size_b3
-	.byte	blink_aarch64_size_b2
-	.byte	blink_aarch64_size_b1
-	.byte	blink_aarch64_size_b0
-	.ascii	")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n"
-	.ascii	"mv -f \"$e.$$\" \"$e\"\n"
-	.ascii	"chmod +x \"$e\"\n"
-	.ascii	"fi\n"
-	.ascii	"exec \"$e\" \"$o\" \"$@\"\n"
-	.ascii	"fi\n"
-	.ascii	"fi\n"
-
-	.ascii	"echo unsupported architecture >&2\n"
-	.rept	16
-	.ascii	"exit 127\n"
-	.endr
-
-	.ascii	"exit 1\n"
-	.endobj	emush
 #ifdef APE_LOADER
         .section .ape.loader,"a",@progbits
 	.align	64
@@ -990,7 +873,7 @@ ape_macho:
 	.long	(520f-510f)/4			# count
 510:	.quad	0				# rax
 	.quad	IMAGE_BASE_VIRTUAL		# rbx
-	.quad	_HOSTXNU			# rcx
+	.quad	XNU				# rcx
 	.quad	0				# rdx
 	.quad	0				# rdi
 	.quad	0				# rsi
@@ -1197,42 +1080,6 @@ ape_idata_idt:
 ape_idata_idtend:
 	.previous
 
-	.section .piro.data.sort.metal_gdt,"aw",@progbits
-	.align	8
-_gdt:
-//	          ┌G:granularity (1 → limit *= 0x1000)
-//	          │┌D/B:default operation size (0 = 16|64bit, 1 = 32-bit)
-//	          ││┌L:long mode
-//	          │││┌AVL:this bit is thine (1<<52)
-//	          ││││    ┌P:present
-//	          ││││    │┌DPL:privilege
-//	          ││││    ││ ┌─────────data/code(1)
-//	          ││││    ││ │┌────data(0)──────code(1)
-//	          ││││    ││ ││┌───conforming───expand-down
-//	          ││││    ││ │││┌──writeable────readable
-//	          ││││    ││ ││││┌─accessed─────accessed
-//	          ││││    ││ │││││
-//	          ││││ ┌──││─│││││───────────────────────────────┐
-//	      ┌───││││─│──││─│││││───────────┐                   │
-//	  ┌───┴──┐││││┌┴─┐│├┐│││││┌──────────┴───────────┐┌──────┴───────┐
-//	  │      ││││││  ││││││││││          base address││ segment limit│
-//	  │      ││││││  ││││││││││               32 bits││       20 bits│
-//	  │      ││││││  ││││││││││                      ││              │
-//	  6666555555555544444444443333333333222222222211111111110000000000
-//	  3210987654321098765432109876543210987654321098765432109876543210
-//	  │      ││││││  ││││││││││                      ││              │
-.quad	0b0000000000000000000000000000000000000000000000000000000000000000 # 0
-.quad	0b0000000000001111100110100000000000000000000000001111111111111111 # 8
-.quad	0b0000000000001111100100100000000000000000000000001111111111111111 #16
-.quad	0b0000000011001111100110100000000000000000000000001111111111111111 #24
-.quad	0b0000000011001111100100100000000000000000000000001111111111111111 #32
-.quad	0b0000000010101111100110110000000000000000000000001111111111111111 #40
-.quad	0b0000000010101111100100110000000000000000000000001111111111111111 #48
-.tssdescstub _tss							#56,64
-_gdt_end:
-	.endobj	_gdt,global,hidden
-	.previous
-
 	.section .piro.data.sort.iat.1,"aw",@progbits
 	.type	ape_idata_iatend,@object
 	.type	ape_idata_iat,@object
@@ -1289,22 +1136,42 @@ sconf:	.short	1843200/*hz*/ / 16/*wut*/ / 9600/*baud*/
 	.endobj	sconf,global,hidden
 
 //	Global Descriptor Table
+//
+//	@note address portion only concern legacy modes
 	.align	8
-_gdtrlo:
-	.short	2f-_gdtlo-1	# table byte length
-	.long	REAL(_gdtlo)	# table address (base memory space)
-	.endobj	_gdtrlo,global,hidden
-_gdtr:
-	.short	_gdt_end-_gdt-1	# table byte length
-	.quad	_gdt		# table address (final virtual space)
-	.endobj	_gdtr,global,hidden
-	.align	8
-//	Partial GDT with descriptors for switching to unreal mode or long mode.
-_gdtlo	= .-GDT_LEGACY_DATA
+gdt:	.short	2f-1f		# table byte length
+	.long	REAL(1f),0	# table address
+	.zero	2
+1:
+//	          ┌G:granularity (1 → limit *= 0x1000)
+//	          │┌D/B:default operation size (0 = 16|64bit, 1 = 32-bit)
+//	          ││┌L:long mode
+//	          │││┌AVL:this bit is thine (1<<52)
+//	          ││││    ┌P:present
+//	          ││││    │┌DPL:privilege
+//	          ││││    ││ ┌─────────data/code(1)
+//	          ││││    ││ │┌────data(0)──────code(1)
+//	          ││││    ││ ││┌───conforming───expand-down
+//	          ││││    ││ │││┌──writeable────readable
+//	          ││││    ││ ││││┌─accessed─────accessed
+//	          ││││    ││ │││││
+//	          ││││ ┌──││─│││││───────────────────────────────┐
+//	      ┌───││││─│──││─│││││───────────┐                   │
+//	  ┌───┴──┐││││┌┴─┐│├┐│││││┌──────────┴───────────┐┌──────┴───────┐
+//	  │      ││││││  ││││││││││          base address││ segment limit│
+//	  │      ││││││  ││││││││││               32 bits││       20 bits│
+//	  │      ││││││  ││││││││││                      ││              │
+//	  6666555555555544444444443333333333222222222211111111110000000000
+//	  3210987654321098765432109876543210987654321098765432109876543210
+//	  │      ││││││  ││││││││││                      ││              │
+.quad	0b0000000000000000000000000000000000000000000000000000000000000000 # 0
+.quad	0b0000000000001111100110100000000000000000000000001111111111111111 # 8
+.quad	0b0000000000001111100100100000000000000000000000001111111111111111 #16
+.quad	0b0000000011001111100110100000000000000000000000001111111111111111 #24
 .quad	0b0000000011001111100100100000000000000000000000001111111111111111 #32
 .quad	0b0000000010101111100110110000000000000000000000001111111111111111 #40
 .quad	0b0000000010101111100100110000000000000000000000001111111111111111 #48
-2:
+2:	.endobj	gdt,global,hidden
 
 /*─────────────────────────────────────────────────────────────────────────────╗
 │ αcτµαlly pδrταblε εxεcµταblε § real mode                                     │
@@ -1312,7 +1179,6 @@ _gdtlo	= .-GDT_LEGACY_DATA
 	the default mode of operation on modern cpus */
 
 realmodeloader:
-	call	lhinit
 	call	rlinit
 	call	sinit4
 	.optfn	_start16
@@ -1320,25 +1186,6 @@ realmodeloader:
 	call	longmodeloader
 	.endfn	realmodeloader
 
-//	Prepares to later load parts of the program that are not loaded yet.
-//
-//	@param	al next sector number
-//	@param	cx next cylinder number
-//	@param	dh next head number
-//	@param	dl drive number
-//	@clob	ax, cx, es, di
-lhinit:	cmp	$0x40,%dl
-	je	9f
-	pushpop	0,%es
-	mov	$mm+"struct mman::pc_drive_next_sector",%di
-	cld
-	stosb	#→ pc_drive_next_sector
-	xchg	%ax,%cx
-	stosw	#→ pc_drive_next_cylinder
-	mov	%dh,%al
-	stosb	#→ pc_drive_next_head
-9:	ret
-
 	.section .sort.text.real.init.1,"ax",@progbits
 	.type	rlinit,@function
 rlinit:	.previous/*
@@ -1399,19 +1246,17 @@ longmodeloader:
 	call	lcheck
 	call	a20
 	call	e820
-	call	cpyhi
-	call	loadhi
 	call	pinit
 	call	golong
 	.endfn	longmodeloader
 
 //	Long Mode Hardware Check
-lcheck:	pushf				# checks for i8086 / i8088 / i80186
-	pop	%ax			# see intel manual volume 1 §20.1.2
-	test	$0x80,%ah
-	jnz	10f			# we now assume 32 bit is supported
-	pushfl				# now check for i386, or early i486
-	pop	%eax			# tests ability to change cpuid bit
+lcheck:	pushf				# check for i8086 / i8088 / i80186
+	pop	%ax
+	test	$0x80,%ah		# see intel manual volume 1 20.1.2
+	jnz	10f			# we now assume 32bit is supported
+	pushfl				# now check for i386 or early i486
+	pop	%eax			# test ability to change cpuid bit
 	mov	%eax,%ecx
 	mov	$1<<21,%ebx
 	xor	%ebx,%eax
@@ -1424,16 +1269,16 @@ lcheck:	pushf				# checks for i8086 / i8088 / i80186
 	or	%ebx,%eax		# puts cpuid bit in the on position
 	push	%eax
 	popfl
-	mov	$0x80000000,%edi	# get amd64 ext cpuid thingy length
+	mov	$0x80000000,%edi	# get amd ext cpuid thingy length
 	mov	%edi,%eax
 	inc	%edi
-	cpuid				# leaf 0x80000000, clob ax/bx/cx/dx
+	cpuid				# clobbers eax, ebx, ecx, and edx
 	cmp	%edi,%eax
 	jl	10f
 	mov	%edi,%eax
-	cpuid				# leaf 0x80000001, clob ax/bx/cx/dx
-	mov	$1<<29|1<<20,%edi	# 29 = LM (long), 20 = NX (no exec)
-	and	%edi,%edx		# we need to both, or we won't work
+	cpuid
+	mov	$1<<29,%edi		# need nexgen32e long mode support
+	and	%edi,%edx
 	cmp	%edi,%edx
 	jne	10f
 	xor	%ax,%ax
@@ -1443,9 +1288,10 @@ lcheck:	pushf				# checks for i8086 / i8088 / i80186
 	.endfn	lcheck
 
 //	Gets memory map from BIOS.
-e820:	xor	%ebx,%ebx		# %ebx is an api state tracker
-	mov	%bx,%es
-	mov	$mm+"struct mman::e820",%di # es:di is destination buffer
+e820:	mov	$0x0510>>4,%di		# mman::e820
+	mov	%di,%es
+	xor	%di,%di			# es:di is destination buffer
+	xor	%ebx,%ebx		# ebx is an api state tracker
 1:	mov	$0xE820,%eax		# magic
 	mov	$8+8+4+4,%ecx		# sizeof(struct SmapEntry)
 	mov	$0x534d4150,%edx	# magic number
@@ -1469,7 +1315,7 @@ e820:	xor	%ebx,%ebx		# %ebx is an api state tracker
 4:	add	$8+8+4+4,%di		# keep entry
 5:	test	%ebx,%ebx		# last entry?
 	jz	8f
-	cmp	$mm+"struct mman::e820_end"-(8+8+4+4),%di
+	cmp	$(256-1)*(8+8+4+4),%di
 	jb	1b
 8:	xor	%ax,%ax			# add a blank sentinel entry
 	mov	$(8+8)/2,%cx
@@ -1543,88 +1389,10 @@ a20:	cli
 5:	ret
 	.endfn	a20
 
-//	Copies program pages loaded into base memory, to extended memory.
-//
-//	@clob	esi, edi
-cpyhi:	push	%es
-	movpp	%ds,%es
-	call	unreal
-	mov	$IMAGE_BASE_REAL,%esi
-	mov	$IMAGE_BASE_PHYSICAL,%edi
-	mov	$v_ape_realdwords,%ecx
-	cld
-	rep movsl %ds:(%esi),%es:(%edi)
-	sti
-	pop	%es
-	ret
-	.endfn	cpyhi
-
-//	Disables interrupts and switches to "unreal mode".
-//
-//	@return	ds, es have same base addresses as before but can access
-//		4 GiB of memory
-//	@clob	eax
-unreal:	push	%ds
-	push	%es
-	cli
-	lgdt	REAL(_gdtrlo)
-	mov	%cr0,%eax
-	or	$CR0_PE,%al
-	mov	%eax,%cr0
-	jmp	0f
-0:	pushpop	GDT_LEGACY_DATA,%ds
-	movpp	%ds,%es
-	and	$~CR0_PE,%al
-	mov	%eax,%cr0
-	jmp	1f
-1:	pop	%es
-	pop	%ds
-	ret
-
-//	Reads any remaining program pages into memory which have not yet
-//	been read by the boot sector.
-//
-//	@clob	eax, ecx, dx, esi, edi, bp
-loadhi:	mov	$v_ape_highsectors,%bp
-	test	%bp,%bp
-	jz	9f
-	mov	$mm+"struct mman::pc_drive",%si
-	cld
-	lodsb	#← pc_drive
-	xchg	%ax,%dx
-	lodsw
-	lodsb	#← pc_drive_next_sector
-	test	%al,%al
-	jz	9f
-	xchg	%ax,%cx
-	lodsw	#← pc_drive_next_cylinder
-	xchg	%ax,%cx
-	mov	(%si),%dh #← pc_drive_next_head
-	push	%es
-#define	SEG 0x79000
-	mov	$IMAGE_BASE_PHYSICAL+v_ape_realbytes-SEG,%edi
-	push	$SEG>>4
-	pop	%es
-0:	call	pcread
-	push	%ax
-	call	unreal
-	pop	%ax
-	push	%cx
-	xor	%esi,%esi
-	xor	%ecx,%ecx
-	mov	$512/4,%cl
-	cld
-	rep movsl %es:(%esi),%es:(%edi)
-	sti
-	pop	%cx
-	dec	%bp
-	jnz	0b
-	pop	%es
-9:	ret
-
 //	Initializes long mode paging.
 pinit:	push	%ds
 	push	%es
+#define	SEG 0x79000
 	mov	$SEG>>4,%ax
 	mov	%ax,%ds
 	mov	%ax,%es
@@ -1640,7 +1408,7 @@ pinit:	push	%ds
 	movl	$0x79000+PAGE_V+PAGE_RW,0x7b000-SEG	# PD←PDT     (+)
 	movl	$0x79000+PAGE_V+PAGE_RW,0x7a000-SEG	# PD←PDT     (-)
 	mov	$512,%cx				# PD±2MB
-	mov	$PAGE_V+PAGE_RSRV+PAGE_RW,%eax
+	mov	$PAGE_V+PAGE_RW,%eax
 	xor	%di,%di
 0:	stosl
 	add	$0x1000,%eax
@@ -1657,15 +1425,15 @@ pinit:	push	%ds
 //
 //	@see	Intel Manual V3A §4.1.2
 golong:	cli
-	lidt	mm+"struct mman::bad_idt"
+	lidt	0x1d22					# mman::bad_idt
 	mov	%cr4,%eax
 	or	$CR4_PAE|CR4_PGE|CR4_OSFXSR,%eax
 	mov	%eax,%cr4
 	movl	$EFER,%ecx
 	rdmsr
-	or	$EFER_LME|EFER_SCE|EFER_NXE,%eax
+	or	$EFER_LME|EFER_SCE,%eax
 	wrmsr
-	lgdt	REAL(_gdtrlo)
+	lgdt	REAL(gdt)
 	mov	%cr0,%eax
 	or	$CR0_PE|CR0_PG|CR0_MP,%eax
 	and	$~CR0_EM,%eax
@@ -1675,9 +1443,7 @@ golong:	cli
 
 //	Long mode is long.
 	.code64
-long:	movabs	$BANE+PHYSICAL(0f),%rax
-	jmp	*%rax
-0:	xor	%eax,%eax
+long:	xor	%eax,%eax
 	mov	$GDT_LONG_DATA,%al
 	mov	%eax,%ds
 	mov	%eax,%ss
@@ -1691,15 +1457,13 @@ long:	movabs	$BANE+PHYSICAL(0f),%rax
 	xor	%r15d,%r15d
 	xor	%ebx,%ebx
 	xor	%ebp,%ebp
-	mov	$mm,%rdi
+	push	%rbp
+	mov	$0x0500,%rdi			# mman
 	mov	%cr3,%rsi
-	mov	$IMAGE_BASE_PHYSICAL,%edx
-	lea	v_ape_allbytes(%rdx),%ecx
+	mov	$IMAGE_BASE_REAL,%edx
 	call	__map_phdrs
 	push	$0x037f
 	fldcw	(%rsp)
-	lgdt	_gdtr					# reload GDTR for
-							# virtual memory space
 	movabs	$kernel,%rax
 	jmp	*%rax
 	.endfn	long
@@ -1780,25 +1544,21 @@ kernel:	movabs	$ape_stack_vaddr,%rsp
 	.byte	0x0f,0x1f,0207			# nop rdi binbase
 	.long	(IMAGE_BASE_VIRTUAL-IMAGE_BASE_REAL)/512
 #endif
-	movabs	$BANE+mm,%rdi
-	mov	$0x79000,%esi
-	mov	$0x7f000,%edx
-	call	__reclaim_boot_pages
-	push	$_HOSTMETAL			# sets __hostos in crt.S
+	push	$METAL				# sets __hostos in crt.S
 	pop	%rcx
-	pushq	.Lenv0(%rip)			# envp[0][0]
+	push	$0
 	mov	%rsp,%rbp
-	pushq	.Largv0+8(%rip)			# argv[0][8]
-	pushq	.Largv0(%rip)			# argv[0][0]
-	mov	%rsp,%rax
+	mov	.Lenv0(%rip),%rax
+	mov	%rax,(%rbp)			# envp[0][0]
+	push	$0				# argv[0][0]
 	push	$0				# auxv[1][1]
 	push	$0				# auxv[1][0]
-	push	%rax				# auxv[0][1]
+	push	%rbp				# auxv[0][1]
 	push	$31				# auxv[0][0] AT_EXECFN
 	push	$0				# envp[1]
-	push	%rbp				# envp[0]
+	push	$.Lenv0				# envp[0]
 	push	$0				# argv[1]
-	push	%rax				# argv[0]
+	push	%rbp				# argv[0]
 	push	$1				# argc
 	xor	%ebp,%ebp
 	xor	%eax,%eax
@@ -1814,9 +1574,6 @@ kernel:	movabs	$ape_stack_vaddr,%rsp
 
 	.rodata
 .Lenv0:	.asciz	"METAL=1"
-.Largv0:
-	.asciz	APE_COM_NAME
-	.org	.Largv0+16
 	.previous
 
 #endif /* SupportsMetal() */
@@ -1829,7 +1586,7 @@ kernel:	movabs	$ape_stack_vaddr,%rsp
 	.ldsvar	_end
 	.ldsvar	_etext
 	.ldsvar	v_ape_realsectors
-	.ldsvar	v_ape_realbytes
+	.ldsvar	v_ape_realslacksectors
 	.ldsvar	v_ape_highsectors
 	.ldsvar	ape_idata_ro
 	.ldsvar	ape_pad_rodata
@@ -1923,21 +1680,5 @@ __bss_start:
 __bss_end:
 	.previous
 
-	.section .blink,"a",@progbits
-	.globl	blink_aarch64_size
-blink_aarch64:
-	.incbin	"ape/blink-aarch64.gz"
-	.endobj	blink_aarch64,globl
-blink_aarch64_size = . - blink_aarch64
-	.previous
-
-	.section .blink,"a",@progbits
-	.globl	blink_darwin_arm64_size
-blink_darwin_arm64:
-	.incbin	"ape/blink-darwin-arm64.gz"
-	.endobj	blink_darwin_arm64,globl
-blink_darwin_arm64_size = . - blink_darwin_arm64
-	.previous
-
 .end
 

ape/ape.lds

@@ -216,8 +216,6 @@ SECTIONS {
     KEEP(*(.elf.phdrs))
     HIDDEN(ape_phdrs_end = .);
 
-    KEEP(*(.emush))
-
     /* OpenBSD */
     . = ALIGN(__SIZEOF_POINTER__);
     HIDDEN(ape_note = .);
@@ -275,7 +273,6 @@ SECTIONS {
     KEEP(*(.textwindowsprologue))
     *(.text.windows)
     KEEP(*(.textwindowsepilogue))
-    KEEP(*(.blink))
     *(SORT_BY_ALIGNMENT(.text.modernity))
     *(SORT_BY_ALIGNMENT(.text.modernity.*))
     *(SORT_BY_ALIGNMENT(.text.hot))
@@ -352,29 +349,8 @@ SECTIONS {
     HIDDEN(_etext = .);
     PROVIDE_HIDDEN(etext = .);
 /*END: Read Only Data (only needed for initialization) */
-  } :Rom
-
-/* initialization image for thread-local storage, this is copied */
-/* out to actual TLS areas at runtime, so just make it read-only */
-  .tdata . : {
-    _tdata_start = .;
-    *(SORT_BY_ALIGNMENT(.tdata))
-    *(SORT_BY_ALIGNMENT(.tdata.*))
-    _tdata_end = .;
-    . = ALIGN(PAGESIZE);
-  } :Tls :Rom
 /*END: Read Only Data */
-
-/* this only tells the linker about the layout of uninitialized */
-/* TLS data, and does not advance the linker's location counter */
-  .tbss . : {
-    _tbss_start = .;
-    *(SORT_BY_ALIGNMENT(.tbss))
-    *(SORT_BY_ALIGNMENT(.tbss.*))
-    . = ALIGN(TLS_ALIGNMENT);
-    /* the %fs register is based on this location */
-    _tbss_end = .;
-  } :Tls
+  } :Rom
 
   .data ALIGN(PAGESIZE) : {
 /*BEGIN: Read/Write Data */
@@ -409,7 +385,26 @@ SECTIONS {
     . = ALIGN(PAGESIZE);
   } :Ram
 
+  .tdata . : {
+    _tdata_start = .;
+    *(SORT_BY_ALIGNMENT(.tdata))
+    *(SORT_BY_ALIGNMENT(.tdata.*))
+    _tdata_end = .;
+    . = ALIGN(PAGESIZE);
+  } :Tls :Ram
+
 /*END:   file content that's loaded by o/s */
+/*BEGIN: bss memory void */
+
+  .tbss . : {
+    _tbss_start = .;
+    *(SORT_BY_ALIGNMENT(.tbss))
+    *(SORT_BY_ALIGNMENT(.tbss.*))
+    . = ALIGN(TLS_ALIGNMENT);
+    /* the %fs register is based on this location */
+    _tbss_end = .;
+  } :Tls
+
 /*END:   file content */
 /*BEGIN: bss memory that's addressable */
 
@@ -432,7 +427,7 @@ SECTIONS {
 
     KEEP(*(.bssepilogue))
 /*END: NT FORK COPYING */
-    . = ALIGN(PAGESIZE);
+    . = ALIGN(FRAMESIZE); /* for brk()/sbrk() allocation */
     HIDDEN(_end = .);
     PROVIDE_HIDDEN(end = .);
   } :Bss
@@ -463,7 +458,6 @@ SECTIONS {
   .debug_line        0 : { *(.debug_line .debug_line.* .debug_line_end ) }
   .debug_frame       0 : { *(.debug_frame) }
   .debug_str         0 : { *(.debug_str) }
-  .debug_line_str    0 : { *(.debug_line_str) }
   .debug_loc         0 : { *(.debug_loc) }
   .debug_macinfo     0 : { *(.debug_macinfo) }
   .debug_weaknames   0 : { *(.debug_weaknames) }
@@ -472,7 +466,6 @@ SECTIONS {
   .debug_varnames    0 : { *(.debug_varnames) }
   .debug_pubtypes    0 : { *(.debug_pubtypes) }
   .debug_ranges      0 : { *(.debug_ranges) }
-  .debug_rnglists    0 : { *(.debug_rnglists) }
   .debug_macro       0 : { *(.debug_macro) }
   .debug_addr        0 : { *(.debug_addr) }
   .gnu.attributes    0 : { KEEP(*(.gnu.attributes)) }
@@ -514,7 +507,7 @@ HIDDEN(ape_rom_rva = RVA(ape_rom_vaddr));
 HIDDEN(ape_ram_offset = ape_rom_offset + ape_rom_filesz);
 HIDDEN(ape_ram_vaddr = ADDR(.data));
 HIDDEN(ape_ram_paddr = LOADADDR(.data));
-HIDDEN(ape_ram_filesz = SIZEOF(.data));
+HIDDEN(ape_ram_filesz = SIZEOF(.data) + SIZEOF(.tdata));
 HIDDEN(ape_ram_memsz = ADDR(.bss) + SIZEOF(.bss) - ape_ram_vaddr);
 HIDDEN(ape_ram_align = PAGESIZE);
 HIDDEN(ape_ram_rva = RVA(ape_ram_vaddr));
@@ -538,16 +531,16 @@ HIDDEN(ape_note_align = __SIZEOF_POINTER__);
 HIDDEN(ape_text_offset = ape_rom_offset + LOADADDR(.text) - ape_rom_paddr);
 HIDDEN(ape_text_paddr = LOADADDR(.text));
 HIDDEN(ape_text_vaddr = ADDR(.text));
-HIDDEN(ape_text_filesz = SIZEOF(.text) + SIZEOF(.tdata));
-HIDDEN(ape_text_memsz = SIZEOF(.text) + SIZEOF(.tdata));
+HIDDEN(ape_text_filesz = SIZEOF(.text));
+HIDDEN(ape_text_memsz = SIZEOF(.text));
 HIDDEN(ape_text_align = PAGESIZE);
 HIDDEN(ape_text_rva = RVA(ape_text_vaddr));
 
 HIDDEN(ape_data_offset = ape_ram_offset + LOADADDR(.data) - ape_ram_paddr);
 HIDDEN(ape_data_paddr = LOADADDR(.data));
 HIDDEN(ape_data_vaddr = ADDR(.data));
-HIDDEN(ape_data_filesz = SIZEOF(.data));
-HIDDEN(ape_data_memsz = SIZEOF(.data));
+HIDDEN(ape_data_filesz = SIZEOF(.data) + SIZEOF(.tdata));
+HIDDEN(ape_data_memsz = SIZEOF(.data) + SIZEOF(.tdata));
 HIDDEN(ape_data_align = PAGESIZE);
 HIDDEN(ape_data_rva = RVA(ape_data_vaddr));
 
@@ -567,59 +560,16 @@ SHSTUB2(ape_loader_dd_count,
             ? ROUNDUP(ape_loader_end - ape_loader, PAGESIZE) / 64
             : 0);
 
-HIDDEN(blink_aarch64_b0 = RVA(blink_aarch64) % 10 + 48);
-HIDDEN(blink_aarch64_b1 = RVA(blink_aarch64) < 10 ? 32 : RVA(blink_aarch64) / 10 % 10 + 48);
-HIDDEN(blink_aarch64_b2 = RVA(blink_aarch64) < 100 ? 32 : RVA(blink_aarch64) / 100 % 10 + 48);
-HIDDEN(blink_aarch64_b3 = RVA(blink_aarch64) < 1000 ? 32 : RVA(blink_aarch64) / 1000 % 10 + 48);
-HIDDEN(blink_aarch64_b4 = RVA(blink_aarch64) < 10000 ? 32 : RVA(blink_aarch64) / 10000 % 10 + 48);
-HIDDEN(blink_aarch64_b5 = RVA(blink_aarch64) < 100000 ? 32 : RVA(blink_aarch64) / 100000 % 10 + 48);
-HIDDEN(blink_aarch64_b6 = RVA(blink_aarch64) < 1000000 ? 32 : RVA(blink_aarch64) / 1000000 % 10 + 48);
-HIDDEN(blink_aarch64_b7 = RVA(blink_aarch64) < 10000000 ? 32 : RVA(blink_aarch64) / 10000000 % 10 + 48);
-HIDDEN(blink_aarch64_b8 = RVA(blink_aarch64) < 100000000 ? 32 : RVA(blink_aarch64) / 100000000 % 10 + 48);
-HIDDEN(blink_aarch64_b9 = RVA(blink_aarch64) < 1000000000 ? 32 : RVA(blink_aarch64) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_aarch64_size_b0 = blink_aarch64_size % 10 + 48);
-HIDDEN(blink_aarch64_size_b1 = blink_aarch64_size < 10 ? 32 : blink_aarch64_size / 10 % 10 + 48);
-HIDDEN(blink_aarch64_size_b2 = blink_aarch64_size < 100 ? 32 : blink_aarch64_size / 100 % 10 + 48);
-HIDDEN(blink_aarch64_size_b3 = blink_aarch64_size < 1000 ? 32 : blink_aarch64_size / 1000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b4 = blink_aarch64_size < 10000 ? 32 : blink_aarch64_size / 10000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b5 = blink_aarch64_size < 100000 ? 32 : blink_aarch64_size / 100000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b6 = blink_aarch64_size < 1000000 ? 32 : blink_aarch64_size / 1000000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b7 = blink_aarch64_size < 10000000 ? 32 : blink_aarch64_size / 10000000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b8 = blink_aarch64_size < 100000000 ? 32 : blink_aarch64_size / 100000000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b9 = blink_aarch64_size < 1000000000 ? 32 : blink_aarch64_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_darwin_arm64_b0 = RVA(blink_darwin_arm64) % 10 + 48);
-HIDDEN(blink_darwin_arm64_b1 = RVA(blink_darwin_arm64) < 10 ? 32 : RVA(blink_darwin_arm64) / 10 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b2 = RVA(blink_darwin_arm64) < 100 ? 32 : RVA(blink_darwin_arm64) / 100 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b3 = RVA(blink_darwin_arm64) < 1000 ? 32 : RVA(blink_darwin_arm64) / 1000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b4 = RVA(blink_darwin_arm64) < 10000 ? 32 : RVA(blink_darwin_arm64) / 10000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b5 = RVA(blink_darwin_arm64) < 100000 ? 32 : RVA(blink_darwin_arm64) / 100000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b6 = RVA(blink_darwin_arm64) < 1000000 ? 32 : RVA(blink_darwin_arm64) / 1000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b7 = RVA(blink_darwin_arm64) < 10000000 ? 32 : RVA(blink_darwin_arm64) / 10000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b8 = RVA(blink_darwin_arm64) < 100000000 ? 32 : RVA(blink_darwin_arm64) / 100000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b9 = RVA(blink_darwin_arm64) < 1000000000 ? 32 : RVA(blink_darwin_arm64) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_darwin_arm64_size_b0 = blink_darwin_arm64_size % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b1 = blink_darwin_arm64_size < 10 ? 32 : blink_darwin_arm64_size / 10 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b2 = blink_darwin_arm64_size < 100 ? 32 : blink_darwin_arm64_size / 100 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b3 = blink_darwin_arm64_size < 1000 ? 32 : blink_darwin_arm64_size / 1000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b4 = blink_darwin_arm64_size < 10000 ? 32 : blink_darwin_arm64_size / 10000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b5 = blink_darwin_arm64_size < 100000 ? 32 : blink_darwin_arm64_size / 100000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b6 = blink_darwin_arm64_size < 1000000 ? 32 : blink_darwin_arm64_size / 1000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b7 = blink_darwin_arm64_size < 10000000 ? 32 : blink_darwin_arm64_size / 10000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b8 = blink_darwin_arm64_size < 100000000 ? 32 : blink_darwin_arm64_size / 100000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b9 = blink_darwin_arm64_size < 1000000000 ? 32 : blink_darwin_arm64_size / 1000000000 % 10 + 48);
-
 #if SupportsMetal()
 HIDDEN(v_ape_realsectors =
-           MIN(0x70000 - IMAGE_BASE_REAL, ROUNDUP(RVA(_ezip), 512)) / 512);
-HIDDEN(v_ape_realbytes = v_ape_realsectors * 512);
-HIDDEN(v_ape_realdwords = v_ape_realsectors * (512 / 4));
-HIDDEN(v_ape_allsectors = ROUNDUP(RVA(_ezip), 512) / 512);
-HIDDEN(v_ape_allbytes = v_ape_allsectors * 512);
-HIDDEN(v_ape_highsectors = MIN(0xffff, v_ape_allsectors - v_ape_realsectors));
-TSSDESCSTUB2(_tss, _tss, _tss_end ? _tss_end - _tss - 1 : 0);
+           MIN(0x70000 - IMAGE_BASE_REAL,
+               ROUNDUP(RVA(_edata), 4096)) / 512);
+HIDDEN(v_ape_realslacksectors =
+           v_ape_realsectors - MIN(0x70000 - IMAGE_BASE_REAL,
+                                   ROUNDUP(RVA(_edata), 512)) / 512);
+HIDDEN(v_ape_realpages = v_ape_realsectors / (4096 / 512));
+HIDDEN(v_ape_highsectors =
+           (ROUNDUP(RVA(_edata), 512) / 512) - v_ape_realsectors);
 #endif
 
 /* ZIP End of Central Directory header */
@@ -701,7 +651,7 @@ CHURN(ADDR(.bss));
 CHURN(_start);
 CHURN(ape_phdrs);
 #if SupportsMetal()
-CHURN(v_ape_allsectors);
+CHURN(v_ape_realsectors);
 #endif
 #if SupportsXnu()
 CHURN(ape_macho);
@@ -765,7 +715,7 @@ ASSERT(IS2POW(ape_stack_memsz),
        "ape_stack_memsz must be a two power");
 
 ASSERT(ape_stack_vaddr % ape_stack_memsz == 0,
-       "ape_stack_vaddr must have ape_stack_memsz alignment; try using STATIC_STACK_ADDR(0x700000040000 & -ape_stack_memsz);");
+       "ape_stack_vaddr must have ape_stack_memsz alignment; try using STATIC_STACK_ADDR(0x700000040000 - ape_stack_memsz);");
 
 ASSERT(ALIGNOF(.tdata) <= TLS_ALIGNMENT && ALIGNOF(.tbss) <= TLS_ALIGNMENT,
        "_Thread_local _Alignof can't exceed TLS_ALIGNMENT");

ape/ape.mk

@@ -65,7 +65,6 @@ o/$(MODE)/ape/ape.lds:				\
 		libc/intrin/bits.h		\
 		libc/thread/tls.h		\
 		libc/calls/struct/timespec.h	\
-		libc/thread/thread.h		\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/elf/pf2prot.internal.h	\
@@ -83,7 +82,6 @@ o/$(MODE)/ape/public/ape.lds:			\
 		libc/intrin/bits.h		\
 		libc/thread/tls.h		\
 		libc/calls/struct/timespec.h	\
-		libc/thread/thread.h		\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/elf/pf2prot.internal.h	\
@@ -96,10 +94,6 @@ o/ape/idata.inc:				\
 		ape/idata.internal.h		\
 		ape/relocations.h
 
-o/$(MODE)/ape/ape.o:				\
-		ape/blink-aarch64.gz		\
-		ape/blink-darwin-arm64.gz
-
 o/$(MODE)/ape/ape-no-modify-self.o:		\
 		ape/ape.S			\
 		ape/macros.internal.h		\
@@ -111,7 +105,6 @@ o/$(MODE)/ape/ape-no-modify-self.o:		\
 		libc/macho.internal.h		\
 		libc/macros.internal.h		\
 		libc/nexgen32e/uart.internal.h	\
-		libc/calls/metalfile.internal.h	\
 		libc/nexgen32e/vidya.internal.h	\
 		libc/nt/pedef.internal.h	\
 		libc/runtime/e820.internal.h	\
@@ -119,8 +112,6 @@ o/$(MODE)/ape/ape-no-modify-self.o:		\
 		libc/runtime/pc.internal.h	\
 		libc/runtime/symbolic.h		\
 		libc/sysv/consts/prot.h		\
-		ape/blink-aarch64.gz		\
-		ape/blink-darwin-arm64.gz	\
 		o/$(MODE)/ape/ape.elf
 	@$(COMPILE)				\
 		-AOBJECTIFY.S			\
@@ -140,16 +131,13 @@ o/$(MODE)/ape/ape-copy-self.o:			\
 		libc/macho.internal.h		\
 		libc/macros.internal.h		\
 		libc/nexgen32e/uart.internal.h	\
-		libc/calls/metalfile.internal.h	\
 		libc/nexgen32e/vidya.internal.h	\
 		libc/nt/pedef.internal.h	\
 		libc/runtime/e820.internal.h	\
 		libc/runtime/mman.internal.h	\
 		libc/runtime/pc.internal.h	\
 		libc/runtime/symbolic.h		\
-		libc/sysv/consts/prot.h		\
-		ape/blink-aarch64.gz		\
-		ape/blink-darwin-arm64.gz
+		libc/sysv/consts/prot.h
 	@$(COMPILE)				\
 		-AOBJECTIFY.S			\
 		$(OBJECTIFY.S)			\

ape/apeinstall.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-if [ "$(id -u)" -eq 0 ]; then
+if [ $UID -eq 0 ]; then
   SUDO=
 else
   SUDO=sudo
@@ -97,8 +97,6 @@ if [ x"$(uname -s)" = xLinux ]; then
   echo you may need to edit configs to persist across reboot >&2
   echo '$SUDO sh -c "echo '"'"':APE:M::MZqFpD::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
   $SUDO sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
-  echo '$SUDO sh -c "echo '"'"':APE-jart:M::jartsr::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
-  $SUDO sh -c "echo ':APE-jart:M::jartsr::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
   echo done >&2
 
   if [ x"$(cat /proc/sys/fs/binfmt_misc/status)" = xdisabled ]; then

ape/apeuninstall.sh

@@ -8,19 +8,17 @@ fi
 
 {
   echo
-  echo "APE Uninstaller intends to run (in pseudo-shell)"
+  echo "APE Uninstaller intends to run"
   echo
-  echo "    sudo echo -1 into /proc/sys/fs/binfmt_misc/APE*"
-  echo "    sudo rm -f /usr/bin/ape ~/.ape o/tmp/.ape /tmp/.ape"
+  echo "    $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE'"
+  echo "    $SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape /tmp/.ape"
   echo
   echo "You may then use ape/apeinstall.sh to reinstall it"
   echo
 } >&2
 
 set -ex
-for f in /proc/sys/fs/binfmt_misc/APE*; do
-  if [ -f $f ]; then
-    $SUDO sh -c "echo -1 >$f" || exit
-  fi
-done
+if [ -f /proc/sys/fs/binfmt_misc/APE ]; then
+  $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE' || exit
+fi
 $SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape o/tmp/ape /tmp/.ape /tmp/ape || exit

ape/idata.internal.h

@@ -32,23 +32,23 @@
 //	@see	ape/ape.lds
 //	@see	winimp
 .macro	.imp	dll:req fn:req actual:req hint
-	.dll	"\dll"
-	.section ".piro.data.sort.iat.2.\dll\().2.\actual","aw",@progbits
+	.dll	\dll
+	.section .piro.data.sort.iat.2.\dll\().2.\actual,"aw",@progbits
 	.type	\fn,@object
 	.align	__SIZEOF_POINTER__
-\fn:	.quad	RVA(("\dll\().\actual"))
+\fn:	.quad	RVA((\dll\().\actual))
 	.size	\fn,.-\fn
 	.globl	\fn
 	.hidden	\fn
 	.previous
-	.section ".idata.ro.ilt.\dll\().2.\actual","a",@progbits
-".Lidata.ilt.\dll\().\actual":
-	.quad	RVA("\dll\().\actual")
-	.type	".Lidata.ilt.\dll\().\actual",@object
-	.size	".Lidata.ilt.\dll\().\actual",.-".Lidata.ilt.\dll\().\actual"
+	.section .idata.ro.ilt.\dll\().2.\actual,"a",@progbits
+.Lidata.ilt.\dll\().\actual:
+	.quad	RVA((\dll\().\actual))
+	.type	.Lidata.ilt.\dll\().\actual,@object
+	.size	.Lidata.ilt.\dll\().\actual,.-.Lidata.ilt.\dll\().\actual
 	.previous
-	.section ".idata.ro.hnt.\dll\().2.\actual","a",@progbits
-"\dll\().\actual":
+	.section .idata.ro.hnt.\dll\().2.\actual,"a",@progbits
+\dll\().\actual:
 	.ifnb	\hint			# hint i.e. guess function ordinal
 	.short	\hint
 	.else
@@ -56,55 +56,55 @@
 	.endif
 	.asciz	"\actual"
 	.align	2			# documented requirement
-	.globl	"\dll\().\actual"
-	.hidden	"\dll\().\actual"
-	.type	"\dll\().\actual",@object
-	.size	"\dll\().\actual",.-"\dll\().\actual"
+	.globl	\dll\().\actual
+	.hidden	\dll\().\actual
+	.type	\dll\().\actual,@object
+	.size	\dll\().\actual,.-\dll\().\actual
 	.previous
 .endm
 
 //	Defines DLL import.
 //	@note	this is an implementation detail of .imp
 .macro	.dll	name:req
-  .section ".idata.ro.idt.2.\name","aG",@progbits,"\name",comdat
-	.equ	".Lidata.idt.\name",.
-	.long	RVA("idata.ilt.\name")		# ImportLookupTable
+  .section .idata.ro.idt.2.\name,"aG",@progbits,\name,comdat
+	.equ	.Lidata.idt.\name,.
+	.long	RVA(idata.ilt.\name)		# ImportLookupTable
 	.long	0				# TimeDateStamp
 	.long	0				# ForwarderChain
-	.long	RVA(".Lidata.str.\name")	# DllNameRva
-	.long	RVA("idata.iat.\name")		# ImportAddressTable
-	.type	".Lidata.idt.\name",@object
-	.size	".Lidata.idt.\name",.-".Lidata.idt.\name"
+	.long	RVA(.Lidata.str.\name)		# DllNameRva
+	.long	RVA(idata.iat.\name)		# ImportAddressTable
+	.type	.Lidata.idt.\name,@object
+	.size	.Lidata.idt.\name,.-.Lidata.idt.\name
   .previous
-  .section ".idata.ro.ilt.\name\().1","aG",@progbits,"\name",comdat
+  .section .idata.ro.ilt.\name\().1,"aG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
-	.type	"idata.ilt.\name",@object
-"idata.ilt.\name":
+	.type	idata.ilt.\name,@object
+idata.ilt.\name:
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section ".idata.ro.ilt.\name\().3","aG",@progbits,"\name",comdat
+	*/.section .idata.ro.ilt.\name\().3,"aG",@progbits,\name,comdat
 	.quad	0
   .previous
-  .section ".idata.ro.hnt.\name\().1","aG",@progbits,"\name",comdat
+  .section .idata.ro.hnt.\name\().1,"aG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
-	.type	"idata.hnt.\name",@object
-	.equ	"idata.hnt.\name",.
+	.type	idata.hnt.\name,@object
+	.equ	idata.hnt.\name,.
   .previous
-  .section ".piro.data.sort.iat.2.\name\().1","awG",@progbits,"\name",comdat
+  .section .piro.data.sort.iat.2.\name\().1,"awG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
-	.type	"idata.iat.\name",@object
-"idata.iat.\name":
+	.type	idata.iat.\name,@object
+idata.iat.\name:
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section ".piro.data.sort.iat.2.\name\().3","awG",@progbits,"\name",comdat
+	*/.section .piro.data.sort.iat.2.\name\().3,"awG",@progbits,\name,comdat
 	.quad	0
   .previous
   .section .rodata.str1.1,"aSM",@progbits,1
-".Lidata.str.\name":
+.Lidata.str.\name:
 	.asciz	"\name\().dll"
   .previous
 .endm

ape/loader-elf.S

@@ -175,7 +175,7 @@ macho:	.long	0xFEEDFACE+1
 510:	.quad	0				# rax
 	.quad	0				# rbx
 	.quad	0				# rcx
-	.quad	_HOSTXNU			# rdx
+	.quad	XNU				# rdx
 	.quad	0				# rdi
 	.quad	0				# rsi
 	.quad	0				# rbp
@@ -221,7 +221,7 @@ _start:
 	jne	0f
 	cmp	$+1,%edx
 	jne	0f
-	mov	$_HOSTXNU,%dl
+	mov	$XNU,%dl
 	xor	%ecx,%ecx
 
 0:	mov	%rsp,%rsi

ape/loader-macho.S

@@ -90,7 +90,7 @@ macho:	.long	0xFEEDFACE+1
 510:	.quad	0				# rax
 	.quad	0				# rbx
 	.quad	0				# rcx
-	.quad	_HOSTXNU			# rdx
+	.quad	XNU				# rdx
 	.quad	0				# rdi
 	.quad	0				# rsi
 	.quad	0				# rbp
@@ -121,7 +121,7 @@ _start:
 	jne	0f
 	cmp	$+1,%edx
 	jne	0f
-	mov	$_HOSTXNU,%dl
+	mov	$XNU,%dl
 	xor	%ecx,%ecx
 
 0:	mov	%rsp,%rsi

ape/macros.internal.h

@@ -180,20 +180,6 @@
  .stub	\name\()_bcs\n,long
 .endm
 
-//	Task State Segment Descriptor Entries.
-.macro	.tssdescstub name:req
- .ifndef \name
-  .weak	\name
-  .set	\name,0
- .endif
- .ifndef \name\()_end
-  .weak	\name\()_end
-  .set	\name\()_end,0
- .endif
- .stub	\name\()_desc_ent0,quad
- .stub	\name\()_desc_ent1,quad
-.endm
-
 /* clang-format on */
 #elif defined(__LINKER__)
 
@@ -271,22 +257,5 @@
                        (X) % 10 * 0x1000000        \
                      : 0xffffffffffffffff)
 
-/**
- * Laying out the GDT entries for a TSS for bare metal operation.
- */
-#define TSSDESCSTUB2(SYM, BASE, LIM)                 \
-  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                       | \
-   ((BASE) >> 24 << 56 & 0xff00000000000000))
-#define TSSDESC_ENT1(BASE)                     \
-   ((BASE) >> 32 <<  0 & 0x00000000ffffffff)
-
 #endif /* __ASSEMBLER__ */
 #endif /* APE_MACROS_H_ */

ape/sections.internal.h

@@ -1,34 +0,0 @@
-#ifndef COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
-#define COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-COSMOPOLITAN_C_START_
-
-extern unsigned char _base[];
-extern unsigned char _ehead[];
-extern unsigned char _etext[];
-extern unsigned char _edata[];
-extern unsigned char _ezip[];
-extern unsigned char _end[];
-extern unsigned char _ereal[];
-extern unsigned char _tdata_start[];
-extern unsigned char _tdata_end[];
-extern unsigned char _tbss_start[];
-extern unsigned char _tbss_end[];
-extern unsigned char __privileged_start[];
-extern unsigned char __privileged_addr[];
-extern unsigned char __privileged_size[];
-extern unsigned char __privileged_end[];
-extern unsigned char __test_start[];
-extern unsigned char __ro[];
-extern unsigned char *__relo_start[];
-extern unsigned char *__relo_end[];
-extern uint8_t __zip_start[];
-extern uint8_t __zip_end[];
-extern uint8_t __data_start[];
-extern uint8_t __data_end[];
-extern uint8_t __bss_start[];
-extern uint8_t __bss_end[];
-
-COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_ */

build/config.mk

@@ -29,7 +29,7 @@ endif
 #
 ifeq ($(MODE),fastbuild)
 CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O
-CONFIG_CPPFLAGS += -DSYSDEBUG -DDWARFLESS
+CONFIG_CPPFLAGS += -DSYSDEBUG
 CONFIG_OFLAGS += -g0
 CONFIG_LDFLAGS += -S
 TARGET_ARCH ?= -msse3
@@ -102,7 +102,7 @@ endif
 #   - Larger binaries
 #
 ifeq ($(MODE), asan)
-CONFIG_CCFLAGS += $(BACKTRACES) -O2 -DSYSDEBUG
+CONFIG_CCFLAGS += $(BACKTRACES) -O2
 CONFIG_COPTS += -fsanitize=address
 TARGET_ARCH ?= -msse3
 endif
@@ -125,22 +125,6 @@ TARGET_ARCH ?= -msse3
 OVERRIDE_CCFLAGS += -fno-pie
 endif
 
-# System Five Mode
-#
-#   - `make MODE=sysv`
-#   - Optimized
-#   - Backtraces
-#   - Debuggable
-#   - Syscall tracing
-#   - Function tracing
-#   - No Windows bloat!
-#
-ifeq ($(MODE), sysv)
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2
-CONFIG_CPPFLAGS += -DSYSDEBUG -DSUPPORT_VECTOR=121
-TARGET_ARCH ?= -msse3
-endif
-
 # Tiny Mode
 #
 #   - `make MODE=tiny`
@@ -167,12 +151,7 @@ CONFIG_CCFLAGS +=			\
 	-fschedule-insns2		\
 	-fomit-frame-pointer		\
 	-momit-leaf-frame-pointer	\
-	-foptimize-sibling-calls	\
-	-DDWARFLESS
-CONFIG_OFLAGS +=			\
-	-g0
-CONFIG_LDFLAGS +=			\
-	-S
+	-foptimize-sibling-calls
 TARGET_ARCH ?=				\
 	-msse3
 PYFLAGS +=				\
@@ -198,14 +177,9 @@ CONFIG_CPPFLAGS +=			\
 	-DTINY				\
 	-DNDEBUG			\
 	-DTRUSTWORTHY			\
-	-DSUPPORT_VECTOR=1		\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=1
 DEFAULT_COPTS +=			\
 	-mred-zone
-CONFIG_OFLAGS +=			\
-	-g0
-CONFIG_LDFLAGS +=			\
-	-S
 CONFIG_CCFLAGS +=			\
 	-Os				\
 	-fno-align-functions		\
@@ -235,14 +209,9 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=113	\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=113
 DEFAULT_COPTS +=		\
 	-mred-zone
-CONFIG_OFLAGS +=		\
-	-g0
-CONFIG_LDFLAGS +=		\
-	-S
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -271,8 +240,7 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=121	\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=121
 DEFAULT_COPTS +=		\
 	-mred-zone
 CONFIG_CCFLAGS +=		\
@@ -281,10 +249,6 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-CONFIG_OFLAGS +=		\
-	-g0
-CONFIG_LDFLAGS +=		\
-	-S
 TARGET_ARCH ?=			\
 	-msse3
 endif
@@ -307,44 +271,17 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=251	\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=251
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-CONFIG_OFLAGS +=		\
-	-g0
-CONFIG_LDFLAGS +=		\
-	-S
 TARGET_ARCH ?=			\
 	-msse3
 endif
 
-# GCC11 Mode
-# https://justine.lol/compilers/x86_64-linux-musl__x86_64-linux-musl__g++-11.2.0.tar.xz
-ifeq ($(MODE), gcc11)
-.UNVEIL += rx:/opt/gcc11
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -DSYSDEBUG -O2
-AS = /opt/gcc11/bin/x86_64-linux-musl-as
-CC = /opt/gcc11/bin/x86_64-linux-musl-gcc
-CXX = /opt/gcc11/bin/x86_64-linux-musl-g++
-CXXFILT = /opt/gcc11/bin/x86_64-linux-musl-c++filt
-LD = /opt/gcc11/bin/x86_64-linux-musl-ld.bfd
-NM = /opt/gcc11/bin/x86_64-linux-musl-nm
-GCC = /opt/gcc11/bin/x86_64-linux-musl-gcc
-STRIP = /opt/gcc11/bin/x86_64-linux-musl-strip
-OBJCOPY = /opt/gcc11/bin/x86_64-linux-musl-objcopy
-OBJDUMP = /opt/gcc11/bin/x86_64-linux-musl-objdump
-ADDR2LINE = /opt/gcc11/bin/x86_64-linux-musl-addr2line
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2 -Wno-stringop-overread
-CONFIG_CFLAGS += -Wno-old-style-definition
-CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
-TARGET_ARCH ?= -msse3
-endif
-
 # LLVM Mode
 ifeq ($(MODE), llvm)
 TARGET_ARCH ?= -msse3

build/definitions.mk

@@ -45,6 +45,7 @@
 LC_ALL = C
 SOURCE_DATE_EPOCH = 0
 
+TAGS ?= /usr/bin/ctags  # emacs source builds or something breaks it
 ARFLAGS = rcsD
 ZFLAGS ?=
 XARGS ?= xargs -P4 -rs8000
@@ -72,25 +73,33 @@ IMAGE_BASE_VIRTUAL ?= 0x400000
 IGNORE := $(shell $(ECHO) -2 ♥cosmo)
 IGNORE := $(shell $(MKDIR) o/tmp)
 
-ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-pc-linux-gnu-*)","")
-PREFIX = o/third_party/gcc/bin/x86_64-pc-linux-gnu-
+ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-pc-linux-gnu-as.exe)","")
+AS = o/third_party/gcc/bin/x86_64-pc-linux-gnu-as.exe
+CC = o/third_party/gcc/bin/x86_64-pc-linux-gnu-gcc.exe
+CXX = o/third_party/gcc/bin/x86_64-pc-linux-gnu-g++.exe
+CXXFILT = o/third_party/gcc/bin/x86_64-pc-linux-gnu-c++filt.exe
+LD = o/third_party/gcc/bin/x86_64-pc-linux-gnu-ld.bfd.exe
+NM = o/third_party/gcc/bin/x86_64-pc-linux-gnu-nm.exe
+GCC = o/third_party/gcc/bin/x86_64-pc-linux-gnu-gcc.exe
+STRIP = o/third_party/gcc/bin/x86_64-pc-linux-gnu-strip.exe
+OBJCOPY = o/third_party/gcc/bin/x86_64-pc-linux-gnu-objcopy.exe
+OBJDUMP = o/third_party/gcc/bin/x86_64-pc-linux-gnu-objdump.exe
+ADDR2LINE = $(PWD)/o/third_party/gcc/bin/x86_64-pc-linux-gnu-addr2line.exe
 else
 IGNORE := $(shell build/bootstrap/unbundle.com)
-PREFIX = o/third_party/gcc/bin/x86_64-linux-musl-
+AS = o/third_party/gcc/bin/x86_64-linux-musl-as
+CC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
+CXX = o/third_party/gcc/bin/x86_64-linux-musl-g++
+CXXFILT = o/third_party/gcc/bin/x86_64-linux-musl-c++filt
+LD = o/third_party/gcc/bin/x86_64-linux-musl-ld.bfd
+NM = o/third_party/gcc/bin/x86_64-linux-musl-nm
+GCC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
+STRIP = o/third_party/gcc/bin/x86_64-linux-musl-strip
+OBJCOPY = o/third_party/gcc/bin/x86_64-linux-musl-objcopy
+OBJDUMP = o/third_party/gcc/bin/x86_64-linux-musl-objdump
+ADDR2LINE = $(PWD)/o/third_party/gcc/bin/x86_64-linux-musl-addr2line
 endif
 
-AS = $(PREFIX)as
-CC = $(PREFIX)gcc
-CXX = $(PREFIX)g++
-CXXFILT = $(PREFIX)c++filt
-LD = $(PREFIX)ld.bfd
-NM = $(PREFIX)nm
-GCC = $(PREFIX)gcc
-STRIP = $(PREFIX)strip
-OBJCOPY = $(PREFIX)objcopy
-OBJDUMP = $(PREFIX)objdump
-ADDR2LINE = $(PWD)/$(PREFIX)addr2line
-
 export ADDR2LINE
 export LC_ALL
 export MKDIR
@@ -139,7 +148,6 @@ DEFAULT_CCFLAGS =							\
 
 DEFAULT_OFLAGS =							\
 	-g								\
-	-gdwarf-4							\
 	-gdescribe-dies
 
 DEFAULT_COPTS =								\

build/htags

@@ -43,9 +43,6 @@
 #     '(progn
 #        (add-hook 'c-mode-common-hook 'jart-c-mode-common-hook)))
 
-TAGS="$1"
-shift
-
 # ctags doesn't understand atomics, e.g.
 #   extern char **environ;
 set -- --regex-c='/_Atomic(\([^)]*\))/\1/b' "$@"
@@ -66,7 +63,7 @@ set -- --regex-c='/^extern [^(]*(\*const \([^)]*\))(/\1/b' "$@"
 #   struct WorstSoftwareEver;
 set -- --regex-c='/^struct.*;$/uehocruehcroue/b' "$@"
 
-exec $TAGS                                                        \
+exec ${TAGS:-ctags}                                               \
      -e                                                           \
      --langmap=c:.c.h                                             \
      --exclude=libc/nt/struct/imagefileheader.internal.h          \

build/rules.mk

@@ -163,15 +163,15 @@ o/$(MODE)%/.zip.o: %
 # and it would be too costly in terms of make latency to have every
 # header file depend on $(HDRS) and $(INCS).
 
-o/%.h.ok: private .UNSANDBOXED = 1
+o/%.h.ok: .UNSANDBOXED = 1
 o/%.h.ok: %.h
 	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
 
-o/$(MODE)/%.h.ok: private .UNSANDBOXED = 1
+o/$(MODE)/%.h.ok: .UNSANDBOXED = 1
 o/$(MODE)/%.h.ok: %.h
 	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
 
-o/$(MODE)/%.hh.ok: private .UNSANDBOXED = 1
+o/$(MODE)/%.hh.ok: .UNSANDBOXED = 1
 o/$(MODE)/%.hh.ok: %.hh
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
@@ -179,7 +179,7 @@ o/%.okk: .UNSANDBOXED = 1
 o/%.okk: %
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
-o/$(MODE)/%.okk: private .UNSANDBOXED = 1
+o/$(MODE)/%.okk: .UNSANDBOXED = 1
 o/$(MODE)/%.okk: %
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
@@ -207,19 +207,19 @@ MAKE_SYMTAB_ZIP =				\
 ################################################################################
 # EMACS ASSEMBLY GENERATION
 
-o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-gcc.asm: .UNSANDBOXED = 1
 o/$(MODE)/%-gcc.asm: %.c
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
 
-o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-gcc.asm: .UNSANDBOXED = 1
 o/$(MODE)/%-gcc.asm: %.cc
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
 
-o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-clang.asm: .UNSANDBOXED = 1
 o/$(MODE)/%-clang.asm: %.c
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
 
 o/$(MODE)/%-clang.asm: CC = $(CLANG)
-o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-clang.asm: .UNSANDBOXED = 1
 o/$(MODE)/%-clang.asm: %.cc
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<

dsp/tty/config.c

@@ -30,7 +30,7 @@
  * @see ttyconfig(), ttyrestore()
  */
 int ttyconfig(int ttyfd, ttyconf_f fn, int64_t arg,
-              struct termios *opt_out_oldconf) {
+              const struct termios *opt_out_oldconf) {
   struct termios conf[2];
   if (tcgetattr(ttyfd, &conf[0]) != -1 &&
       fn(memcpy(&conf[1], &conf[0], sizeof(conf[0])), arg) != -1 &&

dsp/tty/tty.h

@@ -44,7 +44,7 @@ int ttysendtitle(int, const char *, const struct TtyIdent *);
 int ttyident(struct TtyIdent *, int, int);
 void ttyidentclear(struct TtyIdent *);
 char *ttydescribe(char *, size_t, const struct TtyIdent *);
-int ttyconfig(int, ttyconf_f, int64_t, struct termios *);
+int ttyconfig(int, ttyconf_f, int64_t, const struct termios *);
 int ttyrestore(int, const struct termios *);
 int ttysetrawdeadline(struct termios *, int64_t);
 int ttysetrawmode(struct termios *, int64_t);

examples/auto-memory-safety-crash2.c

@@ -7,12 +7,12 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/dce.h"
 #include "libc/intrin/bits.h"
-#include "libc/intrin/kprintf.h"
+#include "libc/dce.h"
 #include "libc/log/log.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 
 /**
@@ -59,15 +59,9 @@
 
 int main(int argc, char *argv[]) {
   if (!IsAsan()) {
-    kprintf("this example is intended for MODE=asan or MODE=dbg\n");
+    printf("this example is intended for MODE=asan or MODE=dbg\n");
     exit(1);
   }
-
-  kprintf("----------------\n");
-  kprintf(" THIS IS A TEST \n");
-  kprintf("SIMULATING CRASH\n");
-  kprintf("----------------\n");
-
   char *buffer;
   ShowCrashReports(); /* not needed but yoinks appropriate symbols */
   buffer = malloc(13);

examples/clock.c

@@ -20,22 +20,22 @@ int main(int argc, char *argv[]) {
   volatile unsigned long x;
   struct timespec now, start, next, interval;
   printf("hammering the cpu...\n");
-  next = start = timespec_mono();
-  interval = timespec_frommillis(500);
-  next = timespec_add(next, interval);
+  next = start = _timespec_mono();
+  interval = _timespec_frommillis(500);
+  next = _timespec_add(next, interval);
   for (;;) {
     for (i = 0;; ++i) {
       x *= 7;
       if (!(i % 256)) {
-        now = timespec_mono();
-        if (timespec_cmp(now, next) >= 0) {
+        now = _timespec_mono();
+        if (_timespec_gte(now, next)) {
           break;
         }
       }
     }
-    next = timespec_add(next, interval);
+    next = _timespec_add(next, interval);
     printf("consumed %10g seconds monotonic time and %10g seconds cpu time\n",
-           timespec_tonanos(timespec_sub(now, start)) / 1000000000.,
+           _timespec_tonanos(_timespec_sub(now, start)) / 1000000000.,
            (double)clock() / CLOCKS_PER_SEC);
   }
 }

examples/clock_getres.c

@@ -1,58 +0,0 @@
-#if 0
-/*─────────────────────────────────────────────────────────────────╗
-│ To the extent possible under law, Justine Tunney has waived      │
-│ all copyright and related or neighboring rights to this file,    │
-│ as it is written in the following disclaimers:                   │
-│   • http://unlicense.org/                                        │
-│   • http://creativecommons.org/publicdomain/zero/1.0/            │
-╚─────────────────────────────────────────────────────────────────*/
-#endif
-#include "libc/calls/struct/timespec.h"
-#include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/clock.h"
-
-int n;
-int shown[64];
-
-void show(int clock) {
-  int i;
-  struct timespec ts;
-  if (clock == 127) return;
-  for (i = 0; i < n; ++i) {
-    if (shown[i] == clock) {
-      return;
-    }
-  }
-  shown[n++] = clock;
-  if (clock_getres(clock, &ts) != -1) {
-    kprintf("%s %'ld ns\n", DescribeClockName(clock), timespec_tonanos(ts));
-  } else {
-    kprintf("%s %s\n", DescribeClockName(clock), _strerrno(errno));
-  }
-}
-
-int main(int argc, char *argv[]) {
-  show(CLOCK_REALTIME);
-  show(CLOCK_REALTIME_FAST);
-  show(CLOCK_REALTIME_PRECISE);
-  show(CLOCK_REALTIME_COARSE);
-  show(CLOCK_MONOTONIC);
-  show(CLOCK_MONOTONIC_RAW);
-  show(CLOCK_MONOTONIC_FAST);
-  show(CLOCK_MONOTONIC_PRECISE);
-  show(CLOCK_MONOTONIC_COARSE);
-  show(CLOCK_PROCESS_CPUTIME_ID);
-  show(CLOCK_THREAD_CPUTIME_ID);
-  show(CLOCK_PROF);
-  show(CLOCK_BOOTTIME);
-  show(CLOCK_REALTIME_ALARM);
-  show(CLOCK_BOOTTIME_ALARM);
-  show(CLOCK_TAI);
-  show(CLOCK_UPTIME);
-  show(CLOCK_UPTIME_PRECISE);
-  show(CLOCK_UPTIME_FAST);
-  show(CLOCK_SECOND);
-}

examples/crashreport.c

@@ -7,7 +7,6 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/intrin/kprintf.h"
 #include "libc/log/log.h"
 #include "libc/runtime/symbols.internal.h"
 
@@ -25,12 +24,6 @@
  */
 
 noubsan int main(int argc, char *argv[]) {
-
-  kprintf("----------------\n");
-  kprintf(" THIS IS A TEST \n");
-  kprintf("SIMULATING CRASH\n");
-  kprintf("----------------\n");
-
   volatile int64_t x;
   ShowCrashReports();
   return 1 / (x = 0);

examples/curl.c

@@ -52,10 +52,12 @@
 #include "third_party/mbedtls/pk.h"
 #include "third_party/mbedtls/ssl.h"
 #include "third_party/mbedtls/ssl_ticket.h"
-#include "tool/curl/cmd.h"
 
 /**
  * @fileoverview Downloads HTTP URL to stdout.
+ *
+ *     make -j8 o//examples/curl.com
+ *     o//examples/curl.com http://justine.lol/ape.html
  */
 
 #define HasHeader(H)    (!!msg.headers[H].a)
@@ -115,11 +117,11 @@ static int TlsRecv(void *c, unsigned char *p, size_t n, uint32_t o) {
 }
 
 static wontreturn void PrintUsage(FILE *f, int rc) {
-  fprintf(f, "usage: %s [-iksvV] URL\n", program_invocation_name);
+  fprintf(f, "usage: %s [-ksvV] URL\n", program_invocation_name);
   exit(rc);
 }
 
-int _curl(int argc, char *argv[]) {
+int main(int argc, char *argv[]) {
   if (!NoDebug()) ShowCrashReports();
 
   /*
@@ -130,13 +132,11 @@ int _curl(int argc, char *argv[]) {
     size_t n;
     char **p;
   } headers = {0};
-  int method = 0;
+  int method = kHttpGet;
   bool authmode = MBEDTLS_SSL_VERIFY_REQUIRED;
-  bool includeheaders = false;
-  const char *postdata = NULL;
   const char *agent = "hurl/1.o (https://github.com/jart/cosmopolitan)";
   __log_level = kLogWarn;
-  while ((opt = getopt(argc, argv, "qiksvVIX:H:A:d:")) != -1) {
+  while ((opt = getopt(argc, argv, "qksvVIX:H:A:")) != -1) {
     switch (opt) {
       case 's':
       case 'q':
@@ -144,9 +144,6 @@ int _curl(int argc, char *argv[]) {
       case 'v':
         ++__log_level;
         break;
-      case 'i':
-        includeheaders = true;
-        break;
       case 'I':
         method = kHttpHead;
         break;
@@ -157,9 +154,6 @@ int _curl(int argc, char *argv[]) {
         headers.p = realloc(headers.p, ++headers.n * sizeof(*headers.p));
         headers.p[headers.n - 1] = optarg;
         break;
-      case 'd':
-        postdata = optarg;
-        break;
       case 'X':
         CHECK((method = GetHttpMethod(optarg, strlen(optarg))));
         break;
@@ -189,7 +183,7 @@ int _curl(int argc, char *argv[]) {
   struct Url url;
   char *host, *port;
   bool usessl = false;
-  _gc(ParseUrl(urlarg, -1, &url, kUrlPlus));
+  _gc(ParseUrl(urlarg, -1, &url));
   _gc(url.params.p);
   if (url.scheme.n) {
     if (url.scheme.n == 5 && !memcasecmp(url.scheme.p, "https", 5)) {
@@ -230,29 +224,17 @@ int _curl(int argc, char *argv[]) {
   /*
    * Create HTTP message.
    */
-  if (!method) method = postdata ? kHttpPost : kHttpGet;
-
   char *request = 0;
   appendf(&request,
           "%s %s HTTP/1.1\r\n"
+          "Host: %s:%s\r\n"
           "Connection: close\r\n"
           "User-Agent: %s\r\n",
-          kHttpMethod[method], _gc(EncodeUrl(&url, 0)), agent);
-
-  bool senthost = false, sentcontenttype = false, sentcontentlength = false;
+          kHttpMethod[method], _gc(EncodeUrl(&url, 0)), host, port, agent);
   for (int i = 0; i < headers.n; ++i) {
     appendf(&request, "%s\r\n", headers.p[i]);
-    if (!strncasecmp("Host:", headers.p[i], 5)) senthost = true;
-    else if (!strncasecmp("Content-Type:", headers.p[i], 13)) sentcontenttype = true;
-    else if (!strncasecmp("Content-Length:", headers.p[i], 15)) sentcontentlength = true;
-  }
-  if (!senthost) appendf(&request, "Host: %s:%s\r\n", host, port);
-  if (postdata) {
-    if (!sentcontenttype) appends(&request, "Content-Type: application/x-www-form-urlencoded\r\n");
-    if (!sentcontentlength) appendf(&request, "Content-Length: %d\r\n", strlen(postdata));
   }
   appendf(&request, "\r\n");
-  if (postdata) appends(&request, postdata);
 
   /*
    * Setup crypto.
@@ -280,7 +262,7 @@ int _curl(int argc, char *argv[]) {
    * Perform DNS lookup.
    */
   struct addrinfo *addr;
-  struct addrinfo hints = {.ai_family = AF_UNSPEC,
+  struct addrinfo hints = {.ai_family = AF_INET,
                            .ai_socktype = SOCK_STREAM,
                            .ai_protocol = IPPROTO_TCP,
                            .ai_flags = AI_NUMERICSERV};
@@ -362,10 +344,10 @@ int _curl(int argc, char *argv[]) {
             i -= hdrlen;
             break;
           }
-          if (method == kHttpHead || includeheaders) {
+          if (method == kHttpHead) {
             Write(p, hdrlen);
-          }
-          if (method == kHttpHead || msg.status == 204 || msg.status == 304) {
+            goto Finished;
+          } else if (msg.status == 204 || msg.status == 304) {
             goto Finished;
           }
           if (HasHeader(kHttpTransferEncoding) &&

examples/examples.mk

@@ -49,12 +49,12 @@ EXAMPLES_DIRECTDEPS =								\
 	LIBC_LOG								\
 	LIBC_MEM								\
 	LIBC_NEXGEN32E								\
-	LIBC_NT_ADVAPI32							\
 	LIBC_NT_IPHLPAPI							\
 	LIBC_NT_KERNEL32							\
 	LIBC_NT_NTDLL								\
 	LIBC_NT_USER32								\
 	LIBC_NT_WS2_32								\
+	LIBC_NT_ADVAPI32							\
 	LIBC_RUNTIME								\
 	LIBC_SOCK								\
 	LIBC_STDIO								\
@@ -71,24 +71,18 @@ EXAMPLES_DIRECTDEPS =								\
 	LIBC_ZIPOS								\
 	NET_HTTP								\
 	NET_HTTPS								\
-	THIRD_PARTY_AWK								\
 	THIRD_PARTY_COMPILER_RT							\
 	THIRD_PARTY_DLMALLOC							\
-	THIRD_PARTY_DOUBLECONVERSION						\
 	THIRD_PARTY_GDTOA							\
 	THIRD_PARTY_GETOPT							\
 	THIRD_PARTY_LIBCXX							\
 	THIRD_PARTY_LINENOISE							\
 	THIRD_PARTY_LUA								\
-	THIRD_PARTY_HIREDIS							\
 	THIRD_PARTY_MBEDTLS							\
 	THIRD_PARTY_MUSL							\
 	THIRD_PARTY_NSYNC							\
-	THIRD_PARTY_NSYNC_MEM							\
 	THIRD_PARTY_QUICKJS							\
-	THIRD_PARTY_SED								\
 	THIRD_PARTY_STB								\
-	THIRD_PARTY_TR								\
 	THIRD_PARTY_XED								\
 	THIRD_PARTY_ZLIB							\
 	TOOL_BUILD_LIB								\
@@ -147,25 +141,6 @@ o/$(MODE)/examples/nesemu1.com.dbg:						\
 		$(EXAMPLES_BOOTLOADER)
 	@$(APELINK)
 
-# # force symtab.com to be a zip file, by pulling a zip asset into linkage
-# # we wouldn't need to do this if we depended on functions like localtime
-# o/$(MODE)/examples/symtab.com.dbg:						\
-# 		$(EXAMPLES_DEPS)						\
-# 		o/$(MODE)/examples/symtab.o					\
-# 		o/$(MODE)/examples/symtab.c.zip.o				\
-# 		o/$(MODE)/examples/examples.pkg					\
-# 		$(EXAMPLES_BOOTLOADER)
-# 	@$(APELINK)
-
-# modify .com so it can read the symbol table without needing the .com.dbg file
-o/$(MODE)/examples/symtab.com:							\
-		o/$(MODE)/examples/symtab.com.dbg				\
-		o/$(MODE)/third_party/zip/zip.com				\
-		o/$(MODE)/tool/build/symtab.com
-	@$(MAKE_OBJCOPY)
-	@$(MAKE_SYMTAB_CREATE)
-	@$(MAKE_SYMTAB_ZIP)
-
 o/$(MODE)/examples/picol.o: private				\
 		OVERRIDE_CPPFLAGS +=				\
 			-DSTACK_FRAME_UNLIMITED

examples/forkrand.c

@@ -9,12 +9,19 @@
 #endif
 #include "libc/calls/calls.h"
 #include "libc/log/check.h"
+#include "libc/log/log.h"
+#include "libc/nt/nt/process.h"
+#include "libc/mem/gc.h"
+#include "libc/runtime/memtrack.internal.h"
+#include "libc/runtime/runtime.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
+#include "libc/time/time.h"
+#include "libc/x/x.h"
 
 dontinline void dostuff(const char *s) {
   int i, us;
-  srand(_rand64()); /* seeds rand() w/ intel rdrnd, auxv, etc. */
+  srand(rand64()); /* seeds rand() w/ intel rdrnd, auxv, etc. */
   for (i = 0; i < 5; ++i) {
     us = rand() % 500000;
     usleep(us);

examples/getcpucount.c

@@ -8,8 +8,8 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/intrin/kprintf.h"
-#include "libc/runtime/runtime.h"
+#include "libc/runtime/sysconf.h"
 
 int main() {
-  kprintf("%d\n", _getcpucount());
+  kprintf("%d\n", GetCpuCount());
 }

examples/getdomainname.c

@@ -1,21 +0,0 @@
-#if 0
-/*─────────────────────────────────────────────────────────────────╗
-│ To the extent possible under law, Justine Tunney has waived      │
-│ all copyright and related or neighboring rights to this file,    │
-│ as it is written in the following disclaimers:                   │
-│   • http://unlicense.org/                                        │
-│   • http://creativecommons.org/publicdomain/zero/1.0/            │
-╚─────────────────────────────────────────────────────────────────*/
-#endif
-#include "libc/calls/calls.h"
-#include "libc/stdio/stdio.h"
-
-int main(int argc, char *argv[]) {
-  char buf[256];
-  if (!getdomainname(buf, sizeof(buf))) {
-    printf("%s\n", buf);
-    return 0;
-  } else {
-    return 1;
-  }
-}

examples/getrandom.c

@@ -7,7 +7,6 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "ape/sections.internal.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/errno.h"
@@ -103,7 +102,7 @@ uint64_t rngset64(void) {
   static unsigned i;
   static uint64_t s;
   if (!i) {
-    s = _rand64();
+    s = rand64();
     i = (s + 1) & (511);
   }
   return MarsagliaXorshift64(&s);
@@ -216,7 +215,7 @@ const struct Function {
     {"moby", moby},              //
     {"mt19937", _mt19937},       //
     {"python", pythonx2},        //
-    {"rand64", _rand64},         //
+    {"rand64", rand64},          //
     {"rdrand", rdrand},          //
     {"rdrnd", rdrand},           //
     {"rdseed", rdseed},          //

examples/greenbean.c

@@ -28,6 +28,7 @@
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
+#include "libc/runtime/sysconf.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/pollfd.h"
 #include "libc/sock/struct/sockaddr.h"
@@ -136,7 +137,7 @@ void *Worker(void *id) {
   setsockopt(server, SOL_TCP, TCP_QUICKACK, &yes, sizeof(yes));
   errno = 0;
 
-  if (bind(server, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
+  if (bind(server, &addr, sizeof(addr)) == -1) {
     kprintf("%s() failed %m\n", "socket");
     goto CloseWorker;
   }
@@ -298,7 +299,7 @@ int main(int argc, char *argv[]) {
             PORT);
   }
 
-  threads = argc > 1 ? atoi(argv[1]) : _getcpucount();
+  threads = argc > 1 ? atoi(argv[1]) : GetCpuCount();
   if (!(1 <= threads && threads <= 100000)) {
     kprintf("error: invalid number of threads: %d\n", threads);
     exit(1);

examples/hiredis.c

@@ -1,55 +0,0 @@
-#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/runtime/runtime.h"
-#include "libc/fmt/conv.h"
-#include "libc/fmt/fmt.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
- */
-
-int main(int argc, char *argv[]) {
-  if (argc < 3 || argc > 5) {
-    fprintf(stderr, "Usage: %s HOST PORT [KEY] [VALUE]\n", argv[0]);
-    exit(1);
-  }
-
-  bool setValue = (argc == 5), getValue = (argc == 4);
-
-  redisContext *c = redisConnect(argv[1], atoi(argv[2]));
-  if (c == NULL || c->err) {
-    if (c) {
-      fprintf(stderr, "Connection error: %s\n", c->errstr);
-      redisFree(c);
-    } else {
-      fputs("Failed to allocate redis context\n", stderr);
-    }
-    exit(1);
-  }
-
-  redisReply *reply;
-  if (!setValue && !getValue) {
-    reply = redisCommand(c, "PING");
-    printf("PING: %s\n", reply->str);
-  } else if (setValue) {
-    reply = redisCommand(c, "SET %s %s", argv[3], argv[4]);
-    printf("SET: %s\n", reply->str);
-  } else {
-    reply = redisCommand(c, "GET %s", argv[3]);
-    printf("GET: %s\n", reply->str);
-  }
-
-  freeReplyObject(reply);
-  redisFree(c);
-  return 0;
-}

examples/mu_test.c

@@ -16,17 +16,995 @@
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/weirdtypes.h"
+#include "libc/errno.h"
+#include "libc/fmt/conv.h"
+#include "libc/fmt/fmt.h"
+#include "libc/limits.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/stdio/temp.h"
 #include "libc/str/str.h"
 #include "libc/thread/thread.h"
+#include "third_party/nsync/atomic.internal.h"
 #include "third_party/nsync/cv.h"
+#include "third_party/nsync/dll.h"
 #include "third_party/nsync/mu.h"
 #include "third_party/nsync/mu_wait.h"
-#include "third_party/nsync/testing/closure.h"
-#include "third_party/nsync/testing/smprintf.h"
-#include "third_party/nsync/testing/testing.h"
-#include "third_party/nsync/testing/time_extra.h"
+#include "third_party/nsync/races.internal.h"
+#include "third_party/nsync/time.h"
 // clang-format off
 
+/**
+ * @fileoverview *NSYNC Mutex Tests / Benchmarks.
+ *
+ *     make -j8 o//examples/mu_test.com
+ *     o//examples/mu_test.com -b
+ *
+ */
+
+typedef struct testing_base_s *testing_base;
+typedef const struct testing_base_s *const_testing_base;
+typedef struct testing_s *testing;
+
+/* Return a newly initialized testing_base. */
+testing_base testing_new (int argc, char *argv[], int flags);
+
+/* Return the index of the first argument in argv[] not processed by testing_new() */
+int testing_base_argn (testing_base tb);
+
+/* exit() with the test's exit status */
+int testing_base_exit (testing_base tb);
+
+/* Stop and start the benchmark timer. */
+void testing_stop_timer (testing t);
+void testing_start_timer (testing t);
+
+/* Return whether the machine appears to be a uniprocessor.
+   Some tests get different results on uniprocessors, because
+   the probability of certain interleavings of thread actions is
+   greatly reduced. */
+int testing_is_uniprocessor (testing t);
+
+/* Given a testing_base, run f (t), where t has type testing.
+   Output will be for a test. */
+#define TEST_RUN(tb, f) testing_run_ ((tb), &f, #f, 0)
+
+/* Given a testing_base, run f (t), where t has type testing.
+   Output will be for a benchmark, which should iterate testing_n (t) times. */
+#define BENCHMARK_RUN(tb, f) testing_run_ ((tb), &f, #f, 1)
+
+/* Return the iteration count for a benchmark. */
+int testing_n (testing t);
+
+/* Output nul-terminated string msg[] to stderr, then abort(). */
+void testing_panic (const char *msg);
+
+/* Return a value below 0 if tests should run short, 0 if normal, and a value exceeding
+   0  if tests should run long. */
+int testing_longshort (testing t);
+
+/* Return non-zero if the user requested verbose output. */
+int testing_verbose (testing t);
+
+/* Output a printf-formated log message associated with *t.
+   Example:    TEST_LOG (t, ("wombat %d", some_int));
+   The TEST_ERROR() and TEST_FATAL() forms of the call makr the test as failing.
+   The TEST_FATAL() form causes other subtests not to run.  */
+#define TEST_LOG(t, args) testing_error_ ((t), 0, __FILE__, __LINE__, smprintf args);
+#define TEST_ERROR(t, args) testing_error_ ((t), 1, __FILE__, __LINE__, smprintf args);
+#define TEST_FATAL(t, args) testing_error_ ((t), 2, __FILE__, __LINE__, smprintf args);
+
+/* ---------------------------------------- */
+
+/* internal details follow */
+
+/* An internal routine used by TEST_RUN() and BENCHMARK_RUN(). */
+void testing_run_ (testing_base tb, void (*f) (testing t), const char *name, int is_benchmark);
+
+/* Output an error message msg, and record status. */
+void testing_error_ (testing t, int status, const char *file, int line, char *msg);
+
+////////////////////////////////////////////////////////////////////////////////
+// time_extra.h
+
+/* Return a malloced nul-terminated string representing time t, using
+   "decimals" decimal places.  */
+char *nsync_time_str (nsync_time t, int decimals);
+
+/* Sleep until the specified time.  Returns 0 on success, and EINTR
+   if the call was interrupted. */
+int nsync_time_sleep_until (nsync_time abs_deadline);
+
+/* Return t as a double. */
+double nsync_time_to_dbl (nsync_time t);
+
+/* Return a time corresponding to double d. */
+nsync_time nsync_time_from_dbl (double d);
+
+////////////////////////////////////////////////////////////////////////////////
+// smprintf.h
+
+char *smprintf (const char *fmt, ...);
+
+////////////////////////////////////////////////////////////////////////////////
+// smprintf.c
+
+char *smprintf (const char *fmt, ...) {
+	int m = strlen (fmt) * 2 + 1;
+	char *buf = (char *) malloc (m);
+	int didnt_fit;
+	do {
+		va_list ap;
+		int x;
+		va_start (ap, fmt);
+		x = vsnprintf (buf, m, fmt, ap);
+		va_end (ap);
+		if (x >= m) {
+			buf = (char *) realloc (buf, m = x+1);
+			didnt_fit = 1;
+		} else if (x < 0 || x == m-1) {
+			buf = (char *) realloc (buf, m *= 2);
+			didnt_fit = 1;
+		} else {
+			didnt_fit = 0;
+		}
+	} while (didnt_fit);
+	return (buf);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// time_extra.c
+
+char *nsync_time_str (nsync_time t, int decimals) {
+	static const struct {
+		const char *suffix;
+		double multiplier;
+	} scale[] = {
+		{ "ns", 1.0e-9, },
+		{ "us", 1e-6, },
+		{ "ms", 1e-3, },
+		{ "s", 1.0, },
+		{ "hr", 3600.0, },
+	};
+        double s = nsync_time_to_dbl (t);
+	int i = 0;
+	while (i + 1 != sizeof (scale) / sizeof (scale[0]) && scale[i + 1].multiplier <= s) {
+		i++;
+	}
+	return (smprintf ("%.*f%s", decimals, s/scale[i].multiplier, scale[i].suffix));
+}
+
+int nsync_time_sleep_until (nsync_time abs_deadline) {
+	int result = 0;
+	nsync_time now;
+	now = nsync_time_now ();
+	if (nsync_time_cmp (abs_deadline, now) > 0) {
+		nsync_time remaining;
+		remaining = nsync_time_sleep (nsync_time_sub (abs_deadline, now));
+		if (nsync_time_cmp (remaining, nsync_time_zero) > 0) {
+			result = EINTR;
+		}
+	}
+	return (result);
+}
+
+double nsync_time_to_dbl (nsync_time t) {
+	return (((double) NSYNC_TIME_SEC (t)) + ((double) NSYNC_TIME_NSEC (t) * 1e-9));
+}
+
+nsync_time nsync_time_from_dbl (double d) {
+	time_t s = (time_t) d;
+	if (d < s) {
+		s--;
+	}
+	return (nsync_time_s_ns (s, (unsigned) ((d - (double) s) * 1e9)));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// start_thread.c
+
+struct thd_args {
+	void (*f) (void *);
+	void *arg;
+};
+
+static void *body (void *v) {
+	struct thd_args *args = (struct thd_args *) v;
+	(*args->f) (args->arg);
+	free (args);
+	return (NULL);
+}
+
+void nsync_start_thread_ (void (*f) (void *), void *arg) {
+	struct thd_args *args = (struct thd_args *) malloc (sizeof (*args));
+	pthread_t t;
+	args->f = f;
+	args->arg = arg;
+	pthread_create (&t, NULL, body, args);
+	pthread_detach (t);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// closure.h
+
+/* A run-once, self-freeing closure. */
+typedef struct closure_s {
+	void (*f0) (void *);
+} closure;
+
+/* Run the closure *cl, and free it. */
+void closure_run (closure *cl);
+
+/* Fork a new thread running the closure *cl, which will be freed when the
+   thread exits.  */
+void closure_fork (closure *cl);
+
+/* To create a closure, declare a closure constructor with the right function arguments.
+
+   For functions taking no arguments, use
+	CLOSURE_DECL_BODY0 (foo)
+   to generate the static routine:
+	static closure *closure_foo (void (*f) (void));
+   that will return a closure for any function *f that takes no argument.
+
+   For an 1-argument function, use
+	CLOSURE_DECL_BODY1 (foo, type)
+   to generate the static routine:
+	static closure *closure_foo (void (*f) (type), type x);
+   that will return a closure for any function taking a single argument of the
+   specified type.
+
+   For an 2-argument function, use
+	CLOSURE_DECL_BODY2 (foo, type0, type1)
+   to generate the static routine:
+	static closure *closure_foo (void (*f) (type0, type1), type0 x0, type1 x1);
+   that will return a closure for any function taking a "type0" argument, and
+   a "type1" argument.
+
+   And so on, up to 9 arguments.
+
+   For example, to make closures out of qsort():
+
+	// First, just once (per module) define:
+	//      static closure *closure_qsort_args (
+	//              void (*f) (void *, size_t, size_t, int (*)(const void *, const void *))
+	//              void *x0, size_t x1, size_t x2, int (*x3)(const void *, const void *));
+	// by writing:
+	CLOSURE_DECL_BODY4 (qsort_args, void *, size_t, size_t, int (*)(const void *, const void *))
+
+	// Second, for each closure to be created, write something like this:
+	closure *cl = closure_qsort_args (array, n_elements, sizeof (array[0]), &elem_cmp);
+
+	// Then to run (and free) each closure:
+	closure_run (cl);
+	// This is like calling
+	//      qsort (array, n_elements, sizeof (array[0]), &elem_cmp);
+	//      free (cl);
+ */
+
+
+
+
+/* ------------------------------------------------------------------ */
+/* Internal macro details follow. */
+#define CLOSURE_S0(x,e) e
+#define CLOSURE_S1(x,e) x##0
+#define CLOSURE_S2(x,e) x##0, x##1
+#define CLOSURE_S3(x,e) x##0, x##1, x##2
+#define CLOSURE_S4(x,e) x##0, x##1, x##2, x##3
+#define CLOSURE_S5(x,e) x##0, x##1, x##2, x##3, x##4
+#define CLOSURE_S6(x,e) x##0, x##1, x##2, x##3, x##4, x##5
+#define CLOSURE_S7(x,e) x##0, x##1, x##2, x##3, x##4, x##5, x##6
+#define CLOSURE_S8(x,e) x##0, x##1, x##2, x##3, x##4, x##5, x##6, x##7
+#define CLOSURE_S9(x,e) x##0, x##1, x##2, x##3, x##4, x##5, x##6, x##7, x##8
+
+#define CLOSURE_P0(x,y,p,s,t)
+#define CLOSURE_P1(x,y,p,s,t) p x##0 y##0 t
+#define CLOSURE_P2(x,y,p,s,t) p x##0 y##0 s x##1 y##1 t
+#define CLOSURE_P3(x,y,p,s,t) p x##0 y##0 s x##1 y##1 s x##2 y##2 t
+#define CLOSURE_P4(x,y,p,s,t) p x##0 y##0 s x##1 y##1 s x##2 y##2 s x##3 y##3 t
+#define CLOSURE_P5(x,y,p,s,t) p x##0 y##0 s x##1 y##1 s x##2 y##2 s x##3 y##3 s x##4 y##4 t
+#define CLOSURE_P6(x,y,p,s,t) p x##0 y##0 s x##1 y##1 s x##2 y##2 s x##3 y##3 s x##4 y##4 s \
+				x##5 y##5 t
+#define CLOSURE_P7(x,y,p,s,t) p x##0 y##0 s x##1 y##1 s x##2 y##2 s x##3 y##3 s x##4 y##4 s \
+				x##5 y##5 s x##6 y##6 t
+#define CLOSURE_P8(x,y,p,s,t) p x##0 y##0 s x##1 y##1 s x##2 y##2 s x##3 y##3 s x##4 y##4 s \
+				x##5 y##5 s x##6 y##6 s x##7 y##7 t
+#define CLOSURE_P9(x,y,p,s,t) p x##0 y##0 s x##1 y##1 s x##2 y##2 s x##3 y##3 s x##4 y##4 s \
+				x##5 y##5 s x##6 y##6 s x##7 y##7 s x##8 y##8 t
+
+#define CLOSURE_COMMA_ ,
+#define CLOSURE_SEMI_ ;
+#define CLOSURE_BLANK_
+
+#define CLOSURE_DECL_BODY_N_(name, n) \
+	struct closure_s_##name { \
+		void (*f0) (void *); /* must be first; matches closure. */ \
+		void (*f) (CLOSURE_S##n (closure_t_##name##_,void)); \
+		CLOSURE_P##n (closure_t_##name##_, a, CLOSURE_BLANK_, \
+			      CLOSURE_SEMI_, CLOSURE_SEMI_) \
+	}; \
+	static void closure_f0_##name (void *v) { \
+		struct closure_s_##name *a = (struct closure_s_##name *) v; \
+		(*a->f) (CLOSURE_S##n (a->a,CLOSURE_BLANK_)); \
+		free (a); \
+	} \
+	static closure *closure_##name (void (*f) (CLOSURE_S##n (closure_t_##name##_,void)) \
+					CLOSURE_P##n (closure_t_##name##_, a, CLOSURE_COMMA_, \
+					CLOSURE_COMMA_, CLOSURE_BLANK_)) { \
+		struct closure_s_##name *cl = (struct closure_s_##name *) malloc (sizeof (*cl)); \
+		cl->f0 = &closure_f0_##name; \
+		cl->f = f; \
+		CLOSURE_P##n (cl->a, = a, CLOSURE_BLANK_, CLOSURE_SEMI_, CLOSURE_SEMI_) \
+		return ((closure *) cl); \
+	}
+
+
+#define CLOSURE_DECL_BODY0(name) \
+	CLOSURE_DECL_BODY_N_ (name, 0)
+#define CLOSURE_DECL_BODY1(name, t0) \
+	typedef t0 closure_t_##name##_0; \
+	CLOSURE_DECL_BODY_N_ (name, 1)
+#define CLOSURE_DECL_BODY2(name, t0, t1) \
+	typedef t0 closure_t_##name##_0; \
+	typedef t1 closure_t_##name##_1; \
+	CLOSURE_DECL_BODY_N_ (name, 2)
+#define CLOSURE_DECL_BODY3(name, t0, t1, t2) \
+	typedef t0 closure_t_##name##_0; \
+	typedef t1 closure_t_##name##_1; \
+	typedef t2 closure_t_##name##_2; \
+	CLOSURE_DECL_BODY_N_ (name, 3)
+#define CLOSURE_DECL_BODY4(name, t0, t1, t2, t3) \
+	typedef t0 closure_t_##name##_0; \
+	typedef t1 closure_t_##name##_1; \
+	typedef t2 closure_t_##name##_2; \
+	typedef t3 closure_t_##name##_3; \
+	CLOSURE_DECL_BODY_N_ (name, 4)
+#define CLOSURE_DECL_BODY5(name, t0, t1, t2, t3, t4) \
+	typedef t0 closure_t_##name##_0; \
+	typedef t1 closure_t_##name##_1; \
+	typedef t2 closure_t_##name##_2; \
+	typedef t3 closure_t_##name##_3; \
+	typedef t4 closure_t_##name##_4; \
+	CLOSURE_DECL_BODY_N_ (name, 5)
+#define CLOSURE_DECL_BODY6(name, t0, t1, t2, t3, t4, t5) \
+	typedef t0 closure_t_##name##_0; \
+	typedef t1 closure_t_##name##_1; \
+	typedef t2 closure_t_##name##_2; \
+	typedef t3 closure_t_##name##_3; \
+	typedef t4 closure_t_##name##_4; \
+	typedef t5 closure_t_##name##_5; \
+	CLOSURE_DECL_BODY_N_ (name, 6)
+#define CLOSURE_DECL_BODY7(name, t0, t1, t2, t3, t4, t5, t6) \
+	typedef t0 closure_t_##name##_0; \
+	typedef t1 closure_t_##name##_1; \
+	typedef t2 closure_t_##name##_2; \
+	typedef t3 closure_t_##name##_3; \
+	typedef t4 closure_t_##name##_4; \
+	typedef t5 closure_t_##name##_5; \
+	typedef t6 closure_t_##name##_6; \
+	CLOSURE_DECL_BODY_N_ (name, 7)
+#define CLOSURE_DECL_BODY8(name, t0, t1, t2, t3, t4, t5, t6, t7) \
+	typedef t0 closure_t_##name##_0; \
+	typedef t1 closure_t_##name##_1; \
+	typedef t2 closure_t_##name##_2; \
+	typedef t3 closure_t_##name##_3; \
+	typedef t4 closure_t_##name##_4; \
+	typedef t5 closure_t_##name##_5; \
+	typedef t6 closure_t_##name##_6; \
+	typedef t7 closure_t_##name##_7; \
+	CLOSURE_DECL_BODY_N_ (name, 8)
+#define CLOSURE_DECL_BODY9(name, t0, t1, t2, t3, t4, t5, t6, t7, t8) \
+	typedef t0 closure_t_##name##_0; \
+	typedef t1 closure_t_##name##_1; \
+	typedef t2 closure_t_##name##_2; \
+	typedef t3 closure_t_##name##_3; \
+	typedef t4 closure_t_##name##_4; \
+	typedef t5 closure_t_##name##_5; \
+	typedef t6 closure_t_##name##_6; \
+	typedef t7 closure_t_##name##_7; \
+	typedef t8 closure_t_##name##_8; \
+	CLOSURE_DECL_BODY_N_ (name, 9)
+
+////////////////////////////////////////////////////////////////////////////////
+// closure.c
+
+void nsync_start_thread_ (void (*f) (void *), void *arg);
+
+/* Run the closure *cl. */
+void closure_run (closure *cl) {
+	(*cl->f0) (cl);
+}
+
+/* Run the closure (closure *), but wrapped to fix the type. */
+static void closure_run_body (void *v) {
+	closure_run ((closure *)v);
+}
+
+void closure_fork (closure *cl) {
+	nsync_start_thread_ (&closure_run_body, cl);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// atm_log.h
+
+void nsync_atm_log_ (int c, void *p, uint32_t o, uint32_t n, const char *file, int line);
+void nsync_atm_log_print_ (void);
+
+////////////////////////////////////////////////////////////////////////////////
+// atm_log.c
+
+#ifndef NSYNC_ATM_LOG
+#define NSYNC_ATM_LOG 0
+#endif
+
+struct atm_log {
+	uintptr_t i;
+	uintptr_t thd_id;
+	uintptr_t c;
+	void *p;
+	uintptr_t o;
+	uintptr_t n;
+	const char *file;
+	uintptr_t line;
+};
+
+#define LOG_N 14
+
+static struct atm_log log_entries[1 << LOG_N];
+static uint32_t log_i;
+
+static pthread_mutex_t log_mu;
+
+static pthread_key_t key;
+static pthread_once_t once = PTHREAD_ONCE_INIT;
+static void do_once (void) {
+	pthread_mutex_init (&log_mu, NULL);
+	pthread_key_create (&key, NULL);
+}
+static int thread_id;
+
+void nsync_atm_log_ (int c, void *p, uint32_t o, uint32_t n, const char *file, int line) {
+	if (NSYNC_ATM_LOG) {
+		struct atm_log *e;
+		uint32_t i;
+		int *pthd_id;
+		int thd_id;
+
+		pthread_once (&once, &do_once);
+		pthd_id = (int *) pthread_getspecific (key);
+
+		pthread_mutex_lock (&log_mu);
+		i = log_i++;
+		if (pthd_id == NULL) {
+			thd_id = thread_id++;
+			pthd_id = (int *) malloc (sizeof (*pthd_id));
+			pthread_setspecific (key, pthd_id);
+			*pthd_id = thd_id;
+		} else {
+			thd_id = *pthd_id;
+		}
+		pthread_mutex_unlock (&log_mu);
+
+		e = &log_entries[i & ((1 << LOG_N) - 1)];
+		e->i = i;
+		e->thd_id = thd_id;
+		e->c = c;
+		e->p = p;
+		e->o = o;
+		e->n = n;
+		e->file = file;
+		e->line = line;
+	}
+}
+
+void nsync_atm_log_print_ (void) {
+	if (NSYNC_ATM_LOG) {
+		uint32_t i;
+		pthread_once (&once, &do_once);
+		pthread_mutex_lock (&log_mu);
+		for (i = 0; i != (1 << LOG_N); i++) {
+			struct atm_log *e = &log_entries[i];
+			if (e->file != 0) {
+				fprintf (stderr, "%6lx %3d %c  p %16p  o %8x  n %8x  %10s:%d\n",
+					(unsigned long) e->i,
+					(int) e->thd_id,
+					e->c <= ' '? '?' : (char)e->c,
+					e->p,
+					(uint32_t) e->o,
+					(uint32_t) e->n,
+					e->file,
+					(int) e->line);
+			}
+		}
+		pthread_mutex_unlock (&log_mu);
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// testing.c
+
+struct testing_base_s {
+	int flags;		/* flags from testing_new(); r/o after init */
+	int parallelism;	/* max parallelism to use; r/o after init */
+	FILE *fp;		/* where to send output; pointer is r/o after init */
+	int argn;		/* first arg not processed by testing_new(); r/o after init */
+	int argc;		/* argc passed to testing_new(); r/o after init */
+	char **argv;		/* argv passed to testing_new(); r/o after init */
+	char *prog;		/* name of programme, from argv[0] */
+	int suppress_header;    /* supress hreader on benchmarks */
+	int run_tests;		/* whether to run tests */
+	int run_benchmarks;     /* whether to run benchmarks */
+	int benchmarks_running; /* and benchmarks are now running */
+	char *include_pat;      /* ,- or |-separated substrings of tests to include */
+	char *exclude_pat;      /* ,- or |-separated substrings of tests to exclude */
+	int longshort;		/* 0 normal, -1 short, 1 long */
+	int verbose;		/* 0 normal; 1 verbose output */
+
+	nsync_mu testing_mu;      /* protects fields below */
+	int is_uniprocessor;      /* whether the system is a uniprocessor */
+	nsync_dll_list_ children; /* list of testing_s structs whose base is this testing_base_s */
+	int child_count;	  /* count of testing_s structs whose base is this testing_base_s */
+	int exit_status;	  /* final exit status */
+};
+
+struct testing_s {
+	struct testing_base_s *base;       /* r/o after init */
+	int test_status;		   /* status; merged into common->exit_status */
+	int n;				   /* benchmark iteration count */
+	nsync_atomic_uint32_ partial_line; /* whether partial test banner emitted last*/
+	FILE *fp;			   /* where to output; merged into common->fp if != to it */
+	nsync_time start_time;	/* timer start time; for benchmarks */
+	nsync_time stop_time;	 /* when the timer was stopped; for benchmarks */
+	void (*f) (testing);		   /* test function to run */
+	const char *name;		   /* name of test */
+	nsync_dll_element_ siblings;       /* part of list of siblings */
+};
+
+/* Output the header for benchmarks. */
+static void output_header (FILE *fp, const char *prog) {
+	int i;
+	int hdrlen = fprintf (fp, "%-10s%-40s %9s %8s  %8s %8s\n", "Benchmark", prog, "ops", "time",
+			      "ops/sec", "time/op");
+	for (i = 1; i < hdrlen; i++) {
+		putc ('-', fp);
+	}
+	putc ('\n', fp);
+	fflush (fp);
+}
+
+/* Process a single flag.  *pargn is main's argn */
+static void process_flag (testing_base tb, int *pargn, int argc, char *argv[], int flag,
+			  const char *arg) {
+	switch (flag) {
+	case 'b':
+		tb->run_benchmarks = 1;
+		break;
+	case 'B':
+		tb->run_benchmarks = 1;
+		tb->run_tests = 0;
+		break;
+	case 'H':
+		output_header (stdout, "");
+		exit (0);
+	case 'h':
+		tb->suppress_header = 1;
+		break;
+	case 'l':
+		tb->longshort++;
+		break;
+	case 'm':
+		if (*pargn + 1 == argc) {
+			fprintf (stderr, "%s: -m flag expects ,- or |-separated strings\n",
+				 argv[0]);
+			exit (2);
+		}
+		tb->include_pat = argv[++*pargn];
+		break;
+	case 'n':
+		if (*pargn + 1 == argc || atoi (argv[1 + *pargn]) < 1) {
+			fprintf (stderr, "%s: -n flag expects parallelism value >= 1\n", argv[0]);
+			exit (2);
+		}
+		tb->parallelism = atoi (argv[++*pargn]);
+		break;
+	case 's':
+		tb->longshort--;
+		break;
+	case 'v':
+		tb->verbose = 1;
+		break;
+	case 'x':
+		if (*pargn + 1 == argc) {
+			fprintf (stderr, "%s: -x flag expects ,- or |-separated strings\n",
+				 argv[0]);
+			exit (2);
+		}
+		tb->exclude_pat = argv[++*pargn];
+		break;
+	default:
+		fprintf (stderr, "%s: unrecognized flag '%c' in arg %d: \"%s\"\n", argv[0], flag,
+			 *pargn, arg);
+		exit (2);
+	}
+}
+
+testing_base testing_new (int argc, char *argv[], int flags) {
+	static const char sep[] = { '/', '\\' };
+	int i;
+	int argn;
+	testing_base tb = (testing_base)malloc (sizeof (*tb));
+	memset ((void *) tb, 0, sizeof (*tb));
+	tb->flags = flags;
+	tb->fp = stderr;
+	tb->argc = argc;
+	tb->argv = argv;
+	tb->parallelism = 1;
+	tb->run_tests = 1;
+	tb->is_uniprocessor = -1;
+	tb->prog = tb->argv[0];
+	for (i = 0; i != sizeof (sep) / sizeof (sep[0]); i++) {
+		char *last = strrchr (tb->prog, sep[i]);
+		if (last != NULL) {
+			tb->prog = last + 1;
+		}
+	}
+	for (argn = 1; argn != argc && argv[argn][0] == '-' &&
+		       strcmp (argv[argn], "--") != 0; argn++) {
+		const char *arg = argv[argn];
+		const char *f;
+		for (f = &arg[1]; *f != 0; f++) {
+			process_flag (tb, &argn, argc, argv, *f, arg);
+		}
+	}
+	tb->argn = argn + (argn != argc && strcmp (argv[argn], "--") == 0);
+	return (tb);
+}
+
+int testing_verbose (testing t) {
+	return (t->base->verbose);
+}
+
+int testing_longshort (testing t) {
+	return (t->base->longshort);
+}
+
+int testing_n (testing t) {
+	return (t->n);
+}
+
+int testing_base_argn (testing_base tb) {
+	return (tb->argn);
+}
+
+/* Return whether *(int *)v is zero.  Used with nsync_mu_wait().  */
+static int int_is_zero (const void *v) {
+	return (*(const int *)v == 0);
+}
+
+int testing_base_exit (testing_base tb) {
+	int exit_status;
+	nsync_mu_lock (&tb->testing_mu);
+	nsync_mu_wait (&tb->testing_mu, &int_is_zero, &tb->child_count, NULL);
+	exit_status = tb->exit_status;
+	nsync_mu_unlock (&tb->testing_mu);
+	free (tb);
+	exit (exit_status);
+	return (exit_status);
+}
+
+/* Cleanup code used after running either a test or a benchmark,
+   called at the end of run_test() and run_benchmark(). */
+static void finish_run (testing t) {
+	testing_base tb = t->base;
+	fflush (t->fp);
+	nsync_mu_lock (&tb->testing_mu);
+	if (t->fp != tb->fp) {
+		int c;
+		rewind (t->fp);
+		while ((c = getc (t->fp)) != EOF) {
+			putc (c, tb->fp);
+		}
+		fclose (t->fp);
+		fflush (tb->fp);
+	}
+	if (tb->exit_status < t->test_status) {
+		tb->exit_status = t->test_status;
+	}
+	tb->children = nsync_dll_remove_ (tb->children, &t->siblings);
+	tb->child_count--;
+	nsync_mu_unlock (&tb->testing_mu);
+	free (t);
+}
+
+/* Run the test (*t->f)(t), and report on t->fp how long it took and its final
+   status, which is set to non-zero if the test reported errors.  */
+static void run_test (testing t) {
+	testing_base tb = t->base;
+	char *elapsed_str = 0;
+	fprintf (t->fp, "%-25s %-45s  ", tb->prog, t->name);
+	fflush (t->fp);
+	ATM_STORE (&t->partial_line, 1);
+	t->test_status = 0;
+	t->n = 0;
+	t->stop_time = nsync_time_zero;
+	t->start_time = nsync_time_now ();
+	(*t->f) (t);
+	elapsed_str = nsync_time_str (nsync_time_sub (nsync_time_now (), t->start_time), 2);
+	if (!ATM_LOAD (&t->partial_line)) {
+		fprintf (t->fp, "%-25s %-45s  %s %8s\n", tb->prog, t->name,
+		         t->test_status != 0? "failed": "passed", elapsed_str);
+	} else {
+		fprintf (t->fp, "%s %8s\n", t->test_status != 0? "failed": "passed", elapsed_str);
+	}
+	ATM_STORE (&t->partial_line, 0);
+	fflush (t->fp);
+	free (elapsed_str);
+	finish_run (t);
+}
+
+/* Run the benchmark (*t->f)(t) repeatedly, specifying successively greater
+   numbers of iterations, measuring how long it takes each time.  Eventually,
+   it takes long enough to get a reasonable estimate of how long each iteration
+   takes, which is reported on t->fp.  */
+static void run_benchmark (testing t) {
+	char *elapsed_str = 0;
+	char *time_per_op_str = 0;
+	double elapsed;
+	int n = 1;
+	double target = 2.0;
+	int longshort = testing_longshort (t);
+	if (longshort < 0) {
+		target = 1e-3 * (2000 >> -longshort);
+	} else if (longshort > 0) {
+		target = 1e-3 * (2000 << longshort);
+	}
+	do {
+		int32_t mul;
+		t->test_status = 0;
+		t->n = n;
+		t->stop_time = nsync_time_zero;
+		t->start_time = nsync_time_now ();
+		(*t->f) (t);
+		elapsed = nsync_time_to_dbl (nsync_time_sub (nsync_time_now (), t->start_time));
+		if (elapsed < 1e-1) {
+			elapsed = 1e-1;
+		}
+		mul = (int32_t) (target / elapsed);
+		while (elapsed * mul * 4 < target * 5) {
+			mul++;
+		}
+		if (mul > 1 && elapsed * mul * 2 < target * 3 && n < INT_MAX / mul) {
+			n *= mul;
+		} else if (n < INT_MAX / 2) {
+			n *= 2;
+		}
+	} while (t->test_status == 0 && elapsed < target && n != t->n);
+	elapsed_str = nsync_time_str (nsync_time_from_dbl (elapsed), 2);
+	time_per_op_str = nsync_time_str (nsync_time_from_dbl (elapsed / t->n), 2);
+	fprintf (t->fp, "%-50s %9d %8s  %8.2g %8s%s\n", t->name, t->n, elapsed_str,
+		 ((double)t->n) / elapsed, time_per_op_str,
+		 t->test_status != 0 ? "  *** failed ***" : "");
+	free (elapsed_str);
+	free (time_per_op_str);
+	finish_run (t);
+}
+
+CLOSURE_DECL_BODY1 (testing, testing)
+
+/* Return whether there's a "spare thread"; that is, whether the current count
+   of child threads is less than the allowed parallelism.  */
+static int spare_thread (const void *v) {
+	const_testing_base tb = (const_testing_base) v;
+	return (tb->child_count < tb->parallelism);
+}
+
+/* Return whether nul-terminated string str[] contains a string listed in
+   comma-separated (or vertical bar-separted) strings in nul-terminated string
+   pat[].  A dollar at the end of a string in pat[] matches the end of
+   string in str[]. */
+static int match (const char *pat, const char *str) {
+	static const char seps[] = ",|";
+	int found = 0;
+	char Xbuf[128];
+	int m = sizeof (Xbuf) - 1;
+	char *mbuf = NULL;
+	char *buf = Xbuf;
+	int i = 0;
+	while (!found && pat[i] != '\0') {
+		int blen = strcspn (&pat[i], seps);
+		int e = i + blen;
+		if (blen > m) {
+			m = blen + 128;
+			buf = mbuf = (char *) realloc (mbuf, m + 1);
+		}
+		memcpy (buf, &pat[i], blen);
+		buf[blen] = '\0';
+		if (blen > 0 && buf[blen - 1] == '$') {
+			int slen = strlen (str);
+			buf[--blen] = 0;
+			found = (slen >= blen &&
+				 strcmp (&str[slen-blen], buf) == 0);
+		} else {
+			found = (strstr (str, buf) != NULL);
+		}
+		i = e + strspn (&pat[e], seps);
+	}
+	free (mbuf);
+	return (found);
+}
+
+void testing_run_ (testing_base tb, void (*f) (testing t), const char *name, int is_benchmark) {
+	int exit_status;
+	nsync_mu_lock (&tb->testing_mu);
+	exit_status = tb->exit_status;
+	nsync_mu_unlock (&tb->testing_mu);
+	if (exit_status < 2 &&
+	    (!is_benchmark || tb->run_benchmarks) &&
+	    (is_benchmark || tb->run_tests) &&
+	    (tb->include_pat == NULL || match (tb->include_pat, name)) &&
+	    (tb->exclude_pat == NULL || !match (tb->exclude_pat, name))) {
+		testing t = (testing) malloc (sizeof (*t));
+		memset ((void *) t, 0, sizeof (*t));
+		nsync_dll_init_ (&t->siblings, t);
+		t->base = tb;
+		t->f = f;
+		t->name = name;
+		if (tb->parallelism == 1) {
+			t->fp = tb->fp;
+		} else {
+			t->fp = tmpfile ();
+		}
+		if (!is_benchmark) {
+			if (tb->benchmarks_running) {
+				nsync_mu_lock (&tb->testing_mu);
+				nsync_mu_wait (&tb->testing_mu, &int_is_zero, &tb->child_count, NULL);
+				nsync_mu_unlock (&tb->testing_mu);
+				tb->benchmarks_running = 0;
+			}
+			nsync_mu_lock (&tb->testing_mu);
+			nsync_mu_wait (&tb->testing_mu, &spare_thread, tb, NULL);
+			tb->child_count++;
+			tb->children = nsync_dll_make_last_in_list_ (tb->children, &t->siblings);
+			nsync_mu_unlock (&tb->testing_mu);
+			closure_fork (closure_testing (&run_test, t));
+		} else {
+			if (!tb->benchmarks_running) {
+				nsync_mu_lock (&tb->testing_mu);
+				nsync_mu_wait (&tb->testing_mu, &int_is_zero, &tb->child_count, NULL);
+				nsync_mu_unlock (&tb->testing_mu);
+				if (!tb->suppress_header) {
+					output_header (tb->fp, tb->prog);
+				}
+				tb->benchmarks_running = 1;
+			}
+			nsync_mu_lock (&tb->testing_mu);
+			nsync_mu_wait (&tb->testing_mu, &spare_thread, tb, NULL);
+			tb->child_count++;
+			tb->children = nsync_dll_make_last_in_list_ (tb->children, &t->siblings);
+			nsync_mu_unlock (&tb->testing_mu);
+			closure_fork (closure_testing (&run_benchmark, t));
+		}
+	}
+}
+
+/* Used to decide whether the test is running on a uniprocessor. */
+struct is_uniprocessor_s {
+	double count;		   /* count of iterations while *state==1 */
+	nsync_atomic_uint32_ done; /* set to 1 when thread finishes */
+	char dummy[256];	   /* so structs don't share cache line */
+};
+
+/* An anciliary thread that waits until *state is 1, then increments s->count
+   while *state stays 1, and then sets s->done to 1 before exiting.  */
+static void uniprocessor_check (nsync_atomic_uint32_ *state, struct is_uniprocessor_s *s) {
+	IGNORE_RACES_START ();
+	while (ATM_LOAD_ACQ (state) != 1) {
+	}
+	while (ATM_LOAD_ACQ (state) == 1) {
+		s->count++;
+	}
+	ATM_STORE_REL (&s->done, 1);
+	IGNORE_RACES_END ();
+}
+
+CLOSURE_DECL_BODY2 (uniprocessor_check, nsync_atomic_uint32_ *, struct is_uniprocessor_s *)
+
+/* Return whether the test is running on a uniprocessor.
+
+   Some of the tests rely on interleaving of actions between threads.
+   Particular interleavings are much less likely on uniprocessors, so the tests
+   do not run, or do not declare an error if the system is a uniprocessor.
+
+   Operating systems vary significantly in how one may ask how many procerssors
+   are present, so we use a heuristic based on comparing the timing of a single
+   thread, and two concurrent threads.  */
+int testing_is_uniprocessor (testing t) {
+	int is_uniprocessor;
+	nsync_mu_lock (&t->base->testing_mu);
+	is_uniprocessor = t->base->is_uniprocessor;
+	if (is_uniprocessor == -1) {
+		int i;
+		struct is_uniprocessor_s s[3];
+		nsync_atomic_uint32_ state;
+		for (i = 0; i != 3; i++) {
+			s[i].count = 0.0;
+			s[i].done = 0;
+		}
+
+		ATM_STORE_REL (&state, 0);
+		closure_fork (closure_uniprocessor_check (&uniprocessor_check, &state, &s[0]));
+		nsync_time_sleep (nsync_time_ms (100));
+		ATM_STORE_REL (&state, 1);
+		nsync_time_sleep (nsync_time_ms (400));
+		ATM_STORE_REL (&state, 2);
+		while (!ATM_LOAD_ACQ (&s[0].done)) {
+		}
+
+		ATM_STORE_REL (&state, 0);
+		closure_fork (closure_uniprocessor_check (&uniprocessor_check, &state, &s[1]));
+		closure_fork (closure_uniprocessor_check (&uniprocessor_check, &state, &s[2]));
+		nsync_time_sleep (nsync_time_ms (100));
+		ATM_STORE_REL (&state, 1);
+		nsync_time_sleep (nsync_time_ms (400));
+		ATM_STORE_REL (&state, 2);
+		while (!ATM_LOAD_ACQ (&s[1].done) || !ATM_LOAD_ACQ (&s[2].done)) {
+		}
+                t->base->is_uniprocessor = ((s[1].count + s[2].count) / s[0].count) < 1.7;
+		is_uniprocessor = t->base->is_uniprocessor;
+	}
+	nsync_mu_unlock (&t->base->testing_mu);
+	return (is_uniprocessor);
+}
+
+void testing_stop_timer (testing t) {
+	if (nsync_time_cmp (t->stop_time, nsync_time_zero) != 0) {
+		abort ();
+	}
+	t->stop_time = nsync_time_now ();
+}
+
+void testing_start_timer (testing t) {
+	if (nsync_time_cmp (t->stop_time, nsync_time_zero) == 0) {
+		abort ();
+	}
+	t->start_time = nsync_time_add (t->start_time,
+		nsync_time_sub (nsync_time_now (), t->stop_time));
+	t->stop_time = nsync_time_zero;
+}
+
+void testing_error_ (testing t, int test_status, const char *file, int line, char *msg) {
+	int len = strlen (msg);
+	int addnl = (len == 0 || msg[len - 1] != '\n');
+	if (t->test_status < test_status) {
+		t->test_status = test_status;
+	}
+	if (ATM_LOAD (&t->partial_line)) {
+		ATM_STORE (&t->partial_line, 0);
+		fprintf (t->fp, "\n%s: %s:%d: %s%s",
+		         test_status == 2? "fatal": test_status == 1? "error": "info", file, line, msg,
+		         addnl? "\n": "");
+	} else {
+		fprintf (t->fp, "%s: %s:%d: %s%s",
+		         test_status == 2? "fatal": test_status == 1? "error": "info", file, line, msg,
+		         addnl? "\n": "");
+	}
+	free (msg);
+}
+
+void nsync_panic_(const char *);
+
+/* Abort after printing the nul-terminated string s[]. */
+void testing_panic (const char *s) {
+	nsync_atm_log_print_ ();
+	nsync_panic_ (s);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// mu_test.c
+
 /* The state shared between the threads in each of the tests below. */
 typedef struct test_data_s {
 	testing t;

examples/nanosleep_test.c

@@ -1,43 +0,0 @@
-#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/assert.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/stdio/stdio.h"
-#include "libc/sysv/consts/clock.h"
-
-/**
- * @fileoverview shows how accurate clock_nanosleep() is
- */
-
-int main(int argc, char *argv[]) {
-  long i, ns;
-  struct timespec x, y, w;
-  timespec_sleep(timespec_fromnanos(0));  // warmup
-
-  printf("\nrelative sleep\n");
-  for (i = 0; i < 28; ++i) {
-    ns = 1l << i;
-    x = timespec_real();
-    timespec_sleep(timespec_fromnanos(ns));
-    y = timespec_real();
-    printf("%,11ld ns sleep took %,ld ns\n", ns,
-           timespec_tonanos(timespec_sub(y, x)));
-  }
-
-  printf("\nabsolute sleep\n");
-  for (i = 0; i < 28; ++i) {
-    ns = 1l << i;
-    x = timespec_real();
-    timespec_sleep_until(timespec_add(x, timespec_fromnanos(ns)));
-    y = timespec_real();
-    printf("%,11ld ns sleep took %,ld ns\n", ns,
-           timespec_tonanos(timespec_sub(y, x)));
-  }
-}

examples/nesemu1.cc

@@ -47,7 +47,7 @@
 #include "third_party/libcxx/vector"
 #include "tool/viz/lib/knobs.h"
 
-STATIC_YOINK("zipos");
+STATIC_YOINK("zip_uri_support");
 
 #define USAGE \
   " [ROM] [FMV]\n\

examples/nomodifyself.c

@@ -7,7 +7,6 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "ape/sections.internal.h"
 #include "libc/dce.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"

examples/portscan.c

@@ -1,127 +0,0 @@
-#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/assert.h"
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/timeval.h"
-#include "libc/errno.h"
-#include "libc/fmt/conv.h"
-#include "libc/fmt/fmt.h"
-#include "libc/mem/alloca.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sock/sock.h"
-#include "libc/sock/struct/sockaddr.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/af.h"
-#include "libc/sysv/consts/ipproto.h"
-#include "libc/sysv/consts/so.h"
-#include "libc/sysv/consts/sock.h"
-#include "libc/sysv/consts/sol.h"
-#include "net/http/ip.h"
-
-/**
- * @fileoverview fast local network port scanner, e.g.
- *
- *     make -j8 o//examples/portscan.com
- *     o//examples/portscan.com 10.10.10.0/24 22
- */
-
-const char *FormatIp(char buf[16], uint32_t ip) {
-  snprintf(buf, 16, "%hhu.%hhu.%hhu.%hhu", ip >> 24, ip >> 16, ip >> 8, ip);
-  return buf;
-}
-
-#define FormatIp(x) FormatIp(alloca(16), x)
-
-int main(int argc, char *argv[]) {
-  int port;
-  struct Cidr in;
-  uint32_t netmask;
-  const char *status;
-  struct timeval timeout;
-  uint32_t network_address;
-  uint32_t last_host_address;
-  uint32_t first_host_address;
-
-  if (argc != 3) {
-  PrintUsage:
-    fprintf(stderr,
-            "usage:   %s IP/CIDR PORT\n"
-            "example: %s 192.168.0.0/24 22\n",
-            argv[0], argv[0]);
-    return 1;
-  }
-
-  in = ParseCidr(argv[1], -1);
-  if (in.addr == -1) {
-    fprintf(stderr, "error: bad ip/cidr\n");
-    goto PrintUsage;
-  }
-
-  port = atoi(argv[2]);
-  if (!(1 <= port && port <= 65535)) {
-    fprintf(stderr, "error: bad port\n");
-    goto PrintUsage;
-  }
-
-  if (in.cidr > 30) {
-    fprintf(stderr, "error: maximum supported cidr is 30\n");
-    goto PrintUsage;
-  }
-
-  if (in.cidr < 22) {
-    fprintf(stderr, "error: minimum cidr support right now is 22\n");
-    goto PrintUsage;
-  }
-
-  netmask = -1u << (32 - in.cidr);
-  network_address = in.addr & netmask;
-  first_host_address = network_address + 1;
-  last_host_address = (network_address | ~netmask) - 1;
-
-  assert(last_host_address > first_host_address);
-  assert(last_host_address - first_host_address < 1024);
-
-  fprintf(stderr, "scanning %s through %s\n", FormatIp(first_host_address),
-          FormatIp(last_host_address));
-
-  timeout = timeval_frommillis(100);
-  for (int64_t ip = first_host_address; ip <= last_host_address; ++ip) {
-    if (!fork()) {
-      socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-      setsockopt(3, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
-      setsockopt(3, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
-      if (!connect(3,
-                   (struct sockaddr *)&(struct sockaddr_in){
-                       .sin_family = AF_INET,
-                       .sin_addr.s_addr = htonl(ip),
-                       .sin_port = htons(port),
-                   },
-                   sizeof(struct sockaddr_in))) {
-        status = "open";
-      } else if (errno == ECONNREFUSED) {
-        status = "closed";
-      } else if (errno != EINPROGRESS) {
-        status = _strerrno(errno);
-      } else {
-        status = 0;
-      }
-      if (status) {
-        printf("%-15s %s\n", FormatIp(ip), status);
-      }
-      _Exit(0);
-    }
-  }
-  for (;;) {
-    if (wait(0) == -1 && errno == ECHILD) {
-      break;
-    }
-  }
-}

examples/reboot.c

@@ -1,39 +0,0 @@
-#if 0
-/*─────────────────────────────────────────────────────────────────╗
-│ To the extent possible under law, Justine Tunney has waived      │
-│ all copyright and related or neighboring rights to this file,    │
-│ as it is written in the following disclaimers:                   │
-│   • http://unlicense.org/                                        │
-│   • http://creativecommons.org/publicdomain/zero/1.0/            │
-╚─────────────────────────────────────────────────────────────────*/
-#endif
-#include "libc/calls/calls.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/reboot.h"
-
-int main(int argc, char *argv[]) {
-  char line[8] = {0};
-  if (argc > 1 && !strcmp(argv[1], "-y")) {
-    line[0] = 'y';
-  } else {
-    printf("reboot your computer? yes or no [no] ");
-    fflush(stdout);
-    fgets(line, sizeof(line), stdin);
-  }
-  if (line[0] == 'y' || line[0] == 'Y') {
-    if (reboot(RB_AUTOBOOT)) {
-      printf("system is rebooting...\n");
-      exit(0);
-    } else {
-      perror("reboot");
-      exit(1);
-    }
-  } else if (line[0] == 'n' || line[0] == 'N') {
-    exit(0);
-  } else {
-    printf("error: unrecognized response\n");
-    exit(2);
-  }
-}

examples/script.c

@@ -1,521 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
-│vi: set et ft=c ts=8 tw=8 fenc=utf-8                                       :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright (c) 2010, 2012 David E. O'Brien                                    │
-│ Copyright (c) 1980, 1992, 1993                                               │
-│      The Regents of the University of California.  All rights reserved.      │
-│                                                                              │
-│ Redistribution and use in source and binary forms, with or without           │
-│ modification, are permitted provided that the following conditions           │
-│ are met:                                                                     │
-│  1. Redistributions of source code must retain the above copyright           │
-│     notice, this list of conditions and the following disclaimer.            │
-│  2. Redistributions in binary form must reproduce the above copyright        │
-│     notice, this list of conditions and the following disclaimer in the      │
-│     documentation and/or other materials provided with the distribution.     │
-│  3. Neither the name of the University nor the names of its contributors     │
-│     may be used to endorse or promote products derived from this software    │
-│     without specific prior written permission.                               │
-│                                                                              │
-│ THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND      │
-│ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE        │
-│ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE   │
-│ ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE     │
-│ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL   │
-│ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS      │
-│ OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)        │
-│ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT   │
-│ LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY    │
-│ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF       │
-│ SUCH DAMAGE.                                                                 │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/iovec.h"
-#include "libc/calls/struct/stat.h"
-#include "libc/calls/struct/termios.h"
-#include "libc/calls/struct/timeval.h"
-#include "libc/calls/struct/winsize.h"
-#include "libc/calls/termios.h"
-#include "libc/calls/weirdtypes.h"
-#include "libc/errno.h"
-#include "libc/fmt/conv.h"
-#include "libc/intrin/bswap.h"
-#include "libc/log/bsd.h"
-#include "libc/macros.internal.h"
-#include "libc/mem/mem.h"
-#include "libc/paths.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sock/select.h"
-#include "libc/stdio/stdio.h"
-#include "libc/sysv/consts/fileno.h"
-#include "libc/sysv/consts/s.h"
-#include "libc/sysv/consts/termios.h"
-#include "libc/time/time.h"
-#include "third_party/getopt/getopt.h"
-// clang-format off
-
-/**
- * @fileoverview Terminal Screencast Recorder / Player, e.g.
- *
- *     make o//examples/script.com
- *     o//examples/script.com -r
- *     # type stuff..
- *     # CTRL-D
- *     o//examples/script.com -p typescript
- *
- * @note works on Linux, OpenBSD, NetBSD, FreeBSD, MacOS
- * @see https://asciinema.org/
- */
-
-asm(".ident\t\"\\n\\n\
-FreeBSD Script (BSD-3 License)\\n\
-Copyright (c) 2010, 2012 David E. O'Brien\\n\
-Copyright (c) 1980, 1992, 1993\\n\
-\tThe Regents of the University of California.\\n\
-\tAll rights reserved.\"");
-asm(".include \"libc/disclaimer.inc\"");
-
-#define DEF_BUF 65536
-
-struct stamp {
-	uint64_t scr_len;	/* amount of data */
-	uint64_t scr_sec;	/* time it arrived in seconds... */
-	uint32_t scr_usec;	/* ...and microseconds */
-	uint32_t scr_direction; /* 'i', 'o', etc (also indicates endianness) */
-};
-
-static FILE *fscript;
-static int master, slave;
-static int child;
-static const char *fname;
-static char *fmfname;
-static int qflg, ttyflg;
-static int usesleep, rawout, showexit;
-
-static struct termios tt;
-
-static void done(int) wontreturn;
-static void doshell(char **);
-static void finish(void);
-static void record(FILE *, char *, size_t, int);
-static void consume(FILE *, off_t, char *, int);
-static void playback(FILE *) wontreturn;
-static void usage(void);
-
-int
-main(int argc, char *argv[])
-{
-	int cc;
-	struct termios rtt, stt;
-	struct winsize win;
-	struct timeval tv, *tvp;
-	time_t tvec, start;
-	static char obuf[BUFSIZ];
-	static char ibuf[BUFSIZ];
-	fd_set rfd;
-	int aflg, Fflg, kflg, pflg, ch, k, n;
-	int flushtime, readstdin;
-	int fm_fd, fm_log;
-
-	aflg = Fflg = kflg = pflg = 0;
-	usesleep = 1;
-	rawout = 0;
-	flushtime = 30;
-	fm_fd = -1;	/* Shut up stupid "may be used uninitialized" GCC
-			   warning. (not needed w/clang) */
-	showexit = 0;
-
-	while ((ch = getopt(argc, argv, "adeFfkpqrt:")) != -1)
-		switch(ch) {
-		case 'a':
-			aflg = 1;
-			break;
-		case 'd':
-			usesleep = 0;
-			break;
-		case 'e':	/* Default behavior, accepted for linux compat */
-			break;
-		case 'F':
-			Fflg = 1;
-			break;
-		case 'k':
-			kflg = 1;
-			break;
-		case 'p':
-			pflg = 1;
-			break;
-		case 'q':
-			qflg = 1;
-			break;
-		case 'r':
-			rawout = 1;
-			break;
-		case 't':
-			flushtime = atoi(optarg);
-			if (flushtime < 0)
-				err(1, "invalid flush time %d", flushtime);
-			break;
-		case '?':
-		default:
-			usage();
-		}
-	argc -= optind;
-	argv += optind;
-
-	if (argc > 0) {
-		fname = argv[0];
-		argv++;
-		argc--;
-	} else
-		fname = "typescript";
-
-	if ((fscript = fopen(fname, pflg ? "r" : aflg ? "a" : "w")) == NULL)
-		err(1, "%s", fname);
-
-	if (pflg)
-		playback(fscript);
-
-	if (tcgetattr(STDIN_FILENO, &tt) == -1 ||
-	    ioctl(STDIN_FILENO, TIOCGWINSZ, &win) == -1) {
-		if (errno != ENOTTY) /* For debugger. */
-			err(1, "tcgetattr/ioctl");
-		if (openpty(&master, &slave, NULL, NULL, NULL) == -1)
-			err(1, "openpty");
-	} else {
-		if (openpty(&master, &slave, NULL, &tt, &win) == -1)
-			err(1, "openpty");
-		ttyflg = 1;
-	}
-
-	if (rawout)
-		record(fscript, NULL, 0, 's');
-
-	if (!qflg) {
-		tvec = time(NULL);
-		printf("Script started, output file is %s\n", fname);
-		if (!rawout) {
-			fprintf(fscript, "Script started on %s",
-			    ctime(&tvec));
-			if (argv[0]) {
-				showexit = 1;
-				fprintf(fscript, "Command: ");
-				for (k = 0 ; argv[k] ; ++k)
-					fprintf(fscript, "%s%s", k ? " " : "",
-						argv[k]);
-				fprintf(fscript, "\n");
-			}
-		}
-		fflush(fscript);
-	}
-	if (ttyflg) {
-		rtt = tt;
-		cfmakeraw(&rtt);
-		rtt.c_lflag &= ~ECHO;
-		tcsetattr(STDIN_FILENO, TCSAFLUSH, &rtt);
-	}
-
-	child = fork();
-	if (child < 0) {
-		warn("fork");
-		done(1);
-	}
-	if (child == 0) {
-		doshell(argv);
-	}
-	close(slave);
-
-	start = tvec = time(0);
-	readstdin = 1;
-	for (;;) {
-		FD_ZERO(&rfd);
-		FD_SET(master, &rfd);
-		if (readstdin)
-			FD_SET(STDIN_FILENO, &rfd);
-		if (!readstdin && ttyflg) {
-			tv.tv_sec = 1;
-			tv.tv_usec = 0;
-			tvp = &tv;
-			readstdin = 1;
-		} else if (flushtime > 0) {
-			tv.tv_sec = flushtime - (tvec - start);
-			tv.tv_usec = 0;
-			tvp = &tv;
-		} else {
-			tvp = NULL;
-		}
-		n = select(master + 1, &rfd, 0, 0, tvp);
-		if (n < 0 && errno != EINTR)
-			break;
-		if (n > 0 && FD_ISSET(STDIN_FILENO, &rfd)) {
-			cc = read(STDIN_FILENO, ibuf, BUFSIZ);
-			if (cc < 0)
-				break;
-			if (cc == 0) {
-				if (tcgetattr(master, &stt) == 0 &&
-				    (stt.c_lflag & ICANON) != 0) {
-					write(master, &stt.c_cc[VEOF], 1);
-				}
-				readstdin = 0;
-			}
-			if (cc > 0) {
-				if (rawout)
-					record(fscript, ibuf, cc, 'i');
-				write(master, ibuf, cc);
-				if (kflg && tcgetattr(master, &stt) >= 0 &&
-				    ((stt.c_lflag & ECHO) == 0)) {
-					fwrite(ibuf, 1, cc, fscript);
-				}
-			}
-		}
-		if (n > 0 && FD_ISSET(master, &rfd)) {
-			cc = read(master, obuf, sizeof (obuf));
-			if (cc <= 0)
-				break;
-			write(STDOUT_FILENO, obuf, cc);
-			if (rawout)
-				record(fscript, obuf, cc, 'o');
-			else
-				fwrite(obuf, 1, cc, fscript);
-		}
-		tvec = time(0);
-		if (tvec - start >= flushtime) {
-			fflush(fscript);
-			start = tvec;
-		}
-		if (Fflg)
-			fflush(fscript);
-	}
-	finish();
-	done(0);
-}
-
-static void
-usage(void)
-{
-	fprintf(stderr,
-		"usage: script [-adfkpqr] [-t time] [file [command ...]]\n");
-	exit(1);
-}
-
-static void
-finish(void)
-{
-	int e, status;
-
-	if (waitpid(child, &status, 0) == child) {
-		if (WIFEXITED(status))
-			e = WEXITSTATUS(status);
-		else if (WIFSIGNALED(status))
-			e = WTERMSIG(status);
-		else /* can't happen */
-			e = 1;
-		done(e);
-	}
-}
-
-static void
-doshell(char **av)
-{
-	const char *shell;
-
-	shell = getenv("SHELL");
-	if (shell == NULL)
-		shell = _PATH_BSHELL;
-
-	close(master);
-	fclose(fscript);
-	free(fmfname);
-	login_tty(slave);
-	setenv("SCRIPT", fname, 1);
-	if (av[0]) {
-		execvp(av[0], av);
-		warn("%s", av[0]);
-	} else {
-		execl(shell, shell, "-i", 0);
-		warn("%s", shell);
-	}
-	exit(1);
-}
-
-static void
-done(int eno)
-{
-	time_t tvec;
-
-	if (ttyflg)
-		tcsetattr(STDIN_FILENO, TCSAFLUSH, &tt);
-	tvec = time(NULL);
-	if (rawout)
-		record(fscript, NULL, 0, 'e');
-	if (!qflg) {
-		if (!rawout) {
-			if (showexit)
-				fprintf(fscript, "\nCommand exit status:"
-				    " %d", eno);
-			fprintf(fscript,"\nScript done on %s",
-			    ctime(&tvec));
-		}
-		printf("\nScript done, output file is %s\n", fname);
-	}
-	fclose(fscript);
-	close(master);
-	exit(eno);
-}
-
-static void
-record(FILE *fp, char *buf, size_t cc, int direction)
-{
-	struct iovec iov[2];
-	struct stamp stamp;
-	struct timeval tv;
-
-	gettimeofday(&tv, NULL);
-	stamp.scr_len = cc;
-	stamp.scr_sec = tv.tv_sec;
-	stamp.scr_usec = tv.tv_usec;
-	stamp.scr_direction = direction;
-	iov[0].iov_len = sizeof(stamp);
-	iov[0].iov_base = &stamp;
-	iov[1].iov_len = cc;
-	iov[1].iov_base = buf;
-	if (writev(fileno(fp), &iov[0], 2) == -1)
-		err(1, "writev");
-}
-
-static void
-consume(FILE *fp, off_t len, char *buf, int reg)
-{
-	size_t l;
-
-	if (reg) {
-		if (fseeko(fp, len, SEEK_CUR) == -1)
-			err(1, NULL);
-	}
-	else {
-		while (len > 0) {
-			l = MIN(DEF_BUF, len);
-			if (fread(buf, sizeof(char), l, fp) != l)
-				err(1, "cannot read buffer");
-			len -= l;
-		}
-	}
-}
-
-#define swapstamp(stamp) do { \
-	if (stamp.scr_direction > 0xff) { \
-		stamp.scr_len = bswap_64(stamp.scr_len); \
-		stamp.scr_sec = bswap_64(stamp.scr_sec); \
-		stamp.scr_usec = bswap_32(stamp.scr_usec); \
-		stamp.scr_direction = bswap_32(stamp.scr_direction); \
-	} \
-} while (0/*CONSTCOND*/)
-
-static void
-termset(void)
-{
-	struct termios traw;
-
-	if (tcgetattr(STDOUT_FILENO, &tt) == -1) {
-		if (errno != ENOTTY) /* For debugger. */
-			err(1, "tcgetattr");
-		return;
-	}
-	ttyflg = 1;
-	traw = tt;
-	cfmakeraw(&traw);
-	traw.c_lflag |= ISIG;
-	tcsetattr(STDOUT_FILENO, TCSANOW, &traw);
-}
-
-static void
-termreset(void)
-{
-	if (ttyflg) {
-		tcsetattr(STDOUT_FILENO, TCSADRAIN, &tt);
-		ttyflg = 0;
-	}
-}
-
-static void
-playback(FILE *fp)
-{
-	struct timespec tsi, tso;
-	struct stamp stamp;
-	struct stat pst;
-	static char buf[DEF_BUF];
-	off_t nread, save_len;
-	size_t l;
-	time_t tclock;
-	int reg;
-
-	if (fstat(fileno(fp), &pst) == -1)
-		err(1, "fstat failed");
-
-	reg = S_ISREG(pst.st_mode);
-
-	for (nread = 0; !reg || nread < pst.st_size; nread += save_len) {
-		if (fread(&stamp, sizeof(stamp), 1, fp) != 1) {
-			if (reg)
-				err(1, "reading playback header");
-			else
-				break;
-		}
-		swapstamp(stamp);
-		save_len = sizeof(stamp);
-
-		if (reg && stamp.scr_len >
-		    (uint64_t)(pst.st_size - save_len) - nread)
-			errx(1, "invalid stamp");
-
-		save_len += stamp.scr_len;
-		tclock = stamp.scr_sec;
-		tso.tv_sec = stamp.scr_sec;
-		tso.tv_nsec = stamp.scr_usec * 1000;
-
-		switch (stamp.scr_direction) {
-		case 's':
-			if (!qflg)
-			    printf("Script started on %s",
-				ctime(&tclock));
-			tsi = tso;
-			consume(fp, stamp.scr_len, buf, reg);
-			termset();
-			atexit(termreset);
-			break;
-		case 'e':
-			termreset();
-			if (!qflg)
-				printf("\nScript done on %s",
-				    ctime(&tclock));
-			consume(fp, stamp.scr_len, buf, reg);
-			break;
-		case 'i':
-			/* throw input away */
-			consume(fp, stamp.scr_len, buf, reg);
-			break;
-		case 'o':
-			tsi.tv_sec = tso.tv_sec - tsi.tv_sec;
-			tsi.tv_nsec = tso.tv_nsec - tsi.tv_nsec;
-			if (tsi.tv_nsec < 0) {
-				tsi.tv_sec -= 1;
-				tsi.tv_nsec += 1000000000;
-			}
-			if (usesleep)
-				nanosleep(&tsi, NULL);
-			tsi = tso;
-			while (stamp.scr_len > 0) {
-				l = MIN(DEF_BUF, stamp.scr_len);
-				if (fread(buf, sizeof(char), l, fp) != l)
-					err(1, "cannot read buffer");
-
-				write(STDOUT_FILENO, buf, l);
-				stamp.scr_len -= l;
-			}
-			break;
-		default:
-			errx(1, "invalid direction");
-		}
-	}
-	fclose(fp);
-	exit(0);
-}

examples/script.txt

@@ -1,100 +0,0 @@
-SCRIPT(1)            Cosmopolitan General Commands Manual              SCRIPT(1)
-
-𝐍𝐀𝐌𝐄
-     𝘀𝗰𝗿𝗶𝗽𝘁 — make typescript of terminal session
-
-𝐒𝐘𝐍𝐎𝐏𝐒𝐈𝐒
-     𝘀𝗰𝗿𝗶𝗽𝘁 [-𝗮𝗱𝗲𝗳𝗸𝗽𝗾𝗿] [-𝐅 p̲i̲p̲e̲] [-𝘁 t̲i̲m̲e̲] [f̲i̲l̲e̲ [c̲o̲m̲m̲a̲n̲d̲ .̲.̲.̲]]
-
-𝐃𝐄𝐒𝐂𝐑𝐈𝐏𝐓𝐈𝐎𝐍
-     The 𝘀𝗰𝗿𝗶𝗽𝘁 utility makes a typescript of everything printed on your termi‐
-     nal.  It is useful for students who need a hardcopy record of an interac‐
-     tive session as proof of an assignment, as the typescript file can be
-     printed out later with lpr(1).
-
-     If the argument f̲i̲l̲e̲ is given, 𝘀𝗰𝗿𝗶𝗽𝘁 saves all dialogue in f̲i̲l̲e̲.  If no
-     file name is given, the typescript is saved in the file t̲y̲p̲e̲s̲c̲r̲i̲p̲t̲.
-
-     If the argument c̲o̲m̲m̲a̲n̲d̲ is given, 𝘀𝗰𝗿𝗶𝗽𝘁 will run the specified command
-     with an optional argument vector instead of an interactive shell.
-
-     The following options are available:
-
-     -𝗮      Append the output to f̲i̲l̲e̲ or t̲y̲p̲e̲s̲c̲r̲i̲p̲t̲, retaining the prior con‐
-             tents.
-
-     -𝗱      When playing back a session with the -𝗽 flag, do not sleep between
-             records when playing back a timestamped session.
-
-     -𝗲      Accepted for compatibility with u̲t̲i̲l̲-̲l̲i̲n̲u̲x̲ 𝘀𝗰𝗿𝗶𝗽𝘁.  The child com‐
-             mand exit status is always the exit status of 𝘀𝗰𝗿𝗶𝗽𝘁.
-
-     -𝐅 p̲i̲p̲e̲
-             Immediately flush output after each write.  This will allow a user
-             to create a named pipe using mkfifo(1) and another user may watch
-             the live session using a utility like cat(1).
-
-     -𝗸      Log keys sent to the program as well as output.
-
-     -𝗽      Play back a session recorded with the -𝗿 flag in real time.
-
-     -𝗾      Run in quiet mode, omit the start, stop and command status mes‐
-             sages.
-
-     -𝗿      Record a session with input, output, and timestamping.
-
-     -𝘁 t̲i̲m̲e̲
-             Specify the interval at which the script output file will be
-             flushed to disk, in seconds.  A value of 0 causes 𝘀𝗰𝗿𝗶𝗽𝘁 to flush
-             after every character I/O event.  The default interval is 30 sec‐
-             onds.
-
-     The script ends when the forked shell (or command) exits (a c̲o̲n̲t̲r̲o̲l̲-̲D̲ to
-     exit the Bourne shell (sh(1)), and e̲x̲i̲t̲, l̲o̲g̲o̲u̲t̲ or c̲o̲n̲t̲r̲o̲l̲-̲D̲ (if i̲g̲n̲o̲r̲e̲e̲o̲f̲
-     is not set) for the C-shell, csh(1)).
-
-     Certain interactive commands, such as vi(1), create garbage in the type‐
-     script file.  The 𝘀𝗰𝗿𝗶𝗽𝘁 utility works best with commands that do not ma‐
-     nipulate the screen.  The results are meant to emulate a hardcopy terminal,
-     not an addressable one.
-
-𝐄𝐍𝐕𝐈𝐑𝐎𝐍𝐌𝐄𝐍𝐓
-     The following environment variables are utilized by 𝘀𝗰𝗿𝗶𝗽𝘁:
-
-     SCRIPT
-            The SCRIPT environment variable is added to the sub-shell.  If
-            SCRIPT already existed in the users environment, its value is over‐
-            written within the sub-shell.  The value of SCRIPT is the name of
-            the t̲y̲p̲e̲s̲c̲r̲i̲p̲t̲ file.
-
-     SHELL  If the variable SHELL exists, the shell forked by 𝘀𝗰𝗿𝗶𝗽𝘁 will be
-            that shell.  If SHELL is not set, the Bourne shell is assumed.
-            (Most shells set this variable automatically).
-
-𝐒𝐄𝐄 𝐀𝐋𝐒𝐎
-     csh(1) (for the h̲i̲s̲t̲o̲r̲y̲ mechanism)
-
-𝐇𝐈𝐒𝐓𝐎𝐑𝐘
-     The 𝘀𝗰𝗿𝗶𝗽𝘁 command appeared in 3.0BSD.
-
-     The -𝗱, -𝗽 and -𝗿 options first appeared in NetBSD 2.0 and were ported to
-     FreeBSD 9.2.
-
-𝐁𝐔𝐆𝐒
-     The 𝘀𝗰𝗿𝗶𝗽𝘁 utility places 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 in the log file, including linefeeds
-     and backspaces.  This is not what the naive user expects.
-
-     It is not possible to specify a command without also naming the script file
-     because of argument parsing compatibility issues.
-
-     When running in -𝗸 mode, echo cancelling is far from ideal.  The slave ter‐
-     minal mode is checked for ECHO mode to check when to avoid manual echo log‐
-     ging.  This does not work when the terminal is in a raw mode where the pro‐
-     gram being run is doing manual echo.
-
-     If 𝘀𝗰𝗿𝗶𝗽𝘁 reads zero bytes from the terminal, it switches to a mode when it
-     only attempts to read once a second until there is data to read.  This pre‐
-     vents 𝘀𝗰𝗿𝗶𝗽𝘁 from spinning on zero-byte reads, but might cause a 1-second
-     delay in processing of user input.
-
-BSD                             September 1, 2020                            BSD

examples/shutdown.c

@@ -1,39 +0,0 @@
-#if 0
-/*─────────────────────────────────────────────────────────────────╗
-│ To the extent possible under law, Justine Tunney has waived      │
-│ all copyright and related or neighboring rights to this file,    │
-│ as it is written in the following disclaimers:                   │
-│   • http://unlicense.org/                                        │
-│   • http://creativecommons.org/publicdomain/zero/1.0/            │
-╚─────────────────────────────────────────────────────────────────*/
-#endif
-#include "libc/calls/calls.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/reboot.h"
-
-int main(int argc, char *argv[]) {
-  char line[8] = {0};
-  if (argc > 1 && !strcmp(argv[1], "-y")) {
-    line[0] = 'y';
-  } else {
-    printf("shutdown your computer? yes or no [no] ");
-    fflush(stdout);
-    fgets(line, sizeof(line), stdin);
-  }
-  if (line[0] == 'y' || line[0] == 'Y') {
-    if (reboot(RB_POWER_OFF)) {
-      printf("system is shutting down...\n");
-      exit(0);
-    } else {
-      perror("reboot");
-      exit(1);
-    }
-  } else if (line[0] == 'n' || line[0] == 'N') {
-    exit(0);
-  } else {
-    printf("error: unrecognized response\n");
-    exit(2);
-  }
-}

examples/statfs.c

@@ -27,13 +27,13 @@ dontinline void ShowIt(const char *path) {
          "optimal transfer block size");
   sizefmt(ibuf, sf.f_frsize, 1024);
   printf("f_frsize  = %,zu (%sb %s)\n", sf.f_frsize, ibuf, "fragment size");
-  sizefmt(ibuf, sf.f_blocks * sf.f_frsize, 1024);
+  sizefmt(ibuf, sf.f_blocks * sf.f_bsize, 1024);
   printf("f_blocks  = %,zu (%sb %s)\n", sf.f_blocks, ibuf,
          "total data blocks in filesystem");
-  sizefmt(ibuf, sf.f_bfree * sf.f_frsize, 1024);
+  sizefmt(ibuf, sf.f_bfree * sf.f_bsize, 1024);
   printf("f_bfree   = %,zu (%sb %s)\n", sf.f_bfree, ibuf,
          "free blocks in filesystem");
-  sizefmt(ibuf, sf.f_bavail * sf.f_frsize, 1024);
+  sizefmt(ibuf, sf.f_bavail * sf.f_bsize, 1024);
   printf("f_bavail  = %,zu (%sb %s)\n", sf.f_bavail, ibuf,
          "free blocks available to use");
   printf("f_files   = %,zu (%s)\n", sf.f_files,

examples/symtab.c

@@ -1,42 +0,0 @@
-#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/intrin/kprintf.h"
-#include "libc/log/log.h"
-
-/**
- * @fileoverview example of how to embed symbol table in .com file
- *
- *     # build our binary
- *     make -j16 o//examples/symtab.com
- *
- *     # move binary somewhere else
- *     # so it can't find the .com.dbg binary
- *     cp o//examples/symtab.com /tmp
- *
- *     # run program
- *     # notice that it has a symbolic backtrace
- *     /tmp/symtab.com
- *
- * @see examples/examples.mk
- */
-
-int main(int argc, char *argv[]) {
-
-  // this links all the debugging and zip functionality
-  ShowCrashReports();
-
-  kprintf("----------------\n");
-  kprintf(" THIS IS A TEST \n");
-  kprintf("SIMULATING CRASH\n");
-  kprintf("----------------\n");
-
-  volatile int64_t x;
-  return 1 / (x = 0);
-}

examples/sysinfo.c

@@ -46,31 +46,31 @@ int main(int argc, char *argv[]) {
          1. / 65536 * si.loads[1],    //
          1. / 65536 * si.loads[2]);   //
 
-  sizefmt(ibuf, si.totalram * si.mem_unit, 1024);
-  printf("%-16s %ld (%s)\n", "totalram", si.totalram, ibuf);
+  sizefmt(ibuf, si.totalram, 1024);
+  printf("%-16s %s\n", "totalram", ibuf);
 
-  sizefmt(ibuf, si.freeram * si.mem_unit, 1024);
-  printf("%-16s %ld (%s)\n", "freeram", si.freeram, ibuf);
+  sizefmt(ibuf, si.freeram, 1024);
+  printf("%-16s %s\n", "freeram", ibuf);
 
-  sizefmt(ibuf, si.sharedram * si.mem_unit, 1024);
-  printf("%-16s %ld (%s)\n", "sharedram", si.sharedram, ibuf);
+  sizefmt(ibuf, si.sharedram, 1024);
+  printf("%-16s %s\n", "sharedram", ibuf);
 
-  sizefmt(ibuf, si.bufferram * si.mem_unit, 1024);
-  printf("%-16s %ld (%s)\n", "bufferram", si.bufferram, ibuf);
+  sizefmt(ibuf, si.bufferram, 1024);
+  printf("%-16s %s\n", "bufferram", ibuf);
 
-  sizefmt(ibuf, si.totalswap * si.mem_unit, 1024);
-  printf("%-16s %ld (%s)\n", "totalswap", si.totalswap, ibuf);
+  sizefmt(ibuf, si.totalswap, 1024);
+  printf("%-16s %s\n", "totalswap", ibuf);
 
-  sizefmt(ibuf, si.freeswap * si.mem_unit, 1024);
-  printf("%-16s %ld (%s)\n", "freeswap", si.freeswap, ibuf);
+  sizefmt(ibuf, si.freeswap, 1024);
+  printf("%-16s %s\n", "freeswap", ibuf);
 
   printf("%-16s %lu\n", "processes", si.procs);
 
-  sizefmt(ibuf, si.totalhigh * si.mem_unit, 1024);
-  printf("%-16s %ld (%s)\n", "totalhigh", si.totalhigh, ibuf);
+  sizefmt(ibuf, si.totalhigh, 1024);
+  printf("%-16s %s\n", "totalhigh", ibuf);
 
-  sizefmt(ibuf, si.freehigh * si.mem_unit, 1024);
-  printf("%-16s %ld (%s)\n", "freehigh", si.freehigh, ibuf);
+  sizefmt(ibuf, si.freehigh, 1024);
+  printf("%-16s %s\n", "freehigh", ibuf);
 
   sizefmt(ibuf, si.mem_unit, 1024);
   printf("%-16s %s\n", "mem_unit", ibuf);

examples/system.c

@@ -7,20 +7,13 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/runtime/runtime.h"
+#include "libc/dce.h"
 #include "libc/stdio/stdio.h"
 
-/**
- * @fileoverview Cosmopolitan Command Interpreter Demo
- * Yes this works on Windows.
- */
-
-STATIC_YOINK("_tr");
-STATIC_YOINK("_sed");
-
 int main(int argc, char *argv[]) {
-  system("x=world\n"
-         "echo hello $x |\n"
-         "  tr a-z A-Z |\n"
-         "  sed 's/\\(.\\)/\\1 /g'");
+  if (IsWindows()) {
+    system("notepad");
+  } else {
+    system("ls | tr a-z A-Z");
+  }
 }

examples/vga.c

@@ -49,12 +49,12 @@ int main(int argc, char *argv[]) {
     printf("res = %d?\n", res);
     return -1;
   }
-  printf("\e[92;44mHello World!\e[0m %.19Lg\n", atan2l(x, y));
+  printf("Hello World! %.19Lg\n", atan2l(x, y));
 
   // read/print loop so machine doesn't reset on metal
   for (;;) {
     if ((res = readansi(0, buf, 16)) > 0) {
-      printf("got \e[97m%`'.*s\e[0m\r\n", res, buf);
+      printf("got %`'.*s\r\n", res, buf);
     }
   }
 }

examples/vga2.c

@@ -1,39 +0,0 @@
-#if 0
-/*─────────────────────────────────────────────────────────────────╗
-│ To the extent possible under law, Justine Tunney has waived      │
-│ all copyright and related or neighboring rights to this file,    │
-│ as it is written in the following disclaimers:                   │
-│   • http://unlicense.org/                                        │
-│   • http://creativecommons.org/publicdomain/zero/1.0/            │
-╚─────────────────────────────────────────────────────────────────*/
-#endif
-#include "libc/calls/calls.h"
-#include "libc/calls/termios.h"
-#include "libc/isystem/unistd.h"
-#include "libc/math.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/termios.h"
-
-/**
- * @fileoverview Demo of program crash reporting with Bare Metal VGA TTY.
- *
- *     make -j8 o//examples/vga2.com
- *     qemu-system-x86_64 -hda o//examples/vga2.com -serial stdio
- */
-
-STATIC_YOINK("vga_console");
-STATIC_YOINK("_idt");
-STATIC_YOINK("EfiMain");
-
-int main(int argc, char *argv[]) {
-  int i;
-  volatile int x = 1;
-  volatile int y = 2;
-  printf("argc = %d\n", argc);
-  for (i = 0; i < argc; ++i) {
-    printf("argv[%d] = \"%s\"\n", i, argv[i]);
-  }
-  printf("\e[92;44mHello World!\e[0m %d\n", 1 / (x + y - 3));
-  for (;;);
-}

examples/wall.c

@@ -1,148 +0,0 @@
-#if 0
-/*─────────────────────────────────────────────────────────────────╗
-│ To the extent possible under law, Justine Tunney has waived      │
-│ all copyright and related or neighboring rights to this file,    │
-│ as it is written in the following disclaimers:                   │
-│   • http://unlicense.org/                                        │
-│   • http://creativecommons.org/publicdomain/zero/1.0/            │
-╚─────────────────────────────────────────────────────────────────*/
-#endif
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/calls/termios.h"
-#include "libc/errno.h"
-#include "libc/fmt/fmt.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/append.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/o.h"
-#include "libc/time/struct/tm.h"
-#include "third_party/getopt/getopt.h"
-#include "third_party/musl/passwd.h"
-
-/**
- * @fileoverview program for broadcasting message to all terminals, e.g.
- *
- *     o//examples/wall.com hello friends
- *
- * Will place some bold text into the top left corners of all terminals:
- *
- *     Broadcast message from jart@host (pts/4) (Tue Oct 11 03:52:24 2022):
- *     hello friends
- *
- * It's useful for having one terminal tab notify your other ones when
- * something like a long running job completes. In the old days back
- * when unix systems had multiple users, the wall command provided the
- * ultimate lulz especially if it's a setuid binary with root privs.
- */
-
-#define GETOPTS "v"
-#define USAGE \
-  "\
-Usage: wall.com [-v] [TEXTMSG] [<TEXTMSG]\n\
-  -v          increase verbosity\n\
-Examples:\n\
-  wall.com 'hello my friends'\n\
-  echo hello my friends | wall.com\n\
-"
-
-int g_verbose;
-
-static void GetOpts(int argc, char *argv[]) {
-  int opt;
-  while ((opt = getopt(argc, argv, GETOPTS)) != -1) {
-    switch (opt) {
-      case 'v':
-        g_verbose++;
-        break;
-      case '?':
-        write(1, USAGE, sizeof(USAGE) - 1);
-        exit(0);
-      default:
-        write(2, USAGE, sizeof(USAGE) - 1);
-        exit(64);
-    }
-  }
-}
-
-char *GetHost(void) {
-  static char host[254];
-  if (gethostname(host, sizeof(host))) {
-    strcpy(host, "localhost");
-  }
-  return host;
-}
-
-char *GetTime(void) {
-  int64_t t;
-  struct tm tm;
-  struct timespec ts;
-  clock_gettime(0, &ts);
-  localtime_r(&ts.tv_sec, &tm);
-  return _chomp(asctime(&tm));
-}
-
-int main(int argc, char *argv[]) {
-  GetOpts(argc, argv);
-
-  // create broadcast banner
-  // we use \e[1m so the text is strong & visually distinct
-  // we use \e[K so it doesn't get lost in a forest of text
-  // we map \n → \r\n because teletype might be in raw mode
-  char *msg = 0;
-  const char *s;
-  appends(&msg, "\e7");    // save cursor position
-  appends(&msg, "\e[H");   // goto top left corne
-  appends(&msg, "\e[K");   // clear line forward
-  appends(&msg, "\e[1m");  // bold text
-  appendf(&msg, "Broadcast message from %s@%s", getpwuid(getuid())->pw_name,
-          GetHost());
-  if (isatty(0) && (s = ttyname(0))) appendf(&msg, " (%s)", s);
-  appendf(&msg, " (%s):\r\n", GetTime());
-  appends(&msg, "\e[K");
-
-  // append broadcast message
-  if (optind < argc) {
-    // use cli arguments as message if they exist
-    for (int i = 0; optind + i < argc; ++i) {
-      if (i) appends(&msg, " ");
-      for (s = argv[optind + i]; *s; ++s) {
-        if (*s == '\n') {
-          appends(&msg, "\r\n\e[K");
-        } else {
-          appendw(&msg, *s & 255);
-        }
-      }
-    }
-  } else {
-    // otherwise use stdin as message
-    ssize_t i, rc;
-    char buf[512];
-    while ((rc = read(0, buf, sizeof(buf))) > 0) {
-      for (i = 0; i < rc; ++i) {
-        if (buf[i] == '\n') {
-          appends(&msg, "\r\n\e[K");  // clear line forward
-        } else {
-          appendw(&msg, buf[i] & 255);
-        }
-      }
-    }
-  }
-  appends(&msg, "\r\n\e[K\e[0m\e8");  // restore
-
-  // try to send message to all pseudoteletypewriters
-  for (int i = 0;; ++i) {
-    int fd;
-    char pts[32];
-    snprintf(pts, sizeof(pts), "/dev/pts/%d", i);
-    if ((fd = open(pts, O_WRONLY | O_NOCTTY)) == -1) {
-      if (errno == ENOENT) break;
-      if (g_verbose) perror(pts);
-    }
-    write(fd, msg, appendz(msg).i);
-    close(fd);
-  }
-
-  return 0;
-}

examples/whois.c

@@ -1,617 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
-│vi: set et ft=c ts=8 tw=8 fenc=utf-8                                       :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright (c) 1980, 1993                                                     │
-│      The Regents of the University of California.  All rights reserved.      │
-│                                                                              │
-│ Redistribution and use in source and binary forms, with or without           │
-│ modification, are permitted provided that the following conditions           │
-│ are met:                                                                     │
-│  1. Redistributions of source code must retain the above copyright           │
-│     notice, this list of conditions and the following disclaimer.            │
-│  2. Redistributions in binary form must reproduce the above copyright        │
-│     notice, this list of conditions and the following disclaimer in the      │
-│     documentation and/or other materials provided with the distribution.     │
-│  3. Neither the name of the University nor the names of its contributors     │
-│     may be used to endorse or promote products derived from this software    │
-│     without specific prior written permission.                               │
-│                                                                              │
-│ THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND      │
-│ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE        │
-│ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE   │
-│ ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE     │
-│ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL   │
-│ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS      │
-│ OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)        │
-│ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT   │
-│ LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY    │
-│ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF       │
-│ SUCH DAMAGE.                                                                 │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/dns/dns.h"
-#include "libc/errno.h"
-#include "libc/log/bsd.h"
-#include "libc/mem/fmt.h"
-#include "libc/mem/mem.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sock/struct/pollfd.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/af.h"
-#include "libc/sysv/consts/ex.h"
-#include "libc/sysv/consts/f.h"
-#include "libc/sysv/consts/o.h"
-#include "libc/sysv/consts/poll.h"
-#include "libc/sysv/consts/sock.h"
-#include "third_party/getopt/getopt.h"
-// clang-format off
-
-asm(".ident\t\"\\n\\n\
-FreeBSD Whois (BSD-3 License)\\n\
-Copyright (c) 1980, 1993\\n\
-\tThe Regents of the University of California.\\n\
-\tAll rights reserved.\"");
-asm(".include \"libc/disclaimer.inc\"");
-
-#define	ABUSEHOST	"whois.abuse.net"
-#define	ANICHOST	"whois.arin.net"
-#define	DENICHOST	"whois.denic.de"
-#define	DKNICHOST	"whois.dk-hostmaster.dk"
-#define	FNICHOST	"whois.afrinic.net"
-#define	GNICHOST	"whois.nic.gov"
-#define	IANAHOST	"whois.iana.org"
-#define	INICHOST	"whois.internic.net"
-#define	KNICHOST	"whois.krnic.net"
-#define	LNICHOST	"whois.lacnic.net"
-#define	MNICHOST	"whois.ra.net"
-#define	PDBHOST		"whois.peeringdb.com"
-#define	PNICHOST	"whois.apnic.net"
-#define	QNICHOST_TAIL	".whois-servers.net"
-#define	RNICHOST	"whois.ripe.net"
-#define	VNICHOST	"whois.verisign-grs.com"
-
-#define	DEFAULT_PORT	"whois"
-
-#define WHOIS_RECURSE	0x01
-#define WHOIS_QUICK	0x02
-#define WHOIS_SPAM_ME	0x04
-
-#define CHOPSPAM	">>> Last update of WHOIS database:"
-
-#define ishost(h) (isalnum((unsigned char)h) || h == '.' || h == '-')
-
-#define SCAN(p, end, check)					\
-	while ((p) < (end))					\
-		if (check) ++(p);				\
-		else break
-
-static struct {
-	const char *suffix, *server;
-} whoiswhere[] = {
-	/* Various handles */
-	{ "-ARIN", ANICHOST },
-	{ "-NICAT", "at" QNICHOST_TAIL },
-	{ "-NORID", "no" QNICHOST_TAIL },
-	{ "-RIPE", RNICHOST },
-	/* Nominet's whois server doesn't return referrals to JANET */
-	{ ".ac.uk", "ac.uk" QNICHOST_TAIL },
-	{ ".gov.uk", "ac.uk" QNICHOST_TAIL },
-	{ "", IANAHOST }, /* default */
-	{ NULL, NULL } /* safety belt */
-};
-
-#define WHOIS_REFERRAL(s) { s, sizeof(s) - 1 }
-static struct {
-	const char *prefix;
-	size_t len;
-} whois_referral[] = {
-	WHOIS_REFERRAL("whois:"), /* IANA */
-	WHOIS_REFERRAL("Whois Server:"),
-	WHOIS_REFERRAL("Registrar WHOIS Server:"), /* corporatedomains.com */
-	WHOIS_REFERRAL("ReferralServer:  whois://"), /* ARIN */
-	WHOIS_REFERRAL("ReferralServer:  rwhois://"), /* ARIN */
-	WHOIS_REFERRAL("descr:          region. Please query"), /* AfriNIC */
-	{ NULL, 0 }
-};
-
-/*
- * We have a list of patterns for RIRs that assert ignorance rather than
- * providing referrals. If that happens, we guess that ARIN will be more
- * helpful. But, before following a referral to an RIR, we check if we have
- * asked that RIR already, and if so we make another guess.
- */
-static const char *actually_arin[] = {
-	"netname:        ERX-NETBLOCK\n", /* APNIC */
-	"netname:        NON-RIPE-NCC-MANAGED-ADDRESS-BLOCK\n",
-	NULL
-};
-
-static struct {
-	int loop;
-	const char *host;
-} try_rir[] = {
-	{ 0, ANICHOST },
-	{ 0, RNICHOST },
-	{ 0, PNICHOST },
-	{ 0, FNICHOST },
-	{ 0, LNICHOST },
-	{ 0, NULL }
-};
-
-static void
-reset_rir(void) {
-	int i;
-
-	for (i = 0; try_rir[i].host != NULL; i++)
-		try_rir[i].loop = 0;
-}
-
-static const char *port = DEFAULT_PORT;
-
-static const char *choose_server(char *);
-static struct addrinfo *gethostinfo(const char *, const char *, int);
-static void s_asprintf(char **ret, const char *format, ...);
-static void usage(void);
-static void whois(const char *, const char *, const char *, int);
-
-int
-main(int argc, char *argv[])
-{
-	const char *country, *host;
-	int ch, flags;
-
-#ifdef	SOCKS
-	SOCKSinit(argv[0]);
-#endif
-
-	country = host = NULL;
-	flags = 0;
-	while ((ch = getopt(argc, argv, "aAbc:fgh:iIklmp:PQrRS")) != -1) {
-		switch (ch) {
-		case 'a':
-			host = ANICHOST;
-			break;
-		case 'A':
-			host = PNICHOST;
-			break;
-		case 'b':
-			host = ABUSEHOST;
-			break;
-		case 'c':
-			country = optarg;
-			break;
-		case 'f':
-			host = FNICHOST;
-			break;
-		case 'g':
-			host = GNICHOST;
-			break;
-		case 'h':
-			host = optarg;
-			break;
-		case 'i':
-			host = INICHOST;
-			break;
-		case 'I':
-			host = IANAHOST;
-			break;
-		case 'k':
-			host = KNICHOST;
-			break;
-		case 'l':
-			host = LNICHOST;
-			break;
-		case 'm':
-			host = MNICHOST;
-			break;
-		case 'p':
-			port = optarg;
-			break;
-		case 'P':
-			host = PDBHOST;
-			break;
-		case 'Q':
-			flags |= WHOIS_QUICK;
-			break;
-		case 'r':
-			host = RNICHOST;
-			break;
-		case 'R':
-			flags |= WHOIS_RECURSE;
-			break;
-		case 'S':
-			flags |= WHOIS_SPAM_ME;
-			break;
-		case '?':
-		default:
-			usage();
-			/* NOTREACHED */
-		}
-	}
-	argc -= optind;
-	argv += optind;
-
-	if (!argc || (country != NULL && host != NULL))
-		usage();
-
-	/*
-	 * If no host or country is specified, rely on referrals from IANA.
-	 */
-	if (host == NULL && country == NULL) {
-		if ((host = getenv("WHOIS_SERVER")) == NULL &&
-		    (host = getenv("RA_SERVER")) == NULL) {
-			if (!(flags & WHOIS_QUICK))
-				flags |= WHOIS_RECURSE;
-		}
-	}
-	while (argc-- > 0) {
-		if (country != NULL) {
-			char *qnichost;
-			s_asprintf(&qnichost, "%s%s", country, QNICHOST_TAIL);
-			whois(*argv, qnichost, port, flags);
-			free(qnichost);
-		} else
-			whois(*argv, host != NULL ? host :
-			      choose_server(*argv), port, flags);
-		reset_rir();
-		argv++;
-	}
-	exit(0);
-}
-
-static const char *
-choose_server(char *domain)
-{
-	size_t len = strlen(domain);
-	int i;
-
-	for (i = 0; whoiswhere[i].suffix != NULL; i++) {
-		size_t suffix_len = strlen(whoiswhere[i].suffix);
-		if (len > suffix_len &&
-		    strcasecmp(domain + len - suffix_len,
-			       whoiswhere[i].suffix) == 0)
-			return (whoiswhere[i].server);
-	}
-	errx(EX_SOFTWARE, "no default whois server");
-}
-
-static struct addrinfo *
-gethostinfo(const char *host, const char *hport, int exit_on_noname)
-{
-	struct addrinfo hints, *res;
-	int error;
-
-	memset(&hints, 0, sizeof(hints));
-	hints.ai_flags = AI_CANONNAME;
-	hints.ai_family = AF_UNSPEC;
-	hints.ai_socktype = SOCK_STREAM;
-	res = NULL;
-	error = getaddrinfo(host, hport, &hints, &res);
-	if (error && (exit_on_noname || error != EAI_NONAME))
-		err(EX_NOHOST, "%s: %s", host, gai_strerror(error));
-	return (res);
-}
-
-/*
- * Wrapper for asprintf(3) that exits on error.
- */
-static void
-s_asprintf(char **ret, const char *format, ...)
-{
-	va_list ap;
-
-	va_start(ap, format);
-	if (vasprintf(ret, format, ap) == -1) {
-		va_end(ap);
-		err(EX_OSERR, "vasprintf()");
-	}
-	va_end(ap);
-}
-
-static int
-connect_to_any_host(struct addrinfo *hostres)
-{
-	struct addrinfo *res;
-	nfds_t i, j;
-	size_t count;
-	struct pollfd *fds;
-	int timeout = 180, s = -1;
-
-	for (res = hostres, count = 0; res; res = res->ai_next)
-		count++;
-	fds = calloc(count, sizeof(*fds));
-	if (fds == NULL)
-		err(EX_OSERR, "calloc()");
-
-	/*
-	 * Traverse the result list elements and make non-block
-	 * connection attempts.
-	 */
-	count = i = 0;
-	for (res = hostres; res != NULL; res = res->ai_next) {
-		s = socket(res->ai_family, res->ai_socktype | SOCK_NONBLOCK,
-		    res->ai_protocol);
-		if (s < 0)
-			continue;
-		if (connect(s, res->ai_addr, res->ai_addrlen) < 0) {
-			if (errno == EINPROGRESS) {
-				/* Add the socket to poll list */
-				fds[i].fd = s;
-				fds[i].events = POLLERR | POLLHUP |
-						POLLIN | POLLOUT;
-				/*
-				 * From here until a socket connects, the
-				 * socket fd is owned by the fds[] poll array.
-				 */
-				s = -1;
-				count++;
-				i++;
-			} else {
-				close(s);
-				s = -1;
-
-				/*
-				 * Poll only if we have something to poll,
-				 * otherwise just go ahead and try next
-				 * address
-				 */
-				if (count == 0)
-					continue;
-			}
-		} else
-			goto done;
-
-		/*
-		 * If we are at the last address, poll until a connection is
-		 * established or we failed all connection attempts.
-		 */
-		if (res->ai_next == NULL)
-			timeout = INFTIM;
-
-		/*
-		 * Poll the watched descriptors for successful connections:
-		 * if we still have more untried resolved addresses, poll only
-		 * once; otherwise, poll until all descriptors have errors,
-		 * which will be considered as ETIMEDOUT later.
-		 */
-		do {
-			int n;
-
-			n = poll(fds, i, timeout);
-			if (n == 0) {
-				/*
-				 * No event reported in time.  Try with a
-				 * smaller timeout (but cap at 2-3ms)
-				 * after a new host have been added.
-				 */
-				if (timeout >= 3)
-					timeout >>= 1;
-
-				break;
-			} else if (n < 0) {
-				/*
-				 * errno here can only be EINTR which we would
-				 * want to clean up and bail out.
-				 */
-				s = -1;
-				goto done;
-			}
-
-			/*
-			 * Check for the event(s) we have seen.
-			 */
-			for (j = 0; j < i; j++) {
-				if (fds[j].fd == -1 || fds[j].events == 0 ||
-				    fds[j].revents == 0)
-					continue;
-				if (fds[j].revents & ~(POLLIN | POLLOUT)) {
-					close(fds[j].fd);
-					fds[j].fd = -1;
-					fds[j].events = 0;
-					count--;
-					continue;
-				} else if (fds[j].revents & (POLLIN | POLLOUT)) {
-					/* Connect succeeded. */
-					s = fds[j].fd;
-					fds[j].fd = -1;
-
-					goto done;
-				}
-
-			}
-		} while (timeout == INFTIM && count != 0);
-	}
-
-	/* All attempts were failed */
-	s = -1;
-	if (count == 0)
-		errno = ETIMEDOUT;
-
-done:
-	/* Close all watched fds except the succeeded one */
-	for (j = 0; j < i; j++)
-		if (fds[j].fd != -1)
-			close(fds[j].fd);
-	free(fds);
-	return (s);
-}
-
-static void
-whois(const char *query, const char *hostname, const char *hostport, int flags)
-{
-	FILE *fp;
-	struct addrinfo *hostres;
-	char *buf, *host, *nhost, *nport, *p;
-	int comment, s, f;
-	size_t len, i;
-
-	hostres = gethostinfo(hostname, hostport, 1);
-	s = connect_to_any_host(hostres);
-	if (s == -1)
-		err(EX_OSERR, "connect()");
-
-	/* Restore default blocking behavior.  */
-	if ((f = fcntl(s, F_GETFL)) == -1)
-		err(EX_OSERR, "fcntl()");
-	f &= ~O_NONBLOCK;
-	if (fcntl(s, F_SETFL, f) == -1)
-		err(EX_OSERR, "fcntl()");
-
-	fp = fdopen(s, "r+");
-	if (fp == NULL)
-		err(EX_OSERR, "fdopen()");
-
-	if (!(flags & WHOIS_SPAM_ME) &&
-	    (strcasecmp(hostname, DENICHOST) == 0 ||
-	     strcasecmp(hostname, "de" QNICHOST_TAIL) == 0)) {
-		const char *q;
-		int idn = 0;
-		for (q = query; *q != '\0'; q++)
-			if (!isascii(*q))
-				idn = 1;
-		fprintf(fp, "-T dn%s %s\r\n", idn ? "" : ",ace", query);
-	} else if (!(flags & WHOIS_SPAM_ME) &&
-		   (strcasecmp(hostname, DKNICHOST) == 0 ||
-		    strcasecmp(hostname, "dk" QNICHOST_TAIL) == 0))
-		fprintf(fp, "--show-handles %s\r\n", query);
-	else if ((flags & WHOIS_SPAM_ME) ||
-		 strchr(query, ' ') != NULL)
-		fprintf(fp, "%s\r\n", query);
-	else if (strcasecmp(hostname, ANICHOST) == 0) {
-		if (strncasecmp(query, "AS", 2) == 0 &&
-		    strspn(query+2, "0123456789") == strlen(query+2))
-			fprintf(fp, "+ a %s\r\n", query+2);
-		else
-			fprintf(fp, "+ %s\r\n", query);
-	} else if (strcasecmp(hostres->ai_canonname, VNICHOST) == 0)
-		fprintf(fp, "domain %s\r\n", query);
-	else
-		fprintf(fp, "%s\r\n", query);
-	fflush(fp);
-
-	comment = 0;
-	if (!(flags & WHOIS_SPAM_ME) &&
-	    (strcasecmp(hostname, ANICHOST) == 0 ||
-	     strcasecmp(hostname, RNICHOST) == 0)) {
-		comment = 2;
-	}
-
-	nhost = NULL;
-	while ((buf = fgetln(fp, &len)) != NULL) {
-		/* Nominet */
-		if (!(flags & WHOIS_SPAM_ME) &&
-		    len == 5 && strncmp(buf, "-- \r\n", 5) == 0)
-			break;
-		/* RIRs */
-		if (comment == 1 && buf[0] == '#')
-			break;
-		else if (comment == 2) {
-			if (strchr("#%\r\n", buf[0]) != NULL)
-				continue;
-			else
-				comment = 1;
-		}
-
-		printf("%.*s", (int)len, buf);
-
-		if ((flags & WHOIS_RECURSE) && nhost == NULL) {
-			for (i = 0; whois_referral[i].prefix != NULL; i++) {
-				p = buf;
-				SCAN(p, buf+len, *p == ' ');
-				if (strncasecmp(p, whois_referral[i].prefix,
-					           whois_referral[i].len) != 0)
-					continue;
-				p += whois_referral[i].len;
-				SCAN(p, buf+len, *p == ' ');
-				host = p;
-				SCAN(p, buf+len, ishost(*p));
-				if (p > host) {
-					char *pstr;
-
-					s_asprintf(&nhost, "%.*s",
-						   (int)(p - host), host);
-
-					if (*p != ':') {
-						s_asprintf(&nport, "%s", port);
-						break;
-					}
-
-					pstr = ++p;
-					SCAN(p, buf+len, isdigit(*p));
-					if (p > pstr && (p - pstr) < 6) {
-						s_asprintf(&nport, "%.*s",
-						    (int)(p - pstr), pstr);
-						break;
-					}
-
-					/* Invalid port; don't recurse */
-					free(nhost);
-					nhost = NULL;
-				}
-				break;
-			}
-			for (i = 0; actually_arin[i] != NULL; i++) {
-				if (strncmp(buf, actually_arin[i], len) == 0) {
-					s_asprintf(&nhost, "%s", ANICHOST);
-					s_asprintf(&nport, "%s", port);
-					break;
-				}
-			}
-		}
-		/* Verisign etc. */
-		if (!(flags & WHOIS_SPAM_ME) &&
-		    len >= sizeof(CHOPSPAM)-1 &&
-		    (strncasecmp(buf, CHOPSPAM, sizeof(CHOPSPAM)-1) == 0 ||
-		     strncasecmp(buf, CHOPSPAM+4, sizeof(CHOPSPAM)-5) == 0)) {
-			printf("\n");
-			break;
-		}
-	}
-	fclose(fp);
-	freeaddrinfo(hostres);
-
-	f = 0;
-	for (i = 0; try_rir[i].host != NULL; i++) {
-		/* Remember visits to RIRs */
-		if (try_rir[i].loop == 0 &&
-		    strcasecmp(try_rir[i].host, hostname) == 0)
-			try_rir[i].loop = 1;
-		/* Do we need to find an alternative RIR? */
-		if (try_rir[i].loop != 0 && nhost != NULL &&
-		    strcasecmp(try_rir[i].host, nhost) == 0) {
-			free(nhost);
-			nhost = NULL;
-			free(nport);
-			nport = NULL;
-			f = 1;
-		}
-	}
-	if (f) {
-		/* Find a replacement RIR */
-		for (i = 0; try_rir[i].host != NULL; i++) {
-			if (try_rir[i].loop == 0) {
-				s_asprintf(&nhost, "%s", try_rir[i].host);
-				s_asprintf(&nport, "%s", port);
-				break;
-			}
-		}
-	}
-	if (nhost != NULL) {
-		/* Ignore self-referrals */
-		if (strcasecmp(hostname, nhost) != 0) {
-			printf("# %s\n\n", nhost);
-			whois(query, nhost, nport, flags);
-		}
-		free(nhost);
-		free(nport);
-	}
-}
-
-static void
-usage(void)
-{
-	fprintf(stderr,
-	    "usage: whois [-aAbfgiIklmPQrRS] [-c country-code | -h hostname] "
-	    "[-p port] name ...\n");
-	exit(EX_USAGE);
-}

libc/ar.h

@@ -1,21 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_AR_H_
-#define COSMOPOLITAN_LIBC_AR_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-COSMOPOLITAN_C_START_
-
-#define ARMAG  "!<arch>\n"
-#define SARMAG 8
-#define ARFMAG "`\n"
-
-struct ar_hdr {
-  char ar_name[16];
-  char ar_date[12];
-  char ar_uid[6], ar_gid[6];
-  char ar_mode[8];
-  char ar_size[10];
-  char ar_fmag[2];
-};
-
-COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_AR_H_ */

libc/assert.h

@@ -4,72 +4,32 @@
 COSMOPOLITAN_C_START_
 
 extern bool __assert_disable;
-void __assert_fail(const char *, const char *, int) _Hide relegated;
+void __assert_fail(const char *, const char *, int) hidden relegated;
 
 #ifdef NDEBUG
-#define assert(x) ((void)0)
+#define assert(EXPR) ((void)0)
 #else
-#define assert(x) ((void)((x) || (__assert_fail(#x, __FILE__, __LINE__), 0)))
+#define assert(EXPR) \
+  ((void)((EXPR) || (__assert_fail(#EXPR, __FILE__, __LINE__), 0)))
 #endif
 
 #ifndef __cplusplus
 #define static_assert _Static_assert
 #endif
 
-#ifdef __GNUC__
-#if !defined(TINY) && !defined(MODE_DBG)
-/**
- * Specifies expression can't possibly be false.
- *
- * This macro uses the `notpossible` keyword and is intended for things
- * like systems integration, where we know for a fact that something is
- * never going to happen, but there's no proof. So we don't want to add
- * extra bloat for filenames and line numbers, since `ShowCrashReports`
- * can print a backtrace if we just embed the UD2 instruction to crash.
- * That's useful for systems code, for the following reason. Invariants
- * make sense with _unassert() since they usually get placed at the top
- * of functions. But if you used _unassert() to test a system call does
- * not fail, then check happens at the end of your function usually and
- * is therefore likely to result in a failure condition where execution
- * falls through into a different function, which is shocking to debug.
- *
- * In `MODE=tiny` these assertions are redefined as undefined behavior.
- */
-#define _npassert(x)                 \
-  ({                                 \
-    if (__builtin_expect(!(x), 0)) { \
-      notpossible;                   \
-    }                                \
-    (void)0;                         \
-  })
-#else
-#define _npassert(x) _unassert(x)
-#endif
-#endif
-
-#ifdef __GNUC__
-/**
- * Specifies expression being false is undefined behavior.
- *
- * This is a good way to tell the compiler about your invariants, which
- * leads to smaller faster programs. The expression is never removed by
- * the preprocessor so it's recommended that it be free of side-effects
- * if you intend for it to be removed. At the same time, this guarantee
- * makes this assertion useful for things like system calls, since they
- * won't be removed by `NDEBUG` mode.
- *
- * If this assertion fails, the worst possible things can happen unless
- * you've built your binary in `MODE=dbg` since UBSAN is the only thing
- * that's capable of debugging this macro.
- */
 #define _unassert(x)                 \
-  ({                                 \
+  do {                               \
     if (__builtin_expect(!(x), 0)) { \
       unreachable;                   \
     }                                \
-    (void)0;                         \
-  })
-#endif
+  } while (0)
+
+#define _npassert(x)                 \
+  do {                               \
+    if (__builtin_expect(!(x), 0)) { \
+      notpossible;                   \
+    }                                \
+  } while (0)
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/__sig_pending.c

@@ -1,43 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/sig.internal.h"
-#include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigset.h"
-
-/**
- * Determines the pending signals on New Technology.
- *
- * @param pending is to hold the pending signals
- * @threadsafe
- */
-textwindows void __sig_pending(sigset_t *pending) {
-  struct Signal *s;
-  sigemptyset(pending);
-  if (__sig.queue) {
-    __sig_lock();
-    for (s = __sig.queue; s; s = s->next) {
-      if (__sig_is_applicable(s) &&
-          __sighandrvas[s->sig] != (unsigned)(intptr_t)SIG_IGN) {
-        sigaddset(pending, s->sig);
-      }
-    }
-    __sig_unlock();
-  }
-}

libc/calls/_ptsname.c

@@ -1,93 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/syscall-sysv.internal.h"
-#include "libc/calls/syscall_support-sysv.internal.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/fmt/itoa.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/termios.h"
-#include "libc/sysv/errfuns.h"
-
-extern const unsigned FIODGNAME;
-extern const unsigned TIOCPTSNAME;
-extern const unsigned TIOCPTYGNAME;
-
-struct fiodgname_arg {
-  int len;
-  void *buf;
-};
-
-struct ptmget {
-  int cfd;
-  int sfd;
-  char cn[1024];
-  char sn[1024];
-};
-
-int _ptsname(int fd, char *buf, size_t size) {
-  int pty;
-  size_t n;
-  struct ptmget t;
-
-  if (_isptmaster(fd)) {
-    return -1;
-  }
-
-  t.sn[0] = '/';
-  t.sn[1] = 'd';
-  t.sn[2] = 'e';
-  t.sn[3] = 'v';
-  t.sn[4] = '/';
-  t.sn[5] = 0;
-
-  if (IsLinux()) {
-    if (sys_ioctl(fd, TIOCGPTN, &pty)) return -1;
-    t.sn[5] = 'p';
-    t.sn[6] = 't';
-    t.sn[7] = 's';
-    t.sn[8] = '/';
-    FormatInt32(t.sn + 9, pty);
-  } else if (IsXnu()) {
-    if (sys_ioctl(fd, TIOCPTYGNAME, t.sn)) {
-      return -1;
-    }
-  } else if (IsFreebsd()) {
-    struct fiodgname_arg fgn = {sizeof(t.sn) - 5, t.sn + 5};
-    if (sys_ioctl(fd, FIODGNAME, &fgn) == -1) {
-      if (errno == EINVAL) {
-        errno = ERANGE;
-      }
-      return -1;
-    }
-  } else if (IsNetbsd()) {
-    if (sys_ioctl(fd, TIOCPTSNAME, &t)) {
-      return -1;
-    }
-  } else {
-    return enosys();
-  }
-
-  if ((n = strlen(t.sn)) < size) {
-    memcpy(buf, t.sn, n + 1);
-    return 0;
-  } else {
-    return erange();
-  }
-}

libc/calls/_timespec_add.c

@@ -21,7 +21,7 @@
 /**
  * Adds two nanosecond timestamps.
  */
-struct timespec timespec_add(struct timespec x, struct timespec y) {
+struct timespec _timespec_add(struct timespec x, struct timespec y) {
   x.tv_sec += y.tv_sec;
   x.tv_nsec += y.tv_nsec;
   if (x.tv_nsec >= 1000000000) {

libc/calls/_timespec_cmp.c

@@ -19,11 +19,9 @@
 #include "libc/calls/struct/timespec.h"
 
 /**
- * Compares nanosecond timestamps.
- *
- * @return 0 if equal, -1 if `a < b`, or +1 if `a > b`
+ * Compares two nanosecond timestamps.
  */
-int timespec_cmp(struct timespec a, struct timespec b) {
+int _timespec_cmp(struct timespec a, struct timespec b) {
   int cmp;
   if (!(cmp = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec))) {
     cmp = (a.tv_nsec > b.tv_nsec) - (a.tv_nsec < b.tv_nsec);

libc/calls/_timespec_eq.c

@@ -16,11 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/sigset.h"
-#include "libc/str/str.h"
+#include "libc/calls/struct/timespec.h"
 
-sigset_t _sigblockall(void) {
-  sigset_t ss;
-  memset(&ss, -1, sizeof(ss));
-  return _sigsetmask(ss);
+/**
+ * Checks if 𝑥 = 𝑦.
+ */
+bool _timespec_eq(struct timespec x, struct timespec y) {
+  return x.tv_sec == y.tv_sec && x.tv_nsec == y.tv_nsec;
 }

libc/calls/_timespec_frommicros.c

@@ -21,7 +21,7 @@
 /**
  * Converts timespec interval from microseconds.
  */
-struct timespec timespec_frommicros(int64_t x) {
+struct timespec _timespec_frommicros(int64_t x) {
   struct timespec ts;
   ts.tv_sec = x / 1000000;
   ts.tv_nsec = x % 1000000 * 1000;

libc/calls/_timespec_frommillis.c

@@ -21,7 +21,7 @@
 /**
  * Converts timespec interval from milliseconds.
  */
-struct timespec timespec_frommillis(int64_t x) {
+struct timespec _timespec_frommillis(int64_t x) {
   struct timespec ts;
   ts.tv_sec = x / 1000;
   ts.tv_nsec = x % 1000 * 1000000;

libc/calls/_timespec_fromnanos.c

@@ -21,7 +21,7 @@
 /**
  * Converts timespec interval from nanoseconds.
  */
-struct timespec timespec_fromnanos(int64_t x) {
+struct timespec _timespec_fromnanos(int64_t x) {
   struct timespec ts;
   ts.tv_sec = x / 1000000000;
   ts.tv_nsec = x % 1000000000;

libc/calls/_timespec_get.c

@@ -26,7 +26,6 @@
  * @param ts receives `CLOCK_REALTIME` timestamp
  * @param base must be `TIME_UTC`
  * @return `base` on success, or `0` on failure
- * @see timespec_real()
  */
 int timespec_get(struct timespec *ts, int base) {
   if (base == TIME_UTC && !clock_gettime(CLOCK_REALTIME, ts)) {

libc/calls/_timespec_gt.c

@@ -0,0 +1,34 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+
+/**
+ * Returns true if timespec `x` is greater than `y`.
+ */
+bool _timespec_gt(struct timespec x, struct timespec y) {
+  if (x.tv_sec > y.tv_sec) {
+    return true;
+  }
+  if (x.tv_sec == y.tv_sec) {
+    if (x.tv_nsec > y.tv_nsec) {
+      return true;
+    }
+  }
+  return false;
+}

libc/calls/_timespec_gte.c

@@ -16,14 +16,13 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/timeval.h"
+#include "libc/calls/struct/timespec.h"
 
 /**
- * Converts timeval interval from microseconds.
+ * Checks if 𝑥 ≥ 𝑦.
  */
-struct timeval timeval_frommicros(int64_t x) {
-  struct timeval tv;
-  tv.tv_sec = x / 1000000;
-  tv.tv_usec = x % 1000000;
-  return tv;
+bool _timespec_gte(struct timespec x, struct timespec y) {
+  if (x.tv_sec > y.tv_sec) return true;
+  if (x.tv_sec < y.tv_sec) return false;
+  return x.tv_nsec >= y.tv_nsec;
 }

libc/calls/_timespec_mono.c

@@ -19,16 +19,13 @@
 #include "libc/assert.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/sysv/consts/clock.h"
+#include "libc/sysv/consts/nr.h"
+#include "libc/time/time.h"
 
-/**
- * Returns current monotonic time.
- *
- * This function uses a `CLOCK_MONOTONIC` clock and never fails.
- *
- * @see timespec_real()
- */
-struct timespec timespec_mono(void) {
+struct timespec _timespec_mono(void) {
+  int ax, dx;
   struct timespec ts;
-  _npassert(!clock_gettime(CLOCK_MONOTONIC, &ts));
+  ax = clock_gettime(CLOCK_MONOTONIC_FAST, &ts);
+  assert(!ax);
   return ts;
 }

libc/calls/_timespec_real.c

@@ -0,0 +1,30 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/sysv/consts/nr.h"
+#include "libc/time/time.h"
+
+struct timespec _timespec_real(void) {
+  int ax, dx;
+  struct timespec ts;
+  ax = clock_gettime(CLOCK_REALTIME_FAST, &ts);
+  if (ax) notpossible;
+  return ts;
+}

libc/calls/_timespec_sub.c

@@ -21,7 +21,7 @@
 /**
  * Subtracts two nanosecond timestamps.
  */
-struct timespec timespec_sub(struct timespec a, struct timespec b) {
+struct timespec _timespec_sub(struct timespec a, struct timespec b) {
   a.tv_sec -= b.tv_sec;
   if (a.tv_nsec < b.tv_nsec) {
     a.tv_nsec += 1000000000;

libc/calls/_timespec_tomicros.c

@@ -0,0 +1,33 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+#include "libc/limits.h"
+
+/**
+ * Converts timespec interval to microseconds.
+ */
+int64_t _timespec_tomicros(struct timespec x) {
+  int64_t us;
+  if (!__builtin_mul_overflow(x.tv_sec, 1000000ul, &us) &&
+      !__builtin_add_overflow(us, x.tv_nsec / 1000, &us)) {
+    return us;
+  } else {
+    return INT64_MAX;
+  }
+}

libc/calls/_timespec_tomillis.c

@@ -0,0 +1,33 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+#include "libc/limits.h"
+
+/**
+ * Converts timespec interval to milliseconds.
+ */
+int64_t _timespec_tomillis(struct timespec x) {
+  int64_t ms;
+  if (!__builtin_mul_overflow(x.tv_sec, 1000ul, &ms) &&
+      !__builtin_add_overflow(ms, x.tv_nsec / 1000000, &ms)) {
+    return ms;
+  } else {
+    return INT64_MAX;
+  }
+}

libc/calls/_timespec_tonanos.c

@@ -0,0 +1,33 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+#include "libc/limits.h"
+
+/**
+ * Converts timespec interval to nanoseconds.
+ */
+int64_t _timespec_tonanos(struct timespec x) {
+  int64_t ns;
+  if (!__builtin_mul_overflow(x.tv_sec, 1000000000ul, &ns) &&
+      !__builtin_add_overflow(ns, x.tv_nsec, &ns)) {
+    return ns;
+  } else {
+    return INT64_MAX;
+  }
+}

libc/calls/_timespec_totimeval.c

@@ -16,9 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/locale.h"
-#include "libc/str/str.h"
+#include "libc/calls/struct/timeval.h"
 
-int strcasecmp_l(const char *a, const char *b, locale_t l) {
-  return strcasecmp(a, b);
+struct timeval _timespec_totimeval(struct timespec ts) {
+  return (struct timeval){ts.tv_sec, ts.tv_nsec / 1000};
 }

libc/calls/_timeval_add.c

@@ -21,7 +21,7 @@
 /**
  * Adds two microsecond timestamps.
  */
-struct timeval timeval_add(struct timeval x, struct timeval y) {
+struct timeval _timeval_add(struct timeval x, struct timeval y) {
   x.tv_sec += y.tv_sec;
   x.tv_usec += y.tv_usec;
   if (x.tv_usec >= 1000000) {

libc/calls/_timeval_totimespec.c

@@ -18,9 +18,6 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timeval.h"
 
-/**
- * Coerces `tv` from 1e-6 to 1e-9 granularity.
- */
-struct timespec timeval_totimespec(struct timeval tv) {
+struct timespec _timeval_totimespec(struct timeval tv) {
   return (struct timespec){tv.tv_sec, tv.tv_usec * 1000};
 }

libc/calls/access.c

@@ -22,14 +22,9 @@
 /**
  * Checks if effective user can access path in particular ways.
  *
- * This is equivalent to saying:
- *
- *     faccessat(AT_FDCWD, path, mode, 0);
- *
  * @param path is a filename or directory
  * @param mode can be R_OK, W_OK, X_OK, F_OK
- * @return 0 if ok, or -1 w/ errno
- * @see faccessat() for further documentation
+ * @return 0 if ok, or -1 and sets errno
  * @asyncsignalsafe
  */
 int access(const char *path, int mode) {

libc/calls/addrusage.c

@@ -22,9 +22,9 @@
 /**
  * Accumulates resource statistics in `y` to `x`.
  */
-void rusage_add(struct rusage *x, const struct rusage *y) {
-  x->ru_utime = timeval_add(x->ru_utime, y->ru_utime);
-  x->ru_stime = timeval_add(x->ru_stime, y->ru_stime);
+void _addrusage(struct rusage *x, const struct rusage *y) {
+  x->ru_utime = _timeval_add(x->ru_utime, y->ru_utime);
+  x->ru_stime = _timeval_add(x->ru_stime, y->ru_stime);
   x->ru_maxrss = MAX(x->ru_maxrss, y->ru_maxrss);
   x->ru_ixrss += y->ru_ixrss;
   x->ru_idrss += y->ru_idrss;

libc/calls/alarm.c

@@ -32,10 +32,12 @@
  * @asyncsignalsafe
  */
 unsigned alarm(unsigned seconds) {
+  int rc;
   struct itimerval it;
   bzero(&it, sizeof(it));
   it.it_value.tv_sec = seconds;
-  _npassert(!setitimer(ITIMER_REAL, &it, &it));
+  rc = setitimer(ITIMER_REAL, &it, &it);
+  assert(rc != -1);
   if (!it.it_value.tv_sec && !it.it_value.tv_usec) {
     return 0;
   } else {

libc/calls/asan.internal.h

@@ -1,8 +1,7 @@
 #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/asmflag.h"
+#include "libc/calls/struct/timespec.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
@@ -15,10 +14,6 @@ forceinline bool __asan_is_valid_timespec(const struct timespec *ts) {
   return zf;
 }
 
-forceinline bool __asan_is_valid_timeval(const struct timeval *tv) {
-  return __asan_is_valid_timespec((const struct timespec *)tv);
-}
-
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_LIBC_CALLS_ASAN_INTERNAL_H_ */

libc/calls/blockcancel.internal.h

@@ -1,22 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_BLOCKCANCEL_H_
-#define COSMOPOLITAN_LIBC_CALLS_BLOCKCANCEL_H_
-#include "libc/thread/thread.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-COSMOPOLITAN_C_START_
-
-#define BLOCK_CANCELLATIONS \
-  do {                      \
-    int _CancelState;       \
-  _CancelState = _pthread_block_cancellations()
-
-#define ALLOW_CANCELLATIONS                   \
-  _pthread_allow_cancellations(_CancelState); \
-  }                                           \
-  while (0)
-
-int _pthread_block_cancellations(void);
-void _pthread_allow_cancellations(int);
-
-COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_CALLS_BLOCKCANCEL_H_ */

libc/calls/blocksigs.internal.h

@@ -1,19 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_BLOCKSIGS_H_
-#define COSMOPOLITAN_LIBC_CALLS_BLOCKSIGS_H_
-#include "libc/calls/struct/sigset.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-COSMOPOLITAN_C_START_
-
-#define BLOCK_SIGNALS  \
-  do {                 \
-    sigset_t _SigMask; \
-  _SigMask = _sigblockall()
-
-#define ALLOW_SIGNALS    \
-  _sigsetmask(_SigMask); \
-  }                      \
-  while (0)
-
-COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_CALLS_BLOCKSIGS_H_ */

libc/calls/calls.h

@@ -5,25 +5,6 @@
 #define _POSIX2_VERSION _POSIX_VERSION
 #define _XOPEN_VERSION  700
 
-#define _POSIX_MAPPED_FILES               _POSIX_VERSION
-#define _POSIX_FSYNC                      _POSIX_VERSION
-#define _POSIX_IPV6                       _POSIX_VERSION
-#define _POSIX_THREADS                    _POSIX_VERSION
-#define _POSIX_THREAD_PROCESS_SHARED      _POSIX_VERSION
-#define _POSIX_THREAD_SAFE_FUNCTIONS      _POSIX_VERSION
-#define _POSIX_THREAD_ATTR_STACKADDR      _POSIX_VERSION
-#define _POSIX_THREAD_ATTR_STACKSIZE      _POSIX_VERSION
-#define _POSIX_THREAD_PRIORITY_SCHEDULING _POSIX_VERSION
-#define _POSIX_THREAD_CPUTIME             _POSIX_VERSION
-#define _POSIX_TIMEOUTS                   _POSIX_VERSION
-#define _POSIX_MONOTONIC_CLOCK            _POSIX_VERSION
-#define _POSIX_CPUTIME                    _POSIX_VERSION
-#define _POSIX_BARRIERS                   _POSIX_VERSION
-#define _POSIX_SPIN_LOCKS                 _POSIX_VERSION
-#define _POSIX_READER_WRITER_LOCKS        _POSIX_VERSION
-#define _POSIX_SEMAPHORES                 _POSIX_VERSION
-#define _POSIX_SHARED_MEMORY_OBJECTS      _POSIX_VERSION
-
 #define EOF      -1         /* end of file */
 #define WEOF     -1u        /* end of file (multibyte) */
 #define _IOFBF   0          /* fully buffered */
@@ -54,10 +35,11 @@
 #define WIFCONTINUED(s) ((s) == 0xffff)
 #define WIFEXITED(s)    (!WTERMSIG(s))
 #define WIFSIGNALED(s)  ((0xffff & (s)) - 1u < 0xffu)
-#define WIFSTOPPED(s)   ((255 & (s)) == 127)
-#define WSTOPSIG(s)     WEXITSTATUS(s)
-#define WTERMSIG(s)     (127 & (s))
-#define W_STOPCODE(s)   ((s) << 8 | 0177)
+#define WIFSTOPPED(s) \
+  ((short)(((0xffff & (unsigned)(s)) * 0x10001) >> 8) > 0x7f00)
+#define WSTOPSIG(s)   WEXITSTATUS(s)
+#define WTERMSIG(s)   (127 & (s))
+#define W_STOPCODE(s) ((s) << 8 | 0177)
 
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
@@ -83,13 +65,13 @@ char *ttyname(int);
 int access(const char *, int) dontthrow;
 int arch_prctl();
 int chdir(const char *);
-int chmod(const char *, unsigned);
-int chown(const char *, unsigned, unsigned);
+int chmod(const char *, uint32_t);
+int chown(const char *, uint32_t, uint32_t);
 int chroot(const char *);
 int close(int);
 int close_range(unsigned, unsigned, unsigned);
 int closefrom(int);
-int creat(const char *, unsigned);
+int creat(const char *, uint32_t);
 int dup(int);
 int dup2(int, int);
 int dup3(int, int, int);
@@ -102,22 +84,24 @@ int execv(const char *, char *const[]);
 int execve(const char *, char *const[], char *const[]);
 int execvp(const char *, char *const[]);
 int execvpe(const char *, char *const[], char *const[]);
-int faccessat(int, const char *, int, int);
+int faccessat(int, const char *, int, uint32_t);
 int fadvise(int, uint64_t, uint64_t, int);
 int fchdir(int);
-int fchmod(int, unsigned) dontthrow;
-int fchmodat(int, const char *, unsigned, int);
-int fchown(int, unsigned, unsigned);
-int fchownat(int, const char *, unsigned, unsigned, int);
+int fchmod(int, uint32_t) dontthrow;
+int fchmodat(int, const char *, uint32_t, int);
+int fchown(int, uint32_t, uint32_t);
+int fchownat(int, const char *, uint32_t, uint32_t, int);
 int fcntl(int, int, ...);
 int fdatasync(int);
-int fexecve(int, char *const[], char *const[]);
 int flock(int, int);
 int fork(void);
 int fsync(int);
 int ftruncate(int, int64_t);
 int getdomainname(char *, size_t);
-int getgroups(int, unsigned[]);
+uint32_t getegid(void) nosideeffect;
+uint32_t geteuid(void) nosideeffect;
+uint32_t getgid(void) nosideeffect;
+int getgroups(int size, uint32_t list[]);
 int gethostname(char *, size_t);
 int getloadavg(double *, int);
 int getpgid(int) libcesque;
@@ -125,29 +109,35 @@ int getpgrp(void) nosideeffect;
 int getpid(void) nosideeffect libcesque;
 int getppid(void);
 int getpriority(int, unsigned);
-int getresgid(unsigned *, unsigned *, unsigned *);
-int getresuid(unsigned *, unsigned *, unsigned *);
+int getresgid(uint32_t *, uint32_t *, uint32_t *);
+int getresuid(uint32_t *, uint32_t *, uint32_t *);
 int getsid(int) nosideeffect libcesque;
 int gettid(void) libcesque;
+uint32_t getuid(void) libcesque;
+int sys_iopl(int);
 int ioprio_get(int, int);
 int ioprio_set(int, int, int);
 int issetugid(void);
 int kill(int, int);
 int killpg(int, int);
-int lchmod(const char *, unsigned);
-int lchown(const char *, unsigned, unsigned);
+int lchmod(const char *, uint32_t);
+int lchown(const char *, uint32_t, uint32_t);
 int link(const char *, const char *) dontthrow;
 int linkat(int, const char *, int, const char *, int);
 int madvise(void *, uint64_t, int);
-int makedirs(const char *, unsigned);
 int memfd_create(const char *, unsigned int);
 int mincore(void *, size_t, unsigned char *);
-int mkdir(const char *, unsigned);
-int mkdirat(int, const char *, unsigned);
-int mkfifo(const char *, unsigned);
-int mkfifoat(int, const char *, unsigned);
-int mknod(const char *, unsigned, uint64_t);
-int mknodat(int, const char *, int, uint64_t);
+int mkdir(const char *, uint32_t);
+int mkdirat(int, const char *, uint32_t);
+int mkfifo(const char *, uint32_t);
+int mkfifoat(int, const char *, uint32_t);
+int mknod(const char *, uint32_t, uint64_t);
+int mknodat(int, const char *, int32_t, uint64_t);
+int sys_mlock(const void *, size_t);
+int sys_mlock2(const void *, size_t, int);
+int sys_mlockall(int);
+int sys_munlock(const void *, size_t);
+int sys_munlockall(void);
 int nice(int);
 int open(const char *, int, ...);
 int openat(int, const char *, int, ...);
@@ -157,7 +147,7 @@ int pipe(int[hasatleast 2]);
 int pipe2(int[hasatleast 2], int);
 int pivot_root(const char *, const char *);
 int pledge(const char *, const char *);
-int posix_fadvise(int, int64_t, int64_t, int);
+int posix_fadvise(int, uint64_t, uint64_t, int);
 int posix_madvise(void *, uint64_t, int);
 int prctl(int, ...);
 int raise(int);
@@ -169,42 +159,36 @@ int renameat2(long, const char *, long, const char *, int);
 int rmdir(const char *);
 int sched_yield(void);
 int seccomp(unsigned, unsigned, void *);
-int setegid(unsigned);
-int seteuid(unsigned);
-int setfsgid(unsigned);
-int setfsuid(unsigned);
-int setgid(unsigned);
-int setgroups(size_t, const unsigned[]);
+int setegid(uint32_t);
+int seteuid(uint32_t);
+int setfsgid(int);
+int setfsuid(int);
+int setgid(int);
+int setgroups(size_t size, const uint32_t list[]);
 int setpgid(int, int);
 int setpgrp(void);
 int setpriority(int, unsigned, int);
-int setregid(unsigned, unsigned);
-int setresgid(unsigned, unsigned, unsigned);
-int setresuid(unsigned, unsigned, unsigned);
-int setreuid(unsigned, unsigned);
+int setregid(uint32_t, uint32_t);
+int setresgid(uint32_t, uint32_t, uint32_t);
+int setresuid(uint32_t, uint32_t, uint32_t);
+int setreuid(uint32_t, uint32_t);
 int setsid(void);
-int setuid(unsigned);
+int setuid(int);
 int sigignore(int);
 int siginterrupt(int, int);
 int symlink(const char *, const char *);
 int symlinkat(const char *, int, const char *);
 int sync_file_range(int, int64_t, int64_t, unsigned);
-int sys_iopl(int);
-int sys_mlock(const void *, size_t);
-int sys_mlock2(const void *, size_t, int);
-int sys_mlockall(int);
-int sys_munlock(const void *, size_t);
-int sys_munlockall(void);
 int sys_ptrace(int, ...);
 int sys_sysctl(const int *, unsigned, void *, size_t *, void *, size_t);
-int tcgetpgrp(int);
-int tcsetpgrp(int, int);
+int tcsetpgrp(int, int32_t);
 int tgkill(int, int, int);
 int tkill(int, int);
 int tmpfd(void);
-int touch(const char *, unsigned);
-int truncate(const char *, int64_t);
+int touch(const char *, uint32_t);
+int truncate(const char *, uint64_t);
 int ttyname_r(int, char *, size_t);
+int umask(int);
 int unlink(const char *);
 int unlink_s(const char **);
 int unlinkat(int, const char *, int);
@@ -213,25 +197,21 @@ int usleep(unsigned);
 int vfork(void) returnstwice;
 int wait(int *);
 int waitpid(int, int *, int);
+int32_t tcgetpgrp(int);
 intptr_t syscall(int, ...);
 long ptrace(int, ...);
-ssize_t copy_file_range(int, long *, int, long *, size_t, unsigned);
-ssize_t copyfd(int, int64_t *, int, int64_t *, size_t, unsigned);
+ssize_t copy_file_range(int, long *, int, long *, size_t, uint32_t);
+ssize_t copyfd(int, int64_t *, int, int64_t *, size_t, uint32_t);
 ssize_t getfiledescriptorsize(int);
-ssize_t lseek(int, int64_t, int);
+ssize_t lseek(int, int64_t, unsigned);
 ssize_t pread(int, void *, size_t, int64_t);
 ssize_t pwrite(int, const void *, size_t, int64_t);
 ssize_t read(int, void *, size_t);
 ssize_t readansi(int, char *, size_t);
 ssize_t readlink(const char *, char *, size_t);
 ssize_t readlinkat(int, const char *, char *, size_t);
-ssize_t splice(int, int64_t *, int, int64_t *, size_t, unsigned);
+ssize_t splice(int, int64_t *, int, int64_t *, size_t, uint32_t);
 ssize_t write(int, const void *, size_t);
-unsigned getegid(void) nosideeffect;
-unsigned geteuid(void) nosideeffect;
-unsigned getgid(void) nosideeffect;
-unsigned getuid(void) libcesque;
-unsigned umask(unsigned);
 void sync(void);
 
 COSMOPOLITAN_C_END_

libc/calls/calls.mk

@@ -65,13 +65,6 @@ $(LIBC_CALLS_A).pkg:					\
 		$(LIBC_CALLS_A_OBJS)			\
 		$(foreach x,$(LIBC_CALLS_A_DIRECTDEPS),$($(x)_A).pkg)
 
-# we can't use asan because:
-#   siginfo_t memory is owned by kernels
-o/$(MODE)/libc/calls/siginfo2cosmo.o: private		\
-		OVERRIDE_COPTS +=			\
-			-ffreestanding			\
-			-fno-sanitize=address
-
 # we can't use asan because:
 #   ucontext_t memory is owned by xnu kernel
 o/$(MODE)/libc/calls/sigenter-xnu.o: private		\
@@ -104,7 +97,6 @@ o/$(MODE)/libc/calls/ntcontext2linux.o: private		\
 
 # we always want -O3 because:
 #   it makes the code size smaller too
-o/$(MODE)/libc/calls/termios2host.o			\
 o/$(MODE)/libc/calls/sigenter-freebsd.o			\
 o/$(MODE)/libc/calls/sigenter-netbsd.o			\
 o/$(MODE)/libc/calls/sigenter-openbsd.o			\
@@ -121,12 +113,21 @@ o/$(MODE)/libc/calls/execlp.o				\
 o/$(MODE)/libc/calls/statfs.o				\
 o/$(MODE)/libc/calls/fstatfs.o				\
 o/$(MODE)/libc/calls/execve-sysv.o			\
-o/$(MODE)/libc/calls/readlinkat-nt.o			\
 o/$(MODE)/libc/calls/execve-nt.greg.o			\
 o/$(MODE)/libc/calls/mkntenvblock.o: private		\
 		OVERRIDE_CPPFLAGS +=			\
 			-DSTACK_FRAME_UNLIMITED
 
+# we must disable static stack safety because:
+#   PATH_MAX*sizeof(char16_t)*2 exceeds 4096 byte frame limit
+o/$(MODE)/libc/calls/copyfile.o				\
+o/$(MODE)/libc/calls/symlinkat-nt.o			\
+o/$(MODE)/libc/calls/readlinkat-nt.o			\
+o/$(MODE)/libc/calls/linkat-nt.o			\
+o/$(MODE)/libc/calls/renameat-nt.o: private		\
+		OVERRIDE_CPPFLAGS +=			\
+			-DSTACK_FRAME_UNLIMITED
+
 # we must segregate codegen because:
 #   file contains multiple independently linkable apis
 o/$(MODE)/libc/calls/ioctl-siocgifconf.o		\
@@ -170,15 +171,12 @@ o//libc/calls/statfs2cosmo.o: private			\
 # we always want -O2 because:
 #   division is expensive if not optimized
 o/$(MODE)/libc/calls/clock.o				\
-o/$(MODE)/libc/calls/timespec_tomillis.o		\
-o/$(MODE)/libc/calls/timespec_tomicros.o		\
-o/$(MODE)/libc/calls/timespec_totimeval.o		\
-o/$(MODE)/libc/calls/timespec_fromnanos.o		\
-o/$(MODE)/libc/calls/timespec_frommillis.o		\
-o/$(MODE)/libc/calls/timespec_frommicros.o		\
-o/$(MODE)/libc/calls/timeval_tomillis.o			\
-o/$(MODE)/libc/calls/timeval_frommillis.o		\
-o/$(MODE)/libc/calls/timeval_frommicros.o: private	\
+o/$(MODE)/libc/calls/_timespec_tomillis.o		\
+o/$(MODE)/libc/calls/_timespec_tomicros.o		\
+o/$(MODE)/libc/calls/_timespec_totimeval.o		\
+o/$(MODE)/libc/calls/_timespec_fromnanos.o		\
+o/$(MODE)/libc/calls/_timespec_frommillis.o		\
+o/$(MODE)/libc/calls/_timespec_frommicros.o: private	\
 		OVERRIDE_CFLAGS +=			\
 			-O2
 

libc/calls/cfgetispeed.c

@@ -1,7 +1,7 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
 │vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
 ╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@@ -16,14 +16,13 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/runtime/runtime.h"
+#include "libc/calls/termios.h"
+#include "libc/sysv/consts/termios.h"
 
-const char *GetCpuidEmulator(void) {
-  static bool once;
-  static char s[13];
-  if (!once) {
-    GetCpuidBrand(s, 0x40000000);
-    once = true;
+uint32_t cfgetispeed(const struct termios *t) {
+  if (CBAUD) {
+    return t->c_cflag & CBAUD;
+  } else {
+    return t->c_ispeed;
   }
-  return s;
 }

libc/calls/cfgetospeed.c

@@ -1,7 +1,7 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
 │vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
 ╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@@ -16,14 +16,13 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/runtime/runtime.h"
+#include "libc/calls/termios.h"
+#include "libc/sysv/consts/termios.h"
 
-const char *GetCpuidOs(void) {
-  static bool once;
-  static char s[13];
-  if (!once) {
-    GetCpuidBrand(s, 0x40031337);
-    once = true;
+uint32_t cfgetospeed(const struct termios *t) {
+  if (CBAUD) {
+    return t->c_cflag & CBAUD;
+  } else {
+    return t->c_ospeed;
   }
-  return s;
 }

libc/calls/cfsetispeed.c

@@ -0,0 +1,33 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/termios.h"
+#include "libc/sysv/errfuns.h"
+
+int cfsetispeed(struct termios *t, int speed) {
+  if (speed) {
+    if (CBAUD) {
+      if (speed & ~CBAUD) return einval();
+      t->c_cflag &= ~CBAUD;
+      t->c_cflag |= speed;
+    } else {
+      t->c_ispeed = speed;
+    }
+  }
+  return 0;
+}

libc/calls/cfsetospeed.c

@@ -1,7 +1,7 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
 │vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
 ╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@@ -16,23 +16,21 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/syscall-sysv.internal.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
+#include "libc/calls/termios.h"
 #include "libc/sysv/consts/termios.h"
+#include "libc/sysv/errfuns.h"
 
-int _isptmaster(int fd) {
-  if (IsFreebsd()) {
-    if (!sys_ioctl(fd, TIOCPTMASTER)) {
+int cfsetospeed(struct termios *t, int speed) {
+  if (CBAUD) {
+    if (!(speed & ~CBAUD)) {
+      t->c_cflag &= ~CBAUD;
+      t->c_cflag |= speed;
       return 0;
     } else {
-      if (errno != EBADF) {
-        errno = EINVAL;
-      }
-      return -1;
+      return einval();
     }
   } else {
+    t->c_ospeed = speed;
     return 0;
   }
 }

libc/calls/cfspeed.c

@@ -1,88 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/termios.h"
-#include "libc/sysv/consts/termios.h"
-#include "libc/sysv/errfuns.h"
-
-/**
- * Returns input baud rate.
- * @asyncsignalsafe
- */
-uint32_t cfgetispeed(const struct termios *t) {
-  if (CBAUD) {
-    return t->c_cflag & CBAUD;
-  } else {
-    return t->c_ispeed;
-  }
-}
-
-/**
- * Returns output baud rate.
- * @asyncsignalsafe
- */
-uint32_t cfgetospeed(const struct termios *t) {
-  if (CBAUD) {
-    return t->c_cflag & CBAUD;
-  } else {
-    return t->c_ospeed;
-  }
-}
-
-/**
- * Sets input baud rate.
- *
- * @return 0 on success, or -1 w/ errno
- * @asyncsignalsafe
- */
-int cfsetispeed(struct termios *t, unsigned speed) {
-  if (speed) {
-    if (CBAUD) {
-      if (!(speed & ~CBAUD)) {
-        t->c_cflag &= ~CBAUD;
-        t->c_cflag |= speed;
-      } else {
-        return einval();
-      }
-    } else {
-      t->c_ispeed = speed;
-    }
-  }
-  return 0;
-}
-
-/**
- * Sets output baud rate.
- *
- * @return 0 on success, or -1 w/ errno
- * @asyncsignalsafe
- */
-int cfsetospeed(struct termios *t, unsigned speed) {
-  if (CBAUD) {
-    if (!(speed & ~CBAUD)) {
-      t->c_cflag &= ~CBAUD;
-      t->c_cflag |= speed;
-      return 0;
-    } else {
-      return einval();
-    }
-  } else {
-    t->c_ospeed = speed;
-    return 0;
-  }
-}

libc/calls/chdir-nt.c

@@ -26,36 +26,35 @@
 #include "libc/nt/synchronization.h"
 #include "libc/sysv/errfuns.h"
 
-textwindows int sys_chdir_nt_impl(char16_t path[hasatleast PATH_MAX],
-                                  uint32_t len) {
+textwindows int sys_chdir_nt(const char *path) {
   uint32_t n;
-  int e, ms, err;
-  char16_t var[4];
-
-  if (len && path[len - 1] != u'\\') {
+  int e, ms, err, len;
+  char16_t path16[PATH_MAX], var[4];
+  if ((len = __mkntpath(path, path16)) == -1) return -1;
+  if (!len) return enoent();
+  if (len && path16[len - 1] != u'\\') {
     if (len + 2 > PATH_MAX) return enametoolong();
-    path[len + 0] = u'\\';
-    path[len + 1] = u'\0';
+    path16[len + 0] = u'\\';
+    path16[len + 1] = u'\0';
   }
-
   /*
    * chdir() seems flaky on windows 7
    * in a similar way to rmdir() sigh
    */
   for (err = errno, ms = 1;; ms *= 2) {
-    if (SetCurrentDirectory(path)) {
+    if (SetCurrentDirectory(path16)) {
       /*
        * Now we need to set a magic environment variable.
        */
-      if ((n = GetCurrentDirectory(PATH_MAX, path))) {
-        if (n < PATH_MAX) {
-          if (!((path[0] == '/' && path[1] == '/') ||
-                (path[0] == '\\' && path[1] == '\\'))) {
+      if ((n = GetCurrentDirectory(ARRAYLEN(path16), path16))) {
+        if (n < ARRAYLEN(path16)) {
+          if (!((path16[0] == '/' && path16[1] == '/') ||
+                (path16[0] == '\\' && path16[1] == '\\'))) {
             var[0] = '=';
-            var[1] = path[0];
+            var[1] = path16[0];
             var[2] = ':';
             var[3] = 0;
-            if (!SetEnvironmentVariable(var, path)) {
+            if (!SetEnvironmentVariable(var, path16)) {
               return __winerr();
             }
           }
@@ -78,13 +77,5 @@ textwindows int sys_chdir_nt_impl(char16_t path[hasatleast PATH_MAX],
       }
     }
   }
-  return __fix_enotdir(-1, path);
-}
-
-textwindows int sys_chdir_nt(const char *path) {
-  int len;
-  char16_t path16[PATH_MAX];
-  if ((len = __mkntpath(path, path16)) == -1) return -1;
-  if (!len) return enoent();
-  return sys_chdir_nt_impl(path16, len);
+  return __fix_enotdir(-1, path16);
 }

libc/calls/chdir.c

@@ -16,12 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/strace.internal.h"
 #include "libc/calls/syscall-nt.internal.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/runtime/runtime.h"
 #include "libc/sysv/errfuns.h"
 
 /**
@@ -35,8 +34,7 @@
  */
 int chdir(const char *path) {
   int rc;
-  GetProgramExecutableName();  // XXX: ugly workaround
-  if (!path || (IsAsan() && !__asan_is_valid_str(path))) {
+  if (!path || (IsAsan() && !__asan_is_valid(path, 1))) {
     rc = efault();
   } else if (!IsWindows()) {
     rc = sys_chdir(path);

libc/calls/chroot.c

@@ -17,43 +17,17 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #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"
+#include "libc/calls/syscall-sysv.internal.h"
 
 /**
  * Changes root directory.
  *
- * Please consider using unveil() instead of chroot(). If you use this
- * system call then consider using both chdir() and closefrom() before
- * calling this function. Otherwise there's a small risk that fchdir()
- * could be used to escape the chroot() environment. Cosmopolitan Libc
- * focuses on static binaries which make chroot() infinitely easier to
- * use since you don't need to construct an entire userspace each time
- * however unveil() is still better to use on modern Linux and OpenBSD
- * because it doesn't require root privileges.
- *
- * @param path shall become the new root directory
- * @return 0 on success, or -1 w/ errno
- * @raise EACCES if we don't have permission to search a component of `path`
- * @raise ENOTDIR if a directory component in `path` exists as non-directory
- * @raise ENAMETOOLONG if symlink-resolved `path` length exceeds `PATH_MAX`
- * @raise ENAMETOOLONG if component in `path` exists longer than `NAME_MAX`
- * @raise EPERM if not root or pledge() is in play
- * @raise EIO if a low-level i/o error occurred
- * @raise EFAULT if `path` is bad memory
- * @raise ENOENT if `path` doesn't exist
  * @raise ENOSYS on Windows
  */
 int chroot(const char *path) {
   int rc;
-  if (!path || (IsAsan() && !__asan_is_valid_str(path))) {
-    rc = efault();
-  } else {
-    rc = sys_chroot(path);
-  }
+  rc = sys_chroot(path);
   STRACE("chroot(%s) → %d% m", path, rc);
   return rc;
 }

libc/calls/clock.c

@@ -55,7 +55,7 @@ int64_t clock(void) {
   if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) == -1) {
     errno = e;
     if (getrusage(RUSAGE_SELF, &ru) != -1) {
-      ts = timeval_totimespec(timeval_add(ru.ru_utime, ru.ru_stime));
+      ts = _timeval_totimespec(_timeval_add(ru.ru_utime, ru.ru_stime));
     } else {
       return -1;
     }

libc/calls/clock_getres.c

@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/asan.internal.h"
+#include "libc/intrin/strace.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"
@@ -49,12 +49,6 @@ static int sys_clock_getres_xnu(int clock, struct timespec *ts) {
 
 /**
  * Returns granularity of clock.
- *
- * @return 0 on success, or -1 w/ errno
- * @error EPERM if pledge() is in play without stdio promise
- * @error EINVAL if `clock` isn't supported on this system
- * @error EFAULT if `ts` points to bad memory
- * @threadsafe
  */
 int clock_getres(int clock, struct timespec *ts) {
   int rc;

libc/calls/clock_gettime-mono.c

@@ -17,11 +17,11 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timespec.h"
+#include "libc/thread/thread.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/thread/thread.h"
 
 static struct {
   pthread_once_t once;
@@ -30,7 +30,7 @@ static struct {
 } g_mono;
 
 static void sys_clock_gettime_mono_init(void) {
-  g_mono.base_wall = timespec_real();
+  g_mono.base_wall = _timespec_real();
   g_mono.base_tick = rdtsc();
 }
 
@@ -42,7 +42,7 @@ int sys_clock_gettime_mono(struct timespec *time) {
     pthread_once(&g_mono.once, sys_clock_gettime_mono_init);
     cycles = rdtsc() - g_mono.base_tick;
     nanos = cycles / 3;
-    *time = timespec_add(g_mono.base_wall, timespec_fromnanos(nanos));
+    *time = _timespec_add(g_mono.base_wall, _timespec_fromnanos(nanos));
     return 0;
   } else {
     return einval();

libc/calls/clock_gettime.c

@@ -20,6 +20,7 @@
 #include "libc/calls/asan.internal.h"
 #include "libc/calls/clock_gettime.internal.h"
 #include "libc/calls/state.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
@@ -29,11 +30,9 @@
 #include "libc/intrin/asmflag.h"
 #include "libc/intrin/bits.h"
 #include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/mem/alloca.h"
 #include "libc/nt/synchronization.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/thread/tls.h"
 
 /**
  * Returns nanosecond time.
@@ -49,33 +48,12 @@
  *     __clock_gettime     l:        35𝑐        11𝑛𝑠
  *     sys_clock_gettime   l:       220𝑐        71𝑛𝑠
  *
- * @param clock can be one of:
- *    - `CLOCK_REALTIME`: universally supported
- *    - `CLOCK_REALTIME_FAST`: ditto but faster on freebsd
- *    - `CLOCK_REALTIME_PRECISE`: ditto but better on freebsd
- *    - `CLOCK_REALTIME_COARSE`: : like `CLOCK_REALTIME_FAST` w/ Linux 2.6.32+
- *    - `CLOCK_MONOTONIC`: universally supported
- *    - `CLOCK_MONOTONIC_FAST`: ditto but faster on freebsd
- *    - `CLOCK_MONOTONIC_PRECISE`: ditto but better on freebsd
- *    - `CLOCK_MONOTONIC_COARSE`: : like `CLOCK_MONOTONIC_FAST` w/ Linux 2.6.32+
- *    - `CLOCK_MONOTONIC_RAW`: is actually monotonic but needs Linux 2.6.28+
- *    - `CLOCK_PROCESS_CPUTIME_ID`: linux and bsd
- *    - `CLOCK_THREAD_CPUTIME_ID`: linux and bsd
- *    - `CLOCK_MONOTONIC_COARSE`: linux, freebsd
- *    - `CLOCK_PROF`: linux and netbsd
- *    - `CLOCK_BOOTTIME`: linux and openbsd
- *    - `CLOCK_REALTIME_ALARM`: linux-only
- *    - `CLOCK_BOOTTIME_ALARM`: linux-only
- *    - `CLOCK_TAI`: linux-only
+ * @param clock can be CLOCK_REALTIME, CLOCK_MONOTONIC, etc.
  * @param ts is where the result is stored
  * @return 0 on success, or -1 w/ errno
- * @error EPERM if pledge() is in play without stdio promise
- * @error EINVAL if `clock` isn't supported on this system
- * @error EFAULT if `ts` points to bad memory
+ * @error EINVAL if clock isn't supported on this system
  * @see strftime(), gettimeofday()
  * @asyncsignalsafe
- * @threadsafe
- * @vforksafe
  */
 int clock_gettime(int clock, struct timespec *ts) {
   int rc;
@@ -87,7 +65,7 @@ int clock_gettime(int clock, struct timespec *ts) {
     rc = __clock_gettime(clock, ts);
   }
 #if SYSDEBUG
-  if (__tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
+  if (!__time_critical) {
     STRACE("clock_gettime(%s, [%s]) → %d% m", DescribeClockName(clock),
            DescribeTimespec(rc, ts), rc);
   }
@@ -119,7 +97,7 @@ clock_gettime_f *__clock_gettime_get(bool *opt_out_isfast) {
   return res;
 }
 
-_Hide int __clock_gettime_init(int clockid, struct timespec *ts) {
+hidden int __clock_gettime_init(int clockid, struct timespec *ts) {
   clock_gettime_f *gettime;
   __clock_gettime = gettime = __clock_gettime_get(0);
   return gettime(clockid, ts);