Add multicast test that works on Linux

This test unfortunately doesn't work yet on non-Linux platforms, which
wasn't what I expected since the ip_mreq ABI is the same across all of
our supported platforms. There's also an automation issue due to using
INADDR_ANY since it causes popups on Windows.

Makefile

@@ -60,7 +60,7 @@
 #   build/config.mk
 
 SHELL      = build/bootstrap/cocmd.com
-HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 xnu win10 win10:31336
+HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 xnu win10
 MAKEFLAGS += --no-builtin-rules
 
 .SUFFIXES:
@@ -175,7 +175,9 @@ 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
@@ -192,6 +194,7 @@ 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
@@ -278,14 +281,14 @@ o/$(MODE)/hdrs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS
 	$(file >$@) $(foreach x,$(HDRS) $(INCS),$(file >>$@,$(x)))
 
 TAGS: private .UNSANDBOXED = 1
-TAGS:	o/$(MODE)/srcs-old.txt $(SRCS)
+TAGS:	o/$(MODE)/srcs-old.txt $(SRCS) o/$(MODE)/third_party/ctags/ctags.com
 	@$(RM) $@
-	@$(TAGS) $(TAGSFLAGS) -L $< -o $@
+	@o/$(MODE)/third_party/ctags/ctags.com $(TAGSFLAGS) -L $< -o $@
 
 HTAGS: private .UNSANDBOXED = 1
-HTAGS:	o/$(MODE)/hdrs-old.txt $(HDRS)
+HTAGS:	o/$(MODE)/hdrs-old.txt $(HDRS) o/$(MODE)/third_party/ctags/ctags.com
 	@$(RM) $@
-	@build/htags -L $< -o $@
+	@build/htags o/$(MODE)/third_party/ctags/ctags.com -L $< -o $@
 
 loc: private .UNSANDBOXED = 1
 loc: o/$(MODE)/tool/build/summy.com
@@ -371,11 +374,9 @@ COSMOPOLITAN_HEADERS =			\
 	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:							\
@@ -438,9 +439,9 @@ $(SRCS):
 $(HDRS):
 $(INCS):
 .DEFAULT:
-	@$(ECHO) >&2
-	@$(ECHO) NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@ >&2
-	@$(ECHO) >&2
+	@$(ECHO)
+	@$(ECHO) NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@
+	@$(ECHO)
 	$(RM) o/$(MODE)/depend
 
 -include o/$(MODE)/depend

README.md

@@ -57,9 +57,13 @@ 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 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.
+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.
 
 ```sh
 # System-Wide APE Install

ape/ape.S

@@ -116,11 +116,29 @@ cstr:	.endobj	cstr,globl,hidden		# ←for gdb readability
 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.
-//	WARNING: This prefix is experimental; it may be removed sometime.
-//	TODO(jart): Find another prefix that will work with BIOS loading.
-	.asciz	"JTqFpD='\n"		# Mark 'Zibo' Joseph Zbikowski
+	.asciz	"jartsr='\n"		# Justine Alexandra Roberts Tunney
+//	push	$0x61
+//	jb	0x78
+//	jae	0x78
 #endif
 	.short	0x1000			# MZ: lowers upper bound load / 16
 	.short	0xf800			# MZ: roll greed on bss
@@ -140,6 +158,9 @@ ape_mz:
 	.long	RVA(ape_pe)		# PE: the new technology
 #else
 	.long	0
+	.org	0x78
+	pop	%rax
+	jmp	_start
 #endif
 	.endfn	ape_mz,globl,hidden
 
@@ -261,6 +282,9 @@ pc:	cld
 	xor	%dh,%dh				# current head
 	mov	$v_ape_realsectors,%di		# total sectors
 3:	call	pcread
+	mov	%es,%si				# addr += 512
+	add	$512>>4,%si
+	mov	%si,%es
 	dec	%di
 	jnz	3b
 6:	ljmp	$0,$REAL(realmodeloader)
@@ -349,6 +373,7 @@ 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
@@ -387,9 +412,6 @@ 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
 	jbe	2f
@@ -559,6 +581,9 @@ ape_disk:
 
 #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"
 //	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.
@@ -660,17 +685,332 @@ apesh:	.ascii	"\n@\n#'\"\n"			# sixth edition shebang
 	.ascii	"o=\"$t\"\n"
 	.ascii	"exec \"$o\" \"$@\"\n"
 #endif /* APE_NO_MODIFY_SELF */
-	.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	"exit $?\n"
 	.ascii	"fi\n"
-	.ascii	"exit $R\n"
+
+	.ascii	"PHDRS='' <<'@'\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-1.1\"\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"
+
+//	Blink for Linux Generic ARM
+	.ascii	"if [ \"$s\" = Linux ] && [ \"${m#arm}\" != \"$m\" ]; then\n"
+	.ascii	"if ! [ -x \"$e\" ]; then\n"
+	.ascii	"echo \"extracting blink-arm to ${e}\" >&2\n"
+	.ascii	"dd if=\"$o\" bs=1 skip=$(("
+	.byte	blink_arm_b9
+	.byte	blink_arm_b8
+	.byte	blink_arm_b7
+	.byte	blink_arm_b6
+	.byte	blink_arm_b5
+	.byte	blink_arm_b4
+	.byte	blink_arm_b3
+	.byte	blink_arm_b2
+	.byte	blink_arm_b1
+	.byte	blink_arm_b0
+	.ascii	")) count=$(("
+	.byte	blink_arm_size_b9
+	.byte	blink_arm_size_b8
+	.byte	blink_arm_size_b7
+	.byte	blink_arm_size_b6
+	.byte	blink_arm_size_b5
+	.byte	blink_arm_size_b4
+	.byte	blink_arm_size_b3
+	.byte	blink_arm_size_b2
+	.byte	blink_arm_size_b1
+	.byte	blink_arm_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 Linux on Legacy x86
+	.ascii	"if [ \"$s\" = Linux ]; then\n"
+	.ascii	"if [ \"$m\" = i686 ] || [ \"$m\" = i386 ]; then\n"
+	.ascii	"if ! [ -x \"$e\" ]; then\n"
+	.ascii	"echo \"extracting blink-i486 to ${e}\" >&2\n"
+	.ascii	"dd if=\"$o\" bs=1 skip=$(("
+	.byte	blink_i486_b9
+	.byte	blink_i486_b8
+	.byte	blink_i486_b7
+	.byte	blink_i486_b6
+	.byte	blink_i486_b5
+	.byte	blink_i486_b4
+	.byte	blink_i486_b3
+	.byte	blink_i486_b2
+	.byte	blink_i486_b1
+	.byte	blink_i486_b0
+	.ascii	")) count=$(("
+	.byte	blink_i486_size_b9
+	.byte	blink_i486_size_b8
+	.byte	blink_i486_size_b7
+	.byte	blink_i486_size_b6
+	.byte	blink_i486_size_b5
+	.byte	blink_i486_size_b4
+	.byte	blink_i486_size_b3
+	.byte	blink_i486_size_b2
+	.byte	blink_i486_size_b1
+	.byte	blink_i486_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"
+
+//	Blink for Linux on RISC-V
+	.ascii	"if [ \"$s\" = Linux ] && [ \"$m\" = riscv64 ]; then\n"
+	.ascii	"if ! [ -x \"$e\" ]; then\n"
+	.ascii	"echo \"extracting blink-riscv64 to ${e}\" >&2\n"
+	.ascii	"dd if=\"$o\" bs=1 skip=$(("
+	.byte	blink_riscv64_b9
+	.byte	blink_riscv64_b8
+	.byte	blink_riscv64_b7
+	.byte	blink_riscv64_b6
+	.byte	blink_riscv64_b5
+	.byte	blink_riscv64_b4
+	.byte	blink_riscv64_b3
+	.byte	blink_riscv64_b2
+	.byte	blink_riscv64_b1
+	.byte	blink_riscv64_b0
+	.ascii	")) count=$(("
+	.byte	blink_riscv64_size_b9
+	.byte	blink_riscv64_size_b8
+	.byte	blink_riscv64_size_b7
+	.byte	blink_riscv64_size_b6
+	.byte	blink_riscv64_size_b5
+	.byte	blink_riscv64_size_b4
+	.byte	blink_riscv64_size_b3
+	.byte	blink_riscv64_size_b2
+	.byte	blink_riscv64_size_b1
+	.byte	blink_riscv64_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 Linux on MIPS Little Endian, e.g. Ubiquiti EdgerouterX
+	.ascii	"if [ \"$s\" = Linux ] && [ \"$m\" = mips ]; then\n"
+	.ascii	"if ! [ -x \"$e\" ]; then\n"
+	.ascii	"echo \"extracting blink-mipsel to ${e}\" >&2\n"
+	.ascii	"dd if=\"$o\" bs=1 skip=$(("
+	.byte	blink_mipsel_b9
+	.byte	blink_mipsel_b8
+	.byte	blink_mipsel_b7
+	.byte	blink_mipsel_b6
+	.byte	blink_mipsel_b5
+	.byte	blink_mipsel_b4
+	.byte	blink_mipsel_b3
+	.byte	blink_mipsel_b2
+	.byte	blink_mipsel_b1
+	.byte	blink_mipsel_b0
+	.ascii	")) count=$(("
+	.byte	blink_mipsel_size_b9
+	.byte	blink_mipsel_size_b8
+	.byte	blink_mipsel_size_b7
+	.byte	blink_mipsel_size_b6
+	.byte	blink_mipsel_size_b5
+	.byte	blink_mipsel_size_b4
+	.byte	blink_mipsel_size_b3
+	.byte	blink_mipsel_size_b2
+	.byte	blink_mipsel_size_b1
+	.byte	blink_mipsel_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 Linux on PowerPC 64 Little Endian, e.g. Raptor
+	.ascii	"if [ \"$s\" = Linux ] && [ \"$m\" = ppc64le ]; then\n"
+	.ascii	"if ! [ -x \"$e\" ]; then\n"
+	.ascii	"echo \"extracting blink-powerpc64le to ${e}\" >&2\n"
+	.ascii	"dd if=\"$o\" bs=1 skip=$(("
+	.byte	blink_powerpc64le_b9
+	.byte	blink_powerpc64le_b8
+	.byte	blink_powerpc64le_b7
+	.byte	blink_powerpc64le_b6
+	.byte	blink_powerpc64le_b5
+	.byte	blink_powerpc64le_b4
+	.byte	blink_powerpc64le_b3
+	.byte	blink_powerpc64le_b2
+	.byte	blink_powerpc64le_b1
+	.byte	blink_powerpc64le_b0
+	.ascii	")) count=$(("
+	.byte	blink_powerpc64le_size_b9
+	.byte	blink_powerpc64le_size_b8
+	.byte	blink_powerpc64le_size_b7
+	.byte	blink_powerpc64le_size_b6
+	.byte	blink_powerpc64le_size_b5
+	.byte	blink_powerpc64le_size_b4
+	.byte	blink_powerpc64le_size_b3
+	.byte	blink_powerpc64le_size_b2
+	.byte	blink_powerpc64le_size_b1
+	.byte	blink_powerpc64le_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 Linux on PowerPC, e.g. Old Macintosh
+	.ascii	"if [ \"$s\" = Linux ] && [ \"$m\" = ppc ]; then\n"
+	.ascii	"if ! [ -x \"$e\" ]; then\n"
+	.ascii	"echo \"extracting blink-powerpc to ${e}\" >&2\n"
+	.ascii	"dd if=\"$o\" bs=1 skip=$(("
+	.byte	blink_powerpc_b9
+	.byte	blink_powerpc_b8
+	.byte	blink_powerpc_b7
+	.byte	blink_powerpc_b6
+	.byte	blink_powerpc_b5
+	.byte	blink_powerpc_b4
+	.byte	blink_powerpc_b3
+	.byte	blink_powerpc_b2
+	.byte	blink_powerpc_b1
+	.byte	blink_powerpc_b0
+	.ascii	")) count=$(("
+	.byte	blink_powerpc_size_b9
+	.byte	blink_powerpc_size_b8
+	.byte	blink_powerpc_size_b7
+	.byte	blink_powerpc_size_b6
+	.byte	blink_powerpc_size_b5
+	.byte	blink_powerpc_size_b4
+	.byte	blink_powerpc_size_b3
+	.byte	blink_powerpc_size_b2
+	.byte	blink_powerpc_size_b1
+	.byte	blink_powerpc_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 Linux on IBM Mainframes
+	.ascii	"if [ \"$s\" = Linux ] && [ \"$m\" = s390x ]; then\n"
+	.ascii	"if ! [ -x \"$e\" ]; then\n"
+	.ascii	"echo \"extracting blink-s390x to ${e}\" >&2\n"
+	.ascii	"dd if=\"$o\" bs=1 skip=$(("
+	.byte	blink_s390x_b9
+	.byte	blink_s390x_b8
+	.byte	blink_s390x_b7
+	.byte	blink_s390x_b6
+	.byte	blink_s390x_b5
+	.byte	blink_s390x_b4
+	.byte	blink_s390x_b3
+	.byte	blink_s390x_b2
+	.byte	blink_s390x_b1
+	.byte	blink_s390x_b0
+	.ascii	")) count=$(("
+	.byte	blink_s390x_size_b9
+	.byte	blink_s390x_size_b8
+	.byte	blink_s390x_size_b7
+	.byte	blink_s390x_size_b6
+	.byte	blink_s390x_size_b5
+	.byte	blink_s390x_size_b4
+	.byte	blink_s390x_size_b3
+	.byte	blink_s390x_size_b2
+	.byte	blink_s390x_size_b1
+	.byte	blink_s390x_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	"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
@@ -1090,6 +1430,42 @@ 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
@@ -1147,48 +1523,21 @@ sconf:	.short	1843200/*hz*/ / 16/*wut*/ / 9600/*baud*/
 
 //	Global Descriptor Table
 	.align	8
-_gdtrphy:
-	.short	2f-1f-1		# table byte length
-	.long	REAL(1f)	# table address (physical space)
-	.endobj	_gdtrphy,global,hidden
+_gdtrlo:
+	.short	2f-_gdtlo-1	# table byte length
+	.long	REAL(_gdtlo)	# table address (base memory space)
+	.endobj	_gdtrlo,global,hidden
 _gdtr:
-	.short	2f-1f-1		# table byte length
-	.quad	1f		# table address (final virtual space)
+	.short	_gdt_end-_gdt-1	# table byte length
+	.quad	_gdt		# table address (final virtual space)
 	.endobj	_gdtr,global,hidden
 	.align	8
-_gdt:
-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
+//	Partial GDT with descriptors for switching to unreal mode or long mode.
+_gdtlo	= .-GDT_LEGACY_DATA
 .quad	0b0000000011001111100100100000000000000000000000001111111111111111 #32
 .quad	0b0000000010101111100110110000000000000000000000001111111111111111 #40
 .quad	0b0000000010101111100100110000000000000000000000001111111111111111 #48
-.tssdescstub _tss							#56,64
 2:
-	.endobj	_gdt,global,hidden
 
 /*─────────────────────────────────────────────────────────────────────────────╗
 │ αcτµαlly pδrταblε εxεcµταblε § real mode                                     │
@@ -1196,6 +1545,7 @@ _gdt:
 	the default mode of operation on modern cpus */
 
 realmodeloader:
+	call	lhinit
 	call	rlinit
 	call	sinit4
 	.optfn	_start16
@@ -1203,6 +1553,25 @@ 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/*
@@ -1263,6 +1632,8 @@ longmodeloader:
 	call	lcheck
 	call	a20
 	call	e820
+	call	cpyhi
+	call	loadhi
 	call	pinit
 	call	golong
 	.endfn	longmodeloader
@@ -1405,10 +1776,88 @@ 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
@@ -1449,7 +1898,7 @@ golong:	cli
 	rdmsr
 	or	$EFER_LME|EFER_SCE|EFER_NXE,%eax
 	wrmsr
-	lgdt	REAL(_gdtrphy)
+	lgdt	REAL(_gdtrlo)
 	mov	%cr0,%eax
 	or	$CR0_PE|CR0_PG|CR0_MP,%eax
 	and	$~CR0_EM,%eax
@@ -1459,7 +1908,9 @@ golong:	cli
 
 //	Long mode is long.
 	.code64
-long:	xor	%eax,%eax
+long:	movabs	$BANE+PHYSICAL(0f),%rax
+	jmp	*%rax
+0:	xor	%eax,%eax
 	mov	$GDT_LONG_DATA,%al
 	mov	%eax,%ds
 	mov	%eax,%ss
@@ -1467,18 +1918,16 @@ long:	xor	%eax,%eax
 	mov	%eax,%fs
 	mov	%eax,%gs
 	mov	$0x80000,%esp
-	mov	$GDT_LONG_TSS,%al
-	ltr	%ax
 	xor	%r12d,%r12d
 	xor	%r13d,%r13d
 	xor	%r14d,%r14d
 	xor	%r15d,%r15d
 	xor	%ebx,%ebx
 	xor	%ebp,%ebp
-	push	%rbp
 	mov	$mm,%rdi
 	mov	%cr3,%rsi
-	mov	$IMAGE_BASE_REAL,%edx
+	mov	$IMAGE_BASE_PHYSICAL,%edx
+	lea	v_ape_allbytes(%rdx),%ecx
 	call	__map_phdrs
 	push	$0x037f
 	fldcw	(%rsp)
@@ -1564,6 +2013,10 @@ 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
 	pop	%rcx
 	pushq	.Lenv0(%rip)			# envp[0][0]
@@ -1609,6 +2062,7 @@ kernel:	movabs	$ape_stack_vaddr,%rsp
 	.ldsvar	_end
 	.ldsvar	_etext
 	.ldsvar	v_ape_realsectors
+	.ldsvar	v_ape_realbytes
 	.ldsvar	v_ape_highsectors
 	.ldsvar	ape_idata_ro
 	.ldsvar	ape_pad_rodata
@@ -1702,5 +2156,77 @@ __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
+
+	.section .blink,"a",@progbits
+	.globl	blink_arm_size
+blink_arm:
+	.incbin	"ape/blink-arm.gz"
+	.endobj	blink_arm,globl
+blink_arm_size = . - blink_arm
+	.previous
+
+	.section .blink,"a",@progbits
+	.globl	blink_i486_size
+blink_i486:
+	.incbin	"ape/blink-i486.gz"
+	.endobj	blink_i486,globl
+blink_i486_size = . - blink_i486
+	.previous
+
+	.section .blink,"a",@progbits
+	.globl	blink_riscv64_size
+blink_riscv64:
+	.incbin	"ape/blink-riscv64.gz"
+	.endobj	blink_riscv64,globl
+blink_riscv64_size = . - blink_riscv64
+	.previous
+
+	.section .blink,"a",@progbits
+	.globl	blink_mipsel_size
+blink_mipsel:
+	.incbin	"ape/blink-mipsel.gz"
+	.endobj	blink_mipsel,globl
+blink_mipsel_size = . - blink_mipsel
+	.previous
+
+	.section .blink,"a",@progbits
+	.globl	blink_powerpc64le_size
+blink_powerpc64le:
+	.incbin	"ape/blink-powerpc64le.gz"
+	.endobj	blink_powerpc64le,globl
+blink_powerpc64le_size = . - blink_powerpc64le
+	.previous
+
+	.section .blink,"a",@progbits
+	.globl	blink_powerpc_size
+blink_powerpc:
+	.incbin	"ape/blink-powerpc.gz"
+	.endobj	blink_powerpc,globl
+blink_powerpc_size = . - blink_powerpc
+	.previous
+
+	.section .blink,"a",@progbits
+	.globl	blink_s390x_size
+blink_s390x:
+	.incbin	"ape/blink-s390x.gz"
+	.endobj	blink_s390x,globl
+blink_s390x_size = . - blink_s390x
+	.previous
+
 .end
 

ape/ape.lds

@@ -216,6 +216,8 @@ SECTIONS {
     KEEP(*(.elf.phdrs))
     HIDDEN(ape_phdrs_end = .);
 
+    KEEP(*(.emush))
+
     /* OpenBSD */
     . = ALIGN(__SIZEOF_POINTER__);
     HIDDEN(ape_note = .);
@@ -273,6 +275,7 @@ SECTIONS {
     KEEP(*(.textwindowsprologue))
     *(.text.windows)
     KEEP(*(.textwindowsepilogue))
+    KEEP(*(.blink))
     *(SORT_BY_ALIGNMENT(.text.modernity))
     *(SORT_BY_ALIGNMENT(.text.modernity.*))
     *(SORT_BY_ALIGNMENT(.text.hot))
@@ -349,9 +352,30 @@ SECTIONS {
     HIDDEN(_etext = .);
     PROVIDE_HIDDEN(etext = .);
 /*END: Read Only Data (only needed for initialization) */
-/*END: Read Only Data */
   } :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
+
   .data ALIGN(PAGESIZE) : {
 /*BEGIN: Read/Write Data */
     KEEP(*(SORT_BY_NAME(.piro.data.sort.iat.*)))
@@ -385,26 +409,7 @@ 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 */
 
@@ -509,7 +514,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) + SIZEOF(.tdata));
+HIDDEN(ape_ram_filesz = SIZEOF(.data));
 HIDDEN(ape_ram_memsz = ADDR(.bss) + SIZEOF(.bss) - ape_ram_vaddr);
 HIDDEN(ape_ram_align = PAGESIZE);
 HIDDEN(ape_ram_rva = RVA(ape_ram_vaddr));
@@ -533,16 +538,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));
-HIDDEN(ape_text_memsz = SIZEOF(.text));
+HIDDEN(ape_text_filesz = SIZEOF(.text) + SIZEOF(.tdata));
+HIDDEN(ape_text_memsz = SIZEOF(.text) + SIZEOF(.tdata));
 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) + SIZEOF(.tdata));
-HIDDEN(ape_data_memsz = SIZEOF(.data) + SIZEOF(.tdata));
+HIDDEN(ape_data_filesz = SIZEOF(.data));
+HIDDEN(ape_data_memsz = SIZEOF(.data));
 HIDDEN(ape_data_align = PAGESIZE);
 HIDDEN(ape_data_rva = RVA(ape_data_vaddr));
 
@@ -562,13 +567,212 @@ 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);
+
+HIDDEN(blink_arm_b0 = RVA(blink_arm) % 10 + 48);
+HIDDEN(blink_arm_b1 = RVA(blink_arm) < 10 ? 32 : RVA(blink_arm) / 10 % 10 + 48);
+HIDDEN(blink_arm_b2 = RVA(blink_arm) < 100 ? 32 : RVA(blink_arm) / 100 % 10 + 48);
+HIDDEN(blink_arm_b3 = RVA(blink_arm) < 1000 ? 32 : RVA(blink_arm) / 1000 % 10 + 48);
+HIDDEN(blink_arm_b4 = RVA(blink_arm) < 10000 ? 32 : RVA(blink_arm) / 10000 % 10 + 48);
+HIDDEN(blink_arm_b5 = RVA(blink_arm) < 100000 ? 32 : RVA(blink_arm) / 100000 % 10 + 48);
+HIDDEN(blink_arm_b6 = RVA(blink_arm) < 1000000 ? 32 : RVA(blink_arm) / 1000000 % 10 + 48);
+HIDDEN(blink_arm_b7 = RVA(blink_arm) < 10000000 ? 32 : RVA(blink_arm) / 10000000 % 10 + 48);
+HIDDEN(blink_arm_b8 = RVA(blink_arm) < 100000000 ? 32 : RVA(blink_arm) / 100000000 % 10 + 48);
+HIDDEN(blink_arm_b9 = RVA(blink_arm) < 1000000000 ? 32 : RVA(blink_arm) / 1000000000 % 10 + 48);
+
+HIDDEN(blink_arm_size_b0 = blink_arm_size % 10 + 48);
+HIDDEN(blink_arm_size_b1 = blink_arm_size < 10 ? 32 : blink_arm_size / 10 % 10 + 48);
+HIDDEN(blink_arm_size_b2 = blink_arm_size < 100 ? 32 : blink_arm_size / 100 % 10 + 48);
+HIDDEN(blink_arm_size_b3 = blink_arm_size < 1000 ? 32 : blink_arm_size / 1000 % 10 + 48);
+HIDDEN(blink_arm_size_b4 = blink_arm_size < 10000 ? 32 : blink_arm_size / 10000 % 10 + 48);
+HIDDEN(blink_arm_size_b5 = blink_arm_size < 100000 ? 32 : blink_arm_size / 100000 % 10 + 48);
+HIDDEN(blink_arm_size_b6 = blink_arm_size < 1000000 ? 32 : blink_arm_size / 1000000 % 10 + 48);
+HIDDEN(blink_arm_size_b7 = blink_arm_size < 10000000 ? 32 : blink_arm_size / 10000000 % 10 + 48);
+HIDDEN(blink_arm_size_b8 = blink_arm_size < 100000000 ? 32 : blink_arm_size / 100000000 % 10 + 48);
+HIDDEN(blink_arm_size_b9 = blink_arm_size < 1000000000 ? 32 : blink_arm_size / 1000000000 % 10 + 48);
+
+HIDDEN(blink_i486_b0 = RVA(blink_i486) % 10 + 48);
+HIDDEN(blink_i486_b1 = RVA(blink_i486) < 10 ? 32 : RVA(blink_i486) / 10 % 10 + 48);
+HIDDEN(blink_i486_b2 = RVA(blink_i486) < 100 ? 32 : RVA(blink_i486) / 100 % 10 + 48);
+HIDDEN(blink_i486_b3 = RVA(blink_i486) < 1000 ? 32 : RVA(blink_i486) / 1000 % 10 + 48);
+HIDDEN(blink_i486_b4 = RVA(blink_i486) < 10000 ? 32 : RVA(blink_i486) / 10000 % 10 + 48);
+HIDDEN(blink_i486_b5 = RVA(blink_i486) < 100000 ? 32 : RVA(blink_i486) / 100000 % 10 + 48);
+HIDDEN(blink_i486_b6 = RVA(blink_i486) < 1000000 ? 32 : RVA(blink_i486) / 1000000 % 10 + 48);
+HIDDEN(blink_i486_b7 = RVA(blink_i486) < 10000000 ? 32 : RVA(blink_i486) / 10000000 % 10 + 48);
+HIDDEN(blink_i486_b8 = RVA(blink_i486) < 100000000 ? 32 : RVA(blink_i486) / 100000000 % 10 + 48);
+HIDDEN(blink_i486_b9 = RVA(blink_i486) < 1000000000 ? 32 : RVA(blink_i486) / 1000000000 % 10 + 48);
+
+HIDDEN(blink_i486_size_b0 = blink_i486_size % 10 + 48);
+HIDDEN(blink_i486_size_b1 = blink_i486_size < 10 ? 32 : blink_i486_size / 10 % 10 + 48);
+HIDDEN(blink_i486_size_b2 = blink_i486_size < 100 ? 32 : blink_i486_size / 100 % 10 + 48);
+HIDDEN(blink_i486_size_b3 = blink_i486_size < 1000 ? 32 : blink_i486_size / 1000 % 10 + 48);
+HIDDEN(blink_i486_size_b4 = blink_i486_size < 10000 ? 32 : blink_i486_size / 10000 % 10 + 48);
+HIDDEN(blink_i486_size_b5 = blink_i486_size < 100000 ? 32 : blink_i486_size / 100000 % 10 + 48);
+HIDDEN(blink_i486_size_b6 = blink_i486_size < 1000000 ? 32 : blink_i486_size / 1000000 % 10 + 48);
+HIDDEN(blink_i486_size_b7 = blink_i486_size < 10000000 ? 32 : blink_i486_size / 10000000 % 10 + 48);
+HIDDEN(blink_i486_size_b8 = blink_i486_size < 100000000 ? 32 : blink_i486_size / 100000000 % 10 + 48);
+HIDDEN(blink_i486_size_b9 = blink_i486_size < 1000000000 ? 32 : blink_i486_size / 1000000000 % 10 + 48);
+
+HIDDEN(blink_riscv64_b0 = RVA(blink_riscv64) % 10 + 48);
+HIDDEN(blink_riscv64_b1 = RVA(blink_riscv64) < 10 ? 32 : RVA(blink_riscv64) / 10 % 10 + 48);
+HIDDEN(blink_riscv64_b2 = RVA(blink_riscv64) < 100 ? 32 : RVA(blink_riscv64) / 100 % 10 + 48);
+HIDDEN(blink_riscv64_b3 = RVA(blink_riscv64) < 1000 ? 32 : RVA(blink_riscv64) / 1000 % 10 + 48);
+HIDDEN(blink_riscv64_b4 = RVA(blink_riscv64) < 10000 ? 32 : RVA(blink_riscv64) / 10000 % 10 + 48);
+HIDDEN(blink_riscv64_b5 = RVA(blink_riscv64) < 100000 ? 32 : RVA(blink_riscv64) / 100000 % 10 + 48);
+HIDDEN(blink_riscv64_b6 = RVA(blink_riscv64) < 1000000 ? 32 : RVA(blink_riscv64) / 1000000 % 10 + 48);
+HIDDEN(blink_riscv64_b7 = RVA(blink_riscv64) < 10000000 ? 32 : RVA(blink_riscv64) / 10000000 % 10 + 48);
+HIDDEN(blink_riscv64_b8 = RVA(blink_riscv64) < 100000000 ? 32 : RVA(blink_riscv64) / 100000000 % 10 + 48);
+HIDDEN(blink_riscv64_b9 = RVA(blink_riscv64) < 1000000000 ? 32 : RVA(blink_riscv64) / 1000000000 % 10 + 48);
+
+HIDDEN(blink_riscv64_size_b0 = blink_riscv64_size % 10 + 48);
+HIDDEN(blink_riscv64_size_b1 = blink_riscv64_size < 10 ? 32 : blink_riscv64_size / 10 % 10 + 48);
+HIDDEN(blink_riscv64_size_b2 = blink_riscv64_size < 100 ? 32 : blink_riscv64_size / 100 % 10 + 48);
+HIDDEN(blink_riscv64_size_b3 = blink_riscv64_size < 1000 ? 32 : blink_riscv64_size / 1000 % 10 + 48);
+HIDDEN(blink_riscv64_size_b4 = blink_riscv64_size < 10000 ? 32 : blink_riscv64_size / 10000 % 10 + 48);
+HIDDEN(blink_riscv64_size_b5 = blink_riscv64_size < 100000 ? 32 : blink_riscv64_size / 100000 % 10 + 48);
+HIDDEN(blink_riscv64_size_b6 = blink_riscv64_size < 1000000 ? 32 : blink_riscv64_size / 1000000 % 10 + 48);
+HIDDEN(blink_riscv64_size_b7 = blink_riscv64_size < 10000000 ? 32 : blink_riscv64_size / 10000000 % 10 + 48);
+HIDDEN(blink_riscv64_size_b8 = blink_riscv64_size < 100000000 ? 32 : blink_riscv64_size / 100000000 % 10 + 48);
+HIDDEN(blink_riscv64_size_b9 = blink_riscv64_size < 1000000000 ? 32 : blink_riscv64_size / 1000000000 % 10 + 48);
+
+HIDDEN(blink_mipsel_b0 = RVA(blink_mipsel) % 10 + 48);
+HIDDEN(blink_mipsel_b1 = RVA(blink_mipsel) < 10 ? 32 : RVA(blink_mipsel) / 10 % 10 + 48);
+HIDDEN(blink_mipsel_b2 = RVA(blink_mipsel) < 100 ? 32 : RVA(blink_mipsel) / 100 % 10 + 48);
+HIDDEN(blink_mipsel_b3 = RVA(blink_mipsel) < 1000 ? 32 : RVA(blink_mipsel) / 1000 % 10 + 48);
+HIDDEN(blink_mipsel_b4 = RVA(blink_mipsel) < 10000 ? 32 : RVA(blink_mipsel) / 10000 % 10 + 48);
+HIDDEN(blink_mipsel_b5 = RVA(blink_mipsel) < 100000 ? 32 : RVA(blink_mipsel) / 100000 % 10 + 48);
+HIDDEN(blink_mipsel_b6 = RVA(blink_mipsel) < 1000000 ? 32 : RVA(blink_mipsel) / 1000000 % 10 + 48);
+HIDDEN(blink_mipsel_b7 = RVA(blink_mipsel) < 10000000 ? 32 : RVA(blink_mipsel) / 10000000 % 10 + 48);
+HIDDEN(blink_mipsel_b8 = RVA(blink_mipsel) < 100000000 ? 32 : RVA(blink_mipsel) / 100000000 % 10 + 48);
+HIDDEN(blink_mipsel_b9 = RVA(blink_mipsel) < 1000000000 ? 32 : RVA(blink_mipsel) / 1000000000 % 10 + 48);
+
+HIDDEN(blink_mipsel_size_b0 = blink_mipsel_size % 10 + 48);
+HIDDEN(blink_mipsel_size_b1 = blink_mipsel_size < 10 ? 32 : blink_mipsel_size / 10 % 10 + 48);
+HIDDEN(blink_mipsel_size_b2 = blink_mipsel_size < 100 ? 32 : blink_mipsel_size / 100 % 10 + 48);
+HIDDEN(blink_mipsel_size_b3 = blink_mipsel_size < 1000 ? 32 : blink_mipsel_size / 1000 % 10 + 48);
+HIDDEN(blink_mipsel_size_b4 = blink_mipsel_size < 10000 ? 32 : blink_mipsel_size / 10000 % 10 + 48);
+HIDDEN(blink_mipsel_size_b5 = blink_mipsel_size < 100000 ? 32 : blink_mipsel_size / 100000 % 10 + 48);
+HIDDEN(blink_mipsel_size_b6 = blink_mipsel_size < 1000000 ? 32 : blink_mipsel_size / 1000000 % 10 + 48);
+HIDDEN(blink_mipsel_size_b7 = blink_mipsel_size < 10000000 ? 32 : blink_mipsel_size / 10000000 % 10 + 48);
+HIDDEN(blink_mipsel_size_b8 = blink_mipsel_size < 100000000 ? 32 : blink_mipsel_size / 100000000 % 10 + 48);
+HIDDEN(blink_mipsel_size_b9 = blink_mipsel_size < 1000000000 ? 32 : blink_mipsel_size / 1000000000 % 10 + 48);
+
+HIDDEN(blink_powerpc64le_b0 = RVA(blink_powerpc64le) % 10 + 48);
+HIDDEN(blink_powerpc64le_b1 = RVA(blink_powerpc64le) < 10 ? 32 : RVA(blink_powerpc64le) / 10 % 10 + 48);
+HIDDEN(blink_powerpc64le_b2 = RVA(blink_powerpc64le) < 100 ? 32 : RVA(blink_powerpc64le) / 100 % 10 + 48);
+HIDDEN(blink_powerpc64le_b3 = RVA(blink_powerpc64le) < 1000 ? 32 : RVA(blink_powerpc64le) / 1000 % 10 + 48);
+HIDDEN(blink_powerpc64le_b4 = RVA(blink_powerpc64le) < 10000 ? 32 : RVA(blink_powerpc64le) / 10000 % 10 + 48);
+HIDDEN(blink_powerpc64le_b5 = RVA(blink_powerpc64le) < 100000 ? 32 : RVA(blink_powerpc64le) / 100000 % 10 + 48);
+HIDDEN(blink_powerpc64le_b6 = RVA(blink_powerpc64le) < 1000000 ? 32 : RVA(blink_powerpc64le) / 1000000 % 10 + 48);
+HIDDEN(blink_powerpc64le_b7 = RVA(blink_powerpc64le) < 10000000 ? 32 : RVA(blink_powerpc64le) / 10000000 % 10 + 48);
+HIDDEN(blink_powerpc64le_b8 = RVA(blink_powerpc64le) < 100000000 ? 32 : RVA(blink_powerpc64le) / 100000000 % 10 + 48);
+HIDDEN(blink_powerpc64le_b9 = RVA(blink_powerpc64le) < 1000000000 ? 32 : RVA(blink_powerpc64le) / 1000000000 % 10 + 48);
+
+HIDDEN(blink_powerpc64le_size_b0 = blink_powerpc64le_size % 10 + 48);
+HIDDEN(blink_powerpc64le_size_b1 = blink_powerpc64le_size < 10 ? 32 : blink_powerpc64le_size / 10 % 10 + 48);
+HIDDEN(blink_powerpc64le_size_b2 = blink_powerpc64le_size < 100 ? 32 : blink_powerpc64le_size / 100 % 10 + 48);
+HIDDEN(blink_powerpc64le_size_b3 = blink_powerpc64le_size < 1000 ? 32 : blink_powerpc64le_size / 1000 % 10 + 48);
+HIDDEN(blink_powerpc64le_size_b4 = blink_powerpc64le_size < 10000 ? 32 : blink_powerpc64le_size / 10000 % 10 + 48);
+HIDDEN(blink_powerpc64le_size_b5 = blink_powerpc64le_size < 100000 ? 32 : blink_powerpc64le_size / 100000 % 10 + 48);
+HIDDEN(blink_powerpc64le_size_b6 = blink_powerpc64le_size < 1000000 ? 32 : blink_powerpc64le_size / 1000000 % 10 + 48);
+HIDDEN(blink_powerpc64le_size_b7 = blink_powerpc64le_size < 10000000 ? 32 : blink_powerpc64le_size / 10000000 % 10 + 48);
+HIDDEN(blink_powerpc64le_size_b8 = blink_powerpc64le_size < 100000000 ? 32 : blink_powerpc64le_size / 100000000 % 10 + 48);
+HIDDEN(blink_powerpc64le_size_b9 = blink_powerpc64le_size < 1000000000 ? 32 : blink_powerpc64le_size / 1000000000 % 10 + 48);
+
+HIDDEN(blink_powerpc_b0 = RVA(blink_powerpc) % 10 + 48);
+HIDDEN(blink_powerpc_b1 = RVA(blink_powerpc) < 10 ? 32 : RVA(blink_powerpc) / 10 % 10 + 48);
+HIDDEN(blink_powerpc_b2 = RVA(blink_powerpc) < 100 ? 32 : RVA(blink_powerpc) / 100 % 10 + 48);
+HIDDEN(blink_powerpc_b3 = RVA(blink_powerpc) < 1000 ? 32 : RVA(blink_powerpc) / 1000 % 10 + 48);
+HIDDEN(blink_powerpc_b4 = RVA(blink_powerpc) < 10000 ? 32 : RVA(blink_powerpc) / 10000 % 10 + 48);
+HIDDEN(blink_powerpc_b5 = RVA(blink_powerpc) < 100000 ? 32 : RVA(blink_powerpc) / 100000 % 10 + 48);
+HIDDEN(blink_powerpc_b6 = RVA(blink_powerpc) < 1000000 ? 32 : RVA(blink_powerpc) / 1000000 % 10 + 48);
+HIDDEN(blink_powerpc_b7 = RVA(blink_powerpc) < 10000000 ? 32 : RVA(blink_powerpc) / 10000000 % 10 + 48);
+HIDDEN(blink_powerpc_b8 = RVA(blink_powerpc) < 100000000 ? 32 : RVA(blink_powerpc) / 100000000 % 10 + 48);
+HIDDEN(blink_powerpc_b9 = RVA(blink_powerpc) < 1000000000 ? 32 : RVA(blink_powerpc) / 1000000000 % 10 + 48);
+
+HIDDEN(blink_powerpc_size_b0 = blink_powerpc_size % 10 + 48);
+HIDDEN(blink_powerpc_size_b1 = blink_powerpc_size < 10 ? 32 : blink_powerpc_size / 10 % 10 + 48);
+HIDDEN(blink_powerpc_size_b2 = blink_powerpc_size < 100 ? 32 : blink_powerpc_size / 100 % 10 + 48);
+HIDDEN(blink_powerpc_size_b3 = blink_powerpc_size < 1000 ? 32 : blink_powerpc_size / 1000 % 10 + 48);
+HIDDEN(blink_powerpc_size_b4 = blink_powerpc_size < 10000 ? 32 : blink_powerpc_size / 10000 % 10 + 48);
+HIDDEN(blink_powerpc_size_b5 = blink_powerpc_size < 100000 ? 32 : blink_powerpc_size / 100000 % 10 + 48);
+HIDDEN(blink_powerpc_size_b6 = blink_powerpc_size < 1000000 ? 32 : blink_powerpc_size / 1000000 % 10 + 48);
+HIDDEN(blink_powerpc_size_b7 = blink_powerpc_size < 10000000 ? 32 : blink_powerpc_size / 10000000 % 10 + 48);
+HIDDEN(blink_powerpc_size_b8 = blink_powerpc_size < 100000000 ? 32 : blink_powerpc_size / 100000000 % 10 + 48);
+HIDDEN(blink_powerpc_size_b9 = blink_powerpc_size < 1000000000 ? 32 : blink_powerpc_size / 1000000000 % 10 + 48);
+
+HIDDEN(blink_s390x_b0 = RVA(blink_s390x) % 10 + 48);
+HIDDEN(blink_s390x_b1 = RVA(blink_s390x) < 10 ? 32 : RVA(blink_s390x) / 10 % 10 + 48);
+HIDDEN(blink_s390x_b2 = RVA(blink_s390x) < 100 ? 32 : RVA(blink_s390x) / 100 % 10 + 48);
+HIDDEN(blink_s390x_b3 = RVA(blink_s390x) < 1000 ? 32 : RVA(blink_s390x) / 1000 % 10 + 48);
+HIDDEN(blink_s390x_b4 = RVA(blink_s390x) < 10000 ? 32 : RVA(blink_s390x) / 10000 % 10 + 48);
+HIDDEN(blink_s390x_b5 = RVA(blink_s390x) < 100000 ? 32 : RVA(blink_s390x) / 100000 % 10 + 48);
+HIDDEN(blink_s390x_b6 = RVA(blink_s390x) < 1000000 ? 32 : RVA(blink_s390x) / 1000000 % 10 + 48);
+HIDDEN(blink_s390x_b7 = RVA(blink_s390x) < 10000000 ? 32 : RVA(blink_s390x) / 10000000 % 10 + 48);
+HIDDEN(blink_s390x_b8 = RVA(blink_s390x) < 100000000 ? 32 : RVA(blink_s390x) / 100000000 % 10 + 48);
+HIDDEN(blink_s390x_b9 = RVA(blink_s390x) < 1000000000 ? 32 : RVA(blink_s390x) / 1000000000 % 10 + 48);
+
+HIDDEN(blink_s390x_size_b0 = blink_s390x_size % 10 + 48);
+HIDDEN(blink_s390x_size_b1 = blink_s390x_size < 10 ? 32 : blink_s390x_size / 10 % 10 + 48);
+HIDDEN(blink_s390x_size_b2 = blink_s390x_size < 100 ? 32 : blink_s390x_size / 100 % 10 + 48);
+HIDDEN(blink_s390x_size_b3 = blink_s390x_size < 1000 ? 32 : blink_s390x_size / 1000 % 10 + 48);
+HIDDEN(blink_s390x_size_b4 = blink_s390x_size < 10000 ? 32 : blink_s390x_size / 10000 % 10 + 48);
+HIDDEN(blink_s390x_size_b5 = blink_s390x_size < 100000 ? 32 : blink_s390x_size / 100000 % 10 + 48);
+HIDDEN(blink_s390x_size_b6 = blink_s390x_size < 1000000 ? 32 : blink_s390x_size / 1000000 % 10 + 48);
+HIDDEN(blink_s390x_size_b7 = blink_s390x_size < 10000000 ? 32 : blink_s390x_size / 10000000 % 10 + 48);
+HIDDEN(blink_s390x_size_b8 = blink_s390x_size < 100000000 ? 32 : blink_s390x_size / 100000000 % 10 + 48);
+HIDDEN(blink_s390x_size_b9 = blink_s390x_size < 1000000000 ? 32 : blink_s390x_size / 1000000000 % 10 + 48);
+
 #if SupportsMetal()
 HIDDEN(v_ape_realsectors =
-           MIN(0x70000 - IMAGE_BASE_REAL,
-               ROUNDUP(RVA(_tdata_end), 512)) / 512);
-HIDDEN(v_ape_realpages = v_ape_realsectors / (4096 / 512));
-HIDDEN(v_ape_highsectors =
-           (ROUNDUP(RVA(_tdata_end), 512) / 512) - 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 = v_ape_allsectors - v_ape_realsectors);
 TSSDESCSTUB2(_tss, _tss, _tss_end ? _tss_end - _tss - 1 : 0);
 #endif
 
@@ -651,7 +855,7 @@ CHURN(ADDR(.bss));
 CHURN(_start);
 CHURN(ape_phdrs);
 #if SupportsMetal()
-CHURN(v_ape_realsectors);
+CHURN(v_ape_allsectors);
 #endif
 #if SupportsXnu()
 CHURN(ape_macho);
@@ -715,7 +919,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

@@ -96,6 +96,17 @@ o/ape/idata.inc:				\
 		ape/idata.internal.h		\
 		ape/relocations.h
 
+o/$(MODE)/ape/ape.o:				\
+		ape/blink-aarch64.gz		\
+		ape/blink-arm.gz		\
+		ape/blink-darwin-arm64.gz	\
+		ape/blink-i486.gz		\
+		ape/blink-mipsel.gz		\
+		ape/blink-powerpc.gz		\
+		ape/blink-powerpc64le.gz	\
+		ape/blink-riscv64.gz		\
+		ape/blink-s390x.gz
+
 o/$(MODE)/ape/ape-no-modify-self.o:		\
 		ape/ape.S			\
 		ape/macros.internal.h		\
@@ -115,6 +126,15 @@ 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-arm.gz		\
+		ape/blink-darwin-arm64.gz	\
+		ape/blink-i486.gz		\
+		ape/blink-mipsel.gz		\
+		ape/blink-powerpc.gz		\
+		ape/blink-powerpc64le.gz	\
+		ape/blink-riscv64.gz		\
+		ape/blink-s390x.gz		\
 		o/$(MODE)/ape/ape.elf
 	@$(COMPILE)				\
 		-AOBJECTIFY.S			\
@@ -141,7 +161,16 @@ o/$(MODE)/ape/ape-copy-self.o:			\
 		libc/runtime/mman.internal.h	\
 		libc/runtime/pc.internal.h	\
 		libc/runtime/symbolic.h		\
-		libc/sysv/consts/prot.h
+		libc/sysv/consts/prot.h		\
+		ape/blink-aarch64.gz		\
+		ape/blink-arm.gz		\
+		ape/blink-darwin-arm64.gz	\
+		ape/blink-i486.gz		\
+		ape/blink-mipsel.gz		\
+		ape/blink-powerpc.gz		\
+		ape/blink-powerpc64le.gz	\
+		ape/blink-riscv64.gz		\
+		ape/blink-s390x.gz
 	@$(COMPILE)				\
 		-AOBJECTIFY.S			\
 		$(OBJECTIFY.S)			\

ape/apeinstall.sh

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

build/definitions.mk

@@ -45,7 +45,6 @@
 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

build/htags

@@ -43,6 +43,9 @@
 #     '(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' "$@"
@@ -63,7 +66,7 @@ set -- --regex-c='/^extern [^(]*(\*const \([^)]*\))(/\1/b' "$@"
 #   struct WorstSoftwareEver;
 set -- --regex-c='/^struct.*;$/uehocruehcroue/b' "$@"
 
-exec ${TAGS:-ctags}                                               \
+exec $TAGS                                                        \
      -e                                                           \
      --langmap=c:.c.h                                             \
      --exclude=libc/nt/struct/imagefileheader.internal.h          \

examples/clock_getres.c

@@ -38,10 +38,12 @@ 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);

examples/examples.mk

@@ -80,6 +80,7 @@ EXAMPLES_DIRECTDEPS =								\
 	THIRD_PARTY_LIBCXX							\
 	THIRD_PARTY_LINENOISE							\
 	THIRD_PARTY_LUA								\
+	THIRD_PARTY_HIREDIS							\
 	THIRD_PARTY_MBEDTLS							\
 	THIRD_PARTY_MUSL							\
 	THIRD_PARTY_NSYNC							\

examples/hiredis.c

@@ -0,0 +1,55 @@
+#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/nanosleep_test.c

@@ -0,0 +1,43 @@
+#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/vga2.c

@@ -24,10 +24,16 @@
 
 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 (;;);
 }

libc/ar.h

@@ -0,0 +1,21 @@
+#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,7 +4,7 @@
 COSMOPOLITAN_C_START_
 
 extern bool __assert_disable;
-void __assert_fail(const char *, const char *, int) hidden relegated;
+void __assert_fail(const char *, const char *, int) _Hide relegated;
 
 #ifdef NDEBUG
 #define assert(x) ((void)0)

libc/calls/calls.h

@@ -35,11 +35,10 @@
 #define WIFCONTINUED(s) ((s) == 0xffff)
 #define WIFEXITED(s)    (!WTERMSIG(s))
 #define WIFSIGNALED(s)  ((0xffff & (s)) - 1u < 0xffu)
-#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)
+#define WIFSTOPPED(s)   ((255 & (s)) == 127)
+#define WSTOPSIG(s)     WEXITSTATUS(s)
+#define WTERMSIG(s)     (127 & (s))
+#define W_STOPCODE(s)   ((s) << 8 | 0177)
 
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_

libc/calls/calls.mk

@@ -121,21 +121,12 @@ 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		\

libc/calls/clock_gettime.c

@@ -50,20 +50,23 @@
  *     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_MONOTONIC`: universally supported
- *     - `CLOCK_MONOTONIC_FAST`: ditto but faster on freebsd
- *     - `CLOCK_MONOTONIC_RAW`: nearly universally supported
- *     - `CLOCK_PROCESS_CPUTIME_ID`: linux and bsd
- *     - `CLOCK_THREAD_CPUTIME_ID`: linux and bsd
- *     - `CLOCK_REALTIME_COARSE`: : linux and openbsd
- *     - `CLOCK_MONOTONIC_COARSE`: linux
- *     - `CLOCK_PROF`: linux and netbsd
- *     - `CLOCK_BOOTTIME`: linux and openbsd
- *     - `CLOCK_REALTIME_ALARM`: linux-only
- *     - `CLOCK_BOOTTIME_ALARM`: linux-only
- *     - `CLOCK_TAI`: linux-only
+ *    - `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 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
@@ -116,7 +119,7 @@ clock_gettime_f *__clock_gettime_get(bool *opt_out_isfast) {
   return res;
 }
 
-hidden int __clock_gettime_init(int clockid, struct timespec *ts) {
+_Hide int __clock_gettime_init(int clockid, struct timespec *ts) {
   clock_gettime_f *gettime;
   __clock_gettime = gettime = __clock_gettime_get(0);
   return gettime(clockid, ts);

libc/calls/clock_gettime.internal.h

@@ -7,9 +7,9 @@ COSMOPOLITAN_C_START_
 typedef int clock_gettime_f(int, struct timespec *);
 
 extern clock_gettime_f *__clock_gettime;
-clock_gettime_f *__clock_gettime_get(bool *) hidden;
-int __clock_gettime_init(int, struct timespec *) hidden;
-int sys_clock_gettime_mono(struct timespec *) hidden;
+clock_gettime_f *__clock_gettime_get(bool *) _Hide;
+int __clock_gettime_init(int, struct timespec *) _Hide;
+int sys_clock_gettime_mono(struct timespec *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/clock_nanosleep.c

@@ -16,7 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/asan.internal.h"
+#include "libc/calls/blockcancel.internal.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/clock_gettime.internal.h"
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/state.internal.h"
 #include "libc/calls/struct/timespec.h"
@@ -27,11 +31,158 @@
 #include "libc/errno.h"
 #include "libc/intrin/describeflags.internal.h"
 #include "libc/intrin/strace.internal.h"
+#include "libc/intrin/weaken.h"
+#include "libc/macros.internal.h"
+#include "libc/nt/ntdll.h"
+#include "libc/str/str.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/consts/timer.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 
+static int64_t g_nanosleep_latency;
+
+static errno_t sys_clock_nanosleep(int clock, int flags,
+                                   const struct timespec *req,
+                                   struct timespec *rem) {
+  int e, rc;
+  BEGIN_CANCELLATION_POINT;
+  e = errno;
+  if (IsLinux() || IsFreebsd() || IsNetbsd()) {
+    rc = __sys_clock_nanosleep(clock, flags, req, rem);
+  } else if (IsXnu()) {
+    rc = sys_clock_nanosleep_xnu(clock, flags, req, rem);
+  } else if (IsOpenbsd()) {
+    rc = sys_clock_nanosleep_openbsd(clock, flags, req, rem);
+  } else {
+    rc = sys_clock_nanosleep_nt(clock, flags, req, rem);
+  }
+  if (rc == -1) {
+    rc = errno;
+    errno = e;
+  }
+  END_CANCELLATION_POINT;
+  return rc;
+}
+
+// determine sched_yield() vs. clock_nanosleep() threshold
+// 1ns sys_clock_nanosleep() on Windows takes milliseconds :'(
+// 1ns sys_clock_nanosleep() on Linux/FreeBSD takes tens of microseconds
+// 1ns sys_clock_nanosleep() on OpenBSD/NetBSD takes tens of milliseconds D:
+static struct timespec GetNanosleepLatency(void) {
+  errno_t rc;
+  int64_t nanos;
+  clock_gettime_f *cgt;
+  struct timespec x, y, w = {0, 1};
+  if (!(nanos = g_nanosleep_latency)) {
+    BLOCK_CANCELLATIONS;
+    for (cgt = __clock_gettime_get(0);;) {
+      _npassert(!cgt(CLOCK_REALTIME_PRECISE, &x));
+      rc = sys_clock_nanosleep(CLOCK_REALTIME, 0, &w, 0);
+      _npassert(!rc || rc == EINTR);
+      if (!rc) {
+        _npassert(!cgt(CLOCK_REALTIME_PRECISE, &y));
+        nanos = timespec_tonanos(timespec_sub(y, x));
+        g_nanosleep_latency = nanos;
+        break;
+      }
+    }
+    ALLOW_CANCELLATIONS;
+  }
+  return timespec_fromnanos(nanos);
+}
+
+static errno_t CheckCancel(void) {
+  if (_weaken(pthread_testcancel_np)) {
+    return _weaken(pthread_testcancel_np)();
+  } else {
+    return 0;
+  }
+}
+
+static errno_t SpinNanosleep(int clock, int flags, const struct timespec *req,
+                             struct timespec *rem) {
+  errno_t rc;
+  clock_gettime_f *cgt;
+  struct timespec now, start, elapsed;
+  if ((rc = CheckCancel())) {
+    if (rc == EINTR && !flags && rem) {
+      *rem = *req;
+    }
+    return rc;
+  }
+  cgt = __clock_gettime_get(0);
+  _npassert(!cgt(CLOCK_REALTIME, &start));
+  for (;;) {
+    sched_yield();
+    _npassert(!cgt(CLOCK_REALTIME, &now));
+    if (flags & TIMER_ABSTIME) {
+      if (timespec_cmp(now, *req) >= 0) {
+        return 0;
+      }
+      if ((rc = CheckCancel())) {
+        return rc;
+      }
+    } else {
+      if (timespec_cmp(now, start) < 0) continue;
+      elapsed = timespec_sub(now, start);
+      if ((rc = CheckCancel())) {
+        if (rc == EINTR && rem) {
+          if (timespec_cmp(elapsed, *req) >= 0) {
+            bzero(rem, sizeof(*rem));
+          } else {
+            *rem = elapsed;
+          }
+        }
+        return rc;
+      }
+      if (timespec_cmp(elapsed, *req) >= 0) {
+        return 0;
+      }
+    }
+  }
+}
+
+static bool ShouldUseSpinNanosleep(int clock, int flags,
+                                   const struct timespec *req) {
+  errno_t e;
+  struct timespec now;
+  if (IsWindows()) {
+    // Our spin technique here is intended to take advantage of the fact
+    // that sched_yield() takes about a hundred nanoseconds. But Windows
+    // SleepEx(0, 0) a.k.a. NtYieldExecution() takes a whole millisecond
+    // and it matters not whether our intent is to yielding or sleeping,
+    // since we use the SleepEx() function to implement both. Therefore,
+    // there's no reason to use SpinNanosleep() on Windows.
+    return false;
+  }
+  if (clock != CLOCK_REALTIME &&          //
+      clock != CLOCK_REALTIME_PRECISE &&  //
+      clock != CLOCK_MONOTONIC &&         //
+      clock != CLOCK_MONOTONIC_RAW &&     //
+      clock != CLOCK_MONOTONIC_PRECISE) {
+    return false;
+  }
+  if (!flags) {
+    return timespec_cmp(*req, GetNanosleepLatency()) < 0;
+  }
+  // We need a clock_gettime() system call to perform this check if the
+  // sleep request is an absolute timestamp. So we avoid doing that on
+  // systems where sleep latency isn't too outrageous.
+  if (timespec_cmp(GetNanosleepLatency(), timespec_fromnanos(50 * 1000)) < 0) {
+    return false;
+  }
+  e = errno;
+  if (__clock_gettime_get(0)(clock, &now)) {
+    // punt to the nanosleep system call
+    errno = e;
+    return false;
+  }
+  return timespec_cmp(*req, now) < 0 ||
+         timespec_cmp(timespec_sub(*req, now), GetNanosleepLatency()) < 0;
+}
+
 /**
  * Sleeps for particular amount of time.
  *
@@ -88,43 +239,30 @@
  */
 errno_t clock_nanosleep(int clock, int flags, const struct timespec *req,
                         struct timespec *rem) {
-  int rc, e = errno;
-  BEGIN_CANCELLATION_POINT;
-
-  if (!req || (IsAsan() && (!__asan_is_valid_timespec(req) ||
-                            (rem && !__asan_is_valid_timespec(rem))))) {
-    rc = efault();
+  int rc;
+  LOCKTRACE("clock_nanosleep(%s, %s, %s) → ...", DescribeClockName(clock),
+            DescribeSleepFlags(flags), DescribeTimespec(0, req));
+  if (IsMetal()) {
+    rc = ENOSYS;
+  } else if (!req || (IsAsan() && (!__asan_is_valid_timespec(req) ||
+                                   (rem && !__asan_is_valid_timespec(rem))))) {
+    rc = EFAULT;
   } else if (clock == 127 ||              //
              (flags & ~TIMER_ABSTIME) ||  //
              req->tv_sec < 0 ||           //
              !(0 <= req->tv_nsec && req->tv_nsec <= 999999999)) {
-    rc = einval();
-  } else if (IsLinux() || IsFreebsd() || IsNetbsd()) {
-    rc = sys_clock_nanosleep(clock, flags, req, rem);
-  } else if (IsXnu()) {
-    rc = sys_clock_nanosleep_xnu(clock, flags, req, rem);
-  } else if (IsOpenbsd()) {
-    rc = sys_clock_nanosleep_openbsd(clock, flags, req, rem);
-  } else if (IsMetal()) {
-    rc = enosys();
+    rc = EINVAL;
+  } else if (ShouldUseSpinNanosleep(clock, flags, req)) {
+    rc = SpinNanosleep(clock, flags, req, rem);
   } else {
-    rc = sys_clock_nanosleep_nt(clock, flags, req, rem);
+    rc = sys_clock_nanosleep(clock, flags, req, rem);
   }
-
-  if (rc == -1) {
-    rc = errno;
-    errno = e;
-  }
-
-  END_CANCELLATION_POINT;
-
 #if SYSDEBUG
   if (__tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
     STRACE("clock_nanosleep(%s, %s, %s, [%s]) → %s", DescribeClockName(clock),
            DescribeSleepFlags(flags), DescribeTimespec(0, req),
-           DescribeTimespec(rc, rem), DescribeErrnoResult(rc));
+           DescribeTimespec(rc, rem), DescribeErrno(rc));
   }
 #endif
-
   return rc;
 }

libc/calls/close-nt.c

@@ -24,7 +24,7 @@
 #include "libc/nt/runtime.h"
 #include "libc/sysv/consts/o.h"
 
-void sys_fcntl_nt_lock_cleanup(int) hidden;
+void sys_fcntl_nt_lock_cleanup(int) _Hide;
 
 textwindows int sys_close_nt(struct Fd *fd, int fildes) {
   int e;

libc/calls/fcntl-nt.c

@@ -98,7 +98,7 @@ static textwindows bool EqualsFileLock(struct FileLock *fl, int64_t off,
   return fl->off == off && off + len == fl->off + fl->len;
 }
 
-hidden textwindows void sys_fcntl_nt_lock_cleanup(int fd) {
+_Hide textwindows void sys_fcntl_nt_lock_cleanup(int fd) {
   struct FileLock *fl, *ft, **flp;
   pthread_mutex_lock(&g_locks.mu);
   for (flp = &g_locks.list, fl = *flp; fl;) {

libc/calls/fexecve.c

@@ -26,8 +26,6 @@
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
-int sys_fexecve(int, char *const[], char *const[]);
-
 /**
  * Executes binary executable at file descriptor.
  *

libc/calls/getpgrp.c

@@ -17,12 +17,14 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
+#include "libc/intrin/strace.internal.h"
 
 /**
  * Returns process group id of calling process.
+ *
+ * This function is equivalent to `getpgid(0)`.
  */
 int getpgrp(void) {
   int rc;

libc/calls/gettimeofday.c

@@ -97,7 +97,7 @@ gettimeofday_f *__gettimeofday_get(bool *opt_out_isfast) {
   return res;
 }
 
-hidden int __gettimeofday_init(struct timeval *tv, struct timezone *tz) {
+_Hide int __gettimeofday_init(struct timeval *tv, struct timezone *tz) {
   gettimeofday_f *gettime;
   __gettimeofday = gettime = __gettimeofday_get(0);
   return gettime(tv, tz, 0).ax;

libc/calls/internal.h

@@ -12,15 +12,15 @@ COSMOPOLITAN_C_START_
 
 #define kIoMotion ((const int8_t[3]){1, 0, 0})
 
-hidden extern struct Fds g_fds;
-hidden extern const struct Fd kEmptyFd;
+_Hide extern struct Fds g_fds;
+_Hide extern const struct Fd kEmptyFd;
 
-int __reservefd(int) hidden;
-int __reservefd_unlocked(int) hidden;
-void __releasefd(int) hidden;
-int __ensurefds(int) hidden;
-int __ensurefds_unlocked(int) hidden;
-void __printfds(void) hidden;
+int __reservefd(int) _Hide;
+int __reservefd_unlocked(int) _Hide;
+void __releasefd(int) _Hide;
+int __ensurefds(int) _Hide;
+int __ensurefds_unlocked(int) _Hide;
+void __printfds(void) _Hide;
 
 forceinline int64_t __getfdhandleactual(int fd) {
   return g_fds.p[fd].handle;
@@ -42,8 +42,8 @@ forceinline size_t _clampio(size_t size) {
   }
 }
 
-int sys_close_nt(struct Fd *, int) hidden;
-int _check_interrupts(bool, struct Fd *) hidden;
+int sys_close_nt(struct Fd *, int) _Hide;
+int _check_interrupts(bool, struct Fd *) _Hide;
 int sys_openat_metal(int, const char *, int, unsigned);
 
 COSMOPOLITAN_C_END_

libc/calls/ioctl_siocgifconf.c

@@ -43,11 +43,11 @@
  * The ifc_len is an input/output parameter: set it to the total size of
  * the ifcu_buf (ifcu_req) buffer on input.
  */
-int ioctl_siocgifconf_nt(int, struct ifconf *) hidden;
-int ioctl_siocgifaddr_nt(int, struct ifreq *) hidden;
-int ioctl_siocgifflags_nt(int, struct ifreq *) hidden;
-int ioctl_siocgifnetmask_nt(int, struct ifreq *) hidden;
-int ioctl_siocgifbrdaddr_nt(int, struct ifreq *) hidden;
+int ioctl_siocgifconf_nt(int, struct ifconf *) _Hide;
+int ioctl_siocgifaddr_nt(int, struct ifreq *) _Hide;
+int ioctl_siocgifflags_nt(int, struct ifreq *) _Hide;
+int ioctl_siocgifnetmask_nt(int, struct ifreq *) _Hide;
+int ioctl_siocgifbrdaddr_nt(int, struct ifreq *) _Hide;
 
 static int ioctl_siocgifconf_sysv(int fd, struct ifconf *ifc) {
   /*

libc/calls/ioctl_tcgets.c

@@ -18,18 +18,18 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/ioctl.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/calls/struct/metatermios.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/termios.internal.h"
 #include "libc/calls/ttydefaults.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
 
-int ioctl_tcgets_nt(int, struct termios *) hidden;
+int ioctl_tcgets_nt(int, struct termios *) _Hide;
 
 static int ioctl_tcgets_metal(int fd, struct termios *tio) {
   bzero(tio, sizeof(*tio));

libc/calls/islinux.c

@@ -18,11 +18,13 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/errno.h"
+#include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/pr.h"
 
 privileged bool __is_linux_2_6_23(void) {
   int rc;
   if (!IsLinux()) return false;
+  if (IsGenuineBlink()) return true;
   asm volatile("syscall"
                : "=a"(rc)
                : "0"(157), "D"(PR_GET_SECCOMP)

libc/calls/kemptyfd.c

@@ -19,4 +19,4 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/fd.internal.h"
 
-hidden const struct Fd kEmptyFd;
+_Hide const struct Fd kEmptyFd;

libc/calls/metalfile.c

@@ -61,14 +61,14 @@ textstartup noasan void InitializeMetalFile(void) {
      * The zipos code will automatically arrange to do this.  Alternatively,
      * user code can STATIC_YOINK this symbol.
      */
-    size_t size = ROUNDUP(_tdata_end - _base, 4096);
+    size_t size = ROUNDUP(_ezip - _base, 4096);
     void *copied_base;
     struct DirectMap dm;
     dm = sys_mmap_metal(NULL, size, PROT_READ | PROT_WRITE,
                         MAP_SHARED_linux | MAP_ANONYMOUS_linux, -1, 0);
     copied_base = dm.addr;
     _npassert(copied_base != (void *)-1);
-    memcpy(copied_base, (void *)(BANE + IMAGE_BASE_REAL), size);
+    memcpy(copied_base, (void *)(BANE + IMAGE_BASE_PHYSICAL), size);
     __ape_com_base = copied_base;
     __ape_com_size = size;
   }

libc/calls/mkntcmdline.c

@@ -61,15 +61,12 @@ static inline int IsAlpha(int c) {
 // TODO(jart): this needs fuzzing and security review
 //
 // @param cmdline is output buffer
-// @param prog is frontloaded as argv[0]
 // @param argv is an a NULL-terminated array of UTF-8 strings
 // @return 0 on success, or -1 w/ errno
 // @raise E2BIG if everything is too huge
 // @see "Everyone quotes command line arguments the wrong way" MSDN
 // @see libc/runtime/getdosargv.c
-textwindows int mkntcmdline(char16_t cmdline[ARG_MAX / 2], const char *prog,
-                            char *const argv[]) {
-  char *arg;
+textwindows int mkntcmdline(char16_t cmdline[ARG_MAX / 2], char *const argv[]) {
   uint64_t w;
   wint_t x, y;
   int slashes, n;
@@ -81,16 +78,16 @@ textwindows int mkntcmdline(char16_t cmdline[ARG_MAX / 2], const char *prog,
     bzero(ansiargv, sizeof(ansiargv));
     argv = ansiargv;
   }
-  for (arg = prog, k = i = 0; arg; arg = argv[++i]) {
+  for (k = i = 0; argv[i]; ++i) {
     if (i) APPEND(u' ');
-    if ((needsquote = NeedsQuotes(arg))) APPEND(u'"');
+    if ((needsquote = NeedsQuotes(argv[i]))) APPEND(u'"');
     for (slashes = j = 0;;) {
-      x = arg[j++] & 255;
+      x = argv[i][j++] & 255;
       if (x >= 0300) {
         n = ThomPikeLen(x);
         x = ThomPikeByte(x);
         while (--n) {
-          if ((y = arg[j++] & 255)) {
+          if ((y = argv[i][j++] & 255)) {
             x = ThomPikeMerge(x, y);
           } else {
             x = 0;
@@ -101,9 +98,9 @@ textwindows int mkntcmdline(char16_t cmdline[ARG_MAX / 2], const char *prog,
       if (!x) break;
       if (x == '/' || x == '\\') {
         if (!i) {
-          // turn / into \ for first arg
+          // turn / into \ for first argv[i]
           x = '\\';
-          // turn \c\... into c:\ for first arg
+          // turn \c\... into c:\ for first argv[i]
           if (k == 2 && IsAlpha(cmdline[1]) && cmdline[0] == '\\') {
             cmdline[0] = cmdline[1];
             cmdline[1] = ':';

libc/calls/munmap-metal.c

@@ -21,13 +21,18 @@
 
 noasan int sys_munmap_metal(void *addr, size_t size) {
   size_t i;
-  uint64_t *e;
+  uint64_t *e, paddr;
   struct mman *mm;
+  uint64_t *pml4t = __get_pml4t();
   mm = (struct mman *)(BANE + 0x0500);
   for (i = 0; i < size; i += 4096) {
-    e = __get_virtual(mm, __get_pml4t(), (uint64_t)addr + i, false);
-    if (e) *e = ~(PAGE_V | PAGE_RSRV);
-    invlpg((uint64_t)addr + i);
+    e = __get_virtual(mm, pml4t, (uint64_t)addr + i, false);
+    if (e) {
+      paddr = *e & PAGE_TA;
+      *e &= ~(PAGE_V | PAGE_RSRV);
+      invlpg((uint64_t)addr + i);
+      __unref_page(mm, pml4t, paddr);
+    }
   }
   return 0;
 }

libc/calls/now.c

@@ -45,10 +45,10 @@ static long double GetTimeSample(void) {
   uint64_t tick1, tick2;
   long double time1, time2;
   sched_yield();
-  time1 = dtime(CLOCK_REALTIME_FAST);
+  time1 = dtime(CLOCK_REALTIME_PRECISE);
   tick1 = rdtsc();
   nanosleep(&(struct timespec){0, 1000000}, NULL);
-  time2 = dtime(CLOCK_REALTIME_FAST);
+  time2 = dtime(CLOCK_REALTIME_PRECISE);
   tick2 = rdtsc();
   return (time2 - time1) * 1e9 / MAX(1, tick2 - tick1);
 }
@@ -74,13 +74,13 @@ static long double MeasureNanosPerCycle(void) {
 void RefreshTime(void) {
   struct Now now;
   now.cpn = MeasureNanosPerCycle();
-  now.r0 = dtime(CLOCK_REALTIME_FAST);
+  now.r0 = dtime(CLOCK_REALTIME_PRECISE);
   now.k0 = rdtsc();
   memcpy(&g_now, &now, sizeof(now));
 }
 
 static long double nowl_sys(void) {
-  return dtime(CLOCK_REALTIME_FAST);
+  return dtime(CLOCK_REALTIME_PRECISE);
 }
 
 static long double nowl_art(void) {
@@ -92,7 +92,7 @@ static long double nowl_vdso(void) {
   long double secs;
   struct timespec tv;
   _unassert(__gettime);
-  __gettime(CLOCK_REALTIME_FAST, &tv);
+  __gettime(CLOCK_REALTIME_PRECISE, &tv);
   secs = tv.tv_nsec;
   secs *= 1 / 1e9L;
   secs += tv.tv_sec;

libc/calls/ntmagicpaths.c

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/ntmagicpaths.internal.h"
 
-hidden const struct NtMagicPaths kNtMagicPaths = {
+_Hide const struct NtMagicPaths kNtMagicPaths = {
 #define TAB(NAME, STRING) STRING,
 #include "libc/calls/ntmagicpaths.inc"
 #undef TAB

libc/calls/ntmagicpaths.internal.h

@@ -9,7 +9,7 @@ struct NtMagicPaths {
 #undef TAB
 };
 
-hidden extern const struct NtMagicPaths kNtMagicPaths;
+_Hide extern const struct NtMagicPaths kNtMagicPaths;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/ntspawn.c

@@ -84,7 +84,7 @@ textwindows int ntspawn(
                                   sizeof(*block), 0)) &&
       (block = MapViewOfFileEx(handle, kNtFileMapRead | kNtFileMapWrite, 0, 0,
                                sizeof(*block), 0)) &&
-      mkntcmdline(block->cmdline, prog, argv) != -1 &&
+      mkntcmdline(block->cmdline, argv) != -1 &&
       mkntenvblock(block->envvars, envp, extravar, block->buf) != -1 &&
       CreateProcess(prog16, block->cmdline, opt_lpProcessAttributes,
                     opt_lpThreadAttributes, bInheritHandles,

libc/calls/ntspawn.h

@@ -6,13 +6,13 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int mkntcmdline(char16_t[ARG_MAX / 2], const char *, char *const[]) hidden;
+int mkntcmdline(char16_t[ARG_MAX / 2], char *const[]) _Hide;
 int mkntenvblock(char16_t[ARG_MAX / 2], char *const[], const char *,
-                 char[ARG_MAX]) hidden;
+                 char[ARG_MAX]) _Hide;
 int ntspawn(const char *, char *const[], char *const[], const char *,
             struct NtSecurityAttributes *, struct NtSecurityAttributes *,
             bool32, uint32_t, const char16_t *, const struct NtStartupInfo *,
-            struct NtProcessInformation *) hidden;
+            struct NtProcessInformation *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/pledge.c

@@ -24,6 +24,7 @@
 #include "libc/errno.h"
 #include "libc/intrin/promises.internal.h"
 #include "libc/intrin/strace.internal.h"
+#include "libc/nexgen32e/vendor.internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/errfuns.h"
 
@@ -238,8 +239,10 @@
 int pledge(const char *promises, const char *execpromises) {
   int e, rc;
   unsigned long ipromises, iexecpromises;
-  if (!ParsePromises(promises, &ipromises) &&
-      !ParsePromises(execpromises, &iexecpromises)) {
+  if (IsGenuineBlink()) {
+    rc = 0;  // blink doesn't support seccomp
+  } else if (!ParsePromises(promises, &ipromises) &&
+             !ParsePromises(execpromises, &iexecpromises)) {
     if (IsLinux()) {
       // copy exec and execnative from promises to execpromises
       iexecpromises = ~(~iexecpromises | (~ipromises & (1ul << PROMISE_EXEC)));

libc/calls/pledge.internal.h

@@ -11,10 +11,10 @@ struct Pledges {
   const size_t len;
 };
 
-hidden extern const struct Pledges kPledge[PROMISE_LEN_];
+_Hide extern const struct Pledges kPledge[PROMISE_LEN_];
 
-int sys_pledge_linux(unsigned long, int) hidden;
-int ParsePromises(const char *, unsigned long *) hidden;
+int sys_pledge_linux(unsigned long, int) _Hide;
+int ParsePromises(const char *, unsigned long *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/readlinkat-nt.c

@@ -28,6 +28,7 @@
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/reparsedatabuffer.h"
+#include "libc/runtime/stack.h"
 #include "libc/str/str.h"
 #include "libc/str/utf16.h"
 #include "libc/sysv/errfuns.h"
@@ -45,7 +46,7 @@ textwindows ssize_t sys_readlinkat_nt(int dirfd, const char *path, char *buf,
   if (__mkntpathat(dirfd, path, 0, path16) == -1) return -1;
   mem = 16384;
   memory = alloca(mem);
-  for (i = 0; i < mem; i += PAGESIZE) memory[i] = 0;
+  CheckLargeStackAllocation(memory, mem);
   rdb = (struct NtReparseDataBuffer *)memory;
   if ((h = CreateFile(path16, 0, 0, 0, kNtOpenExisting,
                       kNtFileFlagOpenReparsePoint | kNtFileFlagBackupSemantics,

libc/calls/sched-sysv.internal.h

@@ -18,11 +18,11 @@ int sys_sched_get_priority_max(int);
 int sys_sched_get_priority_min(int);
 int sys_sched_getparam(int, struct sched_param *);
 int sys_sched_getscheduler(int);
-int sys_sched_setaffinity(int, uint64_t, const void *) hidden;
+int sys_sched_setaffinity(int, uint64_t, const void *) _Hide;
 int sys_sched_setparam(int, const struct sched_param *);
 int sys_sched_setscheduler(int, int, const struct sched_param *);
-int sys_sched_yield(void) hidden;
-int64_t sys_sched_getaffinity(int, uint64_t, void *) hidden;
+int sys_sched_yield(void) _Hide;
+int64_t sys_sched_getaffinity(int, uint64_t, void *) _Hide;
 
 int sys_sched_getscheduler_netbsd(int, struct sched_param *);
 int sys_sched_setparam_netbsd(int, int, int, const struct sched_param *)  //

libc/calls/sched_rr_get_interval.c

@@ -17,11 +17,11 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/strace.internal.h"
 
-int sys_sched_rr_get_interval(int, struct timespec *) hidden;
+int sys_sched_rr_get_interval(int, struct timespec *) _Hide;
 
 /**
  * Returns round-robin `SCHED_RR` quantum for `pid`.

libc/calls/sig.internal.h

@@ -28,14 +28,14 @@ struct Signals {
 extern struct Signals __sig;
 extern atomic_long __sig_count;
 
-bool __sig_check(bool) hidden;
-bool __sig_handle(bool, int, int, ucontext_t *) hidden;
-int __sig_add(int, int, int) hidden;
-int __sig_mask(int, const sigset_t *, sigset_t *) hidden;
-int __sig_raise(int, int) hidden;
-void __sig_check_ignore(const int, const unsigned) hidden;
-void __sig_pending(sigset_t *) hidden;
-int __sig_is_applicable(struct Signal *) hidden;
+bool __sig_check(bool) _Hide;
+bool __sig_handle(bool, int, int, ucontext_t *) _Hide;
+int __sig_add(int, int, int) _Hide;
+int __sig_mask(int, const sigset_t *, sigset_t *) _Hide;
+int __sig_raise(int, int) _Hide;
+void __sig_check_ignore(const int, const unsigned) _Hide;
+void __sig_pending(sigset_t *) _Hide;
+int __sig_is_applicable(struct Signal *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/sigtimedwait.internal.h

@@ -7,7 +7,7 @@
 COSMOPOLITAN_C_START_
 
 int sys_sigtimedwait(const sigset_t *, union siginfo_meta *,
-                     const struct timespec *, size_t) hidden;
+                     const struct timespec *, size_t) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/state.internal.h

@@ -6,13 +6,13 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-hidden extern int __vforked;
-hidden extern bool __time_critical;
-hidden extern unsigned __sighandrvas[NSIG];
-hidden extern unsigned __sighandflags[NSIG];
-hidden extern pthread_mutex_t __fds_lock_obj;
-hidden extern pthread_mutex_t __sig_lock_obj;
-hidden extern const struct NtSecurityAttributes kNtIsInheritable;
+_Hide extern int __vforked;
+_Hide extern bool __time_critical;
+_Hide extern unsigned __sighandrvas[NSIG];
+_Hide extern unsigned __sighandflags[NSIG];
+_Hide extern pthread_mutex_t __fds_lock_obj;
+_Hide extern pthread_mutex_t __sig_lock_obj;
+_Hide extern const struct NtSecurityAttributes kNtIsInheritable;
 
 void __fds_lock(void);
 void __fds_unlock(void);

libc/calls/struct/framebuffercolormap.h

@@ -0,0 +1,15 @@
+#ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_FRAMEBUFFERCOLORMAP_H_
+#define COSMOPOLITAN_LIBC_CALLS_STRUCT_FRAMEBUFFERCOLORMAP_H_
+#if !(__ASSEMBLER__ + __LINKER__ + 0)
+
+struct FrameBufferColorMap {
+  uint32_t start;
+  uint32_t len;
+  uint16_t *red;
+  uint16_t *green;
+  uint16_t *blue;
+  uint16_t *transp;
+};
+
+#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+#endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_FRAMEBUFFERCOLORMAP_H_ */

libc/calls/struct/iovec.internal.h

@@ -6,24 +6,24 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int64_t sys_preadv(int, struct iovec *, int, int64_t, int64_t) hidden;
-int64_t sys_pwritev(int, const struct iovec *, int, int64_t, int64_t) hidden;
-int64_t sys_readv(int32_t, const struct iovec *, int32_t) hidden;
-int64_t sys_vmsplice(int, const struct iovec *, int64_t, uint32_t) hidden;
-int64_t sys_writev(int32_t, const struct iovec *, int32_t) hidden;
-size_t __iovec_size(const struct iovec *, size_t) hidden;
+int64_t sys_preadv(int, struct iovec *, int, int64_t, int64_t) _Hide;
+int64_t sys_pwritev(int, const struct iovec *, int, int64_t, int64_t) _Hide;
+int64_t sys_readv(int32_t, const struct iovec *, int32_t) _Hide;
+int64_t sys_vmsplice(int, const struct iovec *, int64_t, uint32_t) _Hide;
+int64_t sys_writev(int32_t, const struct iovec *, int32_t) _Hide;
+size_t __iovec_size(const struct iovec *, size_t) _Hide;
 ssize_t WritevUninterruptible(int, struct iovec *, int);
-ssize_t sys_read_nt(struct Fd *, const struct iovec *, size_t, ssize_t) hidden;
-ssize_t sys_readv_metal(struct Fd *, const struct iovec *, int) hidden;
-ssize_t sys_readv_nt(struct Fd *, const struct iovec *, int) hidden;
-ssize_t sys_readv_serial(struct Fd *, const struct iovec *, int) hidden;
-ssize_t sys_write_nt(int, const struct iovec *, size_t, ssize_t) hidden;
-ssize_t sys_writev_metal(struct Fd *, const struct iovec *, int) hidden;
-ssize_t sys_writev_nt(int, const struct iovec *, int) hidden;
-ssize_t sys_writev_serial(struct Fd *, const struct iovec *, int) hidden;
-ssize_t sys_send_nt(int, const struct iovec *, size_t, uint32_t) hidden;
+ssize_t sys_read_nt(struct Fd *, const struct iovec *, size_t, ssize_t) _Hide;
+ssize_t sys_readv_metal(struct Fd *, const struct iovec *, int) _Hide;
+ssize_t sys_readv_nt(struct Fd *, const struct iovec *, int) _Hide;
+ssize_t sys_readv_serial(struct Fd *, const struct iovec *, int) _Hide;
+ssize_t sys_write_nt(int, const struct iovec *, size_t, ssize_t) _Hide;
+ssize_t sys_writev_metal(struct Fd *, const struct iovec *, int) _Hide;
+ssize_t sys_writev_nt(int, const struct iovec *, int) _Hide;
+ssize_t sys_writev_serial(struct Fd *, const struct iovec *, int) _Hide;
+ssize_t sys_send_nt(int, const struct iovec *, size_t, uint32_t) _Hide;
 ssize_t sys_sendto_nt(int, const struct iovec *, size_t, uint32_t, void *,
-                      uint32_t) hidden;
+                      uint32_t) _Hide;
 
 const char *DescribeIovec(char[300], ssize_t, const struct iovec *, int);
 #define DescribeIovec(x, y, z) DescribeIovec(alloca(300), x, y, z)

libc/calls/struct/itimerval.internal.h

@@ -5,9 +5,9 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int sys_getitimer(int, struct itimerval *) hidden;
-int sys_setitimer(int, const struct itimerval *, struct itimerval *) hidden;
-int sys_setitimer_nt(int, const struct itimerval *, struct itimerval *) hidden;
+int sys_getitimer(int, struct itimerval *) _Hide;
+int sys_setitimer(int, const struct itimerval *, struct itimerval *) _Hide;
+int sys_setitimer_nt(int, const struct itimerval *, struct itimerval *) _Hide;
 
 const char *DescribeTimeval(char[45], int, const struct timeval *);
 #define DescribeTimeval(rc, ts) DescribeTimeval(alloca(45), rc, ts)

libc/calls/struct/metastat.internal.h

@@ -94,7 +94,7 @@ union metastat {
   struct stat_netbsd netbsd;
 };
 
-void __stat2cosmo(struct stat *restrict, const union metastat *) hidden;
+void __stat2cosmo(struct stat *restrict, const union metastat *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/struct/rlimit.internal.h

@@ -5,9 +5,9 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int sys_getrlimit(int, struct rlimit *) hidden;
-int sys_setrlimit(int, const struct rlimit *) hidden;
-int sys_setrlimit_nt(int, const struct rlimit *) hidden;
+int sys_getrlimit(int, struct rlimit *) _Hide;
+int sys_setrlimit(int, const struct rlimit *) _Hide;
+int sys_setrlimit_nt(int, const struct rlimit *) _Hide;
 
 const char *DescribeRlimit(char[64], int, const struct rlimit *);
 #define DescribeRlimit(rc, rl) DescribeRlimit(alloca(64), rc, rl)

libc/calls/struct/rusage.internal.h

@@ -4,12 +4,12 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int __sys_getrusage(int, struct rusage *) hidden;
-int __sys_wait4(int, int *, int, struct rusage *) hidden;
-int sys_getrusage(int, struct rusage *) hidden;
-int sys_wait4(int, int *, int, struct rusage *) hidden;
-void __rusage2linux(struct rusage *) hidden;
-int sys_getrusage_nt(int, struct rusage *) hidden;
+int __sys_getrusage(int, struct rusage *) _Hide;
+int __sys_wait4(int, int *, int, struct rusage *) _Hide;
+int sys_getrusage(int, struct rusage *) _Hide;
+int sys_wait4(int, int *, int, struct rusage *) _Hide;
+void __rusage2linux(struct rusage *) _Hide;
+int sys_getrusage_nt(int, struct rusage *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/struct/sigaction.internal.h

@@ -54,11 +54,11 @@ union metasigaction {
   struct sigaction_xnu_out xnu_out;
 };
 
-void __sigenter_xnu(int, struct siginfo *, void *) hidden;
-void __sigenter_wsl(int, struct siginfo *, void *) hidden;
-void __sigenter_netbsd(int, struct siginfo *, void *) hidden;
-void __sigenter_freebsd(int, struct siginfo *, void *) hidden;
-void __sigenter_openbsd(int, struct siginfo *, void *) hidden;
+void __sigenter_xnu(int, struct siginfo *, void *) _Hide;
+void __sigenter_wsl(int, struct siginfo *, void *) _Hide;
+void __sigenter_netbsd(int, struct siginfo *, void *) _Hide;
+void __sigenter_freebsd(int, struct siginfo *, void *) _Hide;
+void __sigenter_openbsd(int, struct siginfo *, void *) _Hide;
 
 const char *DescribeSigaction(char[256], int, const struct sigaction *);
 #define DescribeSigaction(rc, sa) DescribeSigaction(alloca(256), rc, sa)

libc/calls/struct/siginfo-meta.internal.h

@@ -16,7 +16,7 @@ union siginfo_meta {
   struct siginfo_netbsd netbsd;
 };
 
-void __siginfo2cosmo(struct siginfo *, const union siginfo_meta *) hidden;
+void __siginfo2cosmo(struct siginfo *, const union siginfo_meta *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/struct/siginfo.internal.h

@@ -5,7 +5,7 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int sys_sigqueueinfo(int, const siginfo_t *) hidden;
+int sys_sigqueueinfo(int, const siginfo_t *) _Hide;
 
 const char *DescribeSiginfo(char[300], int, const siginfo_t *);
 #define DescribeSiginfo(x, y) DescribeSiginfo(alloca(300), x, y)

libc/calls/struct/sigset.internal.h

@@ -6,10 +6,10 @@
 COSMOPOLITAN_C_START_
 
 int __sys_sigprocmask(int, const struct sigset *, struct sigset *,
-                      uint64_t) hidden;
-int sys_sigprocmask(int, const struct sigset *, struct sigset *) hidden;
-int sys_sigsuspend(const struct sigset *, uint64_t) hidden;
-int sys_sigpending(struct sigset *, size_t) hidden;
+                      uint64_t) _Hide;
+int sys_sigprocmask(int, const struct sigset *, struct sigset *) _Hide;
+int sys_sigsuspend(const struct sigset *, uint64_t) _Hide;
+int sys_sigpending(struct sigset *, size_t) _Hide;
 
 const char *DescribeSigset(char[128], int, const sigset_t *);
 #define DescribeSigset(rc, ss) DescribeSigset(alloca(128), rc, ss)

libc/calls/struct/sigval.internal.h

@@ -4,7 +4,7 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int sys_sigqueue(int, int, const union sigval) hidden;
+int sys_sigqueue(int, int, const union sigval) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/struct/stat.internal.h

@@ -5,11 +5,11 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int sys_fstat(int, struct stat *) hidden;
-int sys_fstatat(int, const char *, struct stat *, int) hidden;
-int sys_fstat_nt(int64_t, struct stat *) hidden;
-int sys_fstatat_nt(int, const char *, struct stat *, int) hidden;
-int sys_lstat_nt(const char *, struct stat *) hidden;
+int sys_fstat(int, struct stat *) _Hide;
+int sys_fstatat(int, const char *, struct stat *, int) _Hide;
+int sys_fstat_nt(int64_t, struct stat *) _Hide;
+int sys_fstatat_nt(int, const char *, struct stat *, int) _Hide;
+int sys_lstat_nt(const char *, struct stat *) _Hide;
 int sys_fstat_metal(int, struct stat *);
 
 const char *DescribeStat(char[300], int, const struct stat *);

libc/calls/struct/statfs-meta.internal.h

@@ -17,7 +17,7 @@ union statfs_meta {
   struct statfs_netbsd netbsd;
 };
 
-void statfs2cosmo(struct statfs *, const union statfs_meta *) hidden;
+void statfs2cosmo(struct statfs *, const union statfs_meta *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/struct/sysinfo.h

@@ -13,7 +13,8 @@ struct sysinfo {
   uint64_t totalswap; /* size of emergency memory */
   uint64_t freeswap;  /* hopefully equal to totalswap */
   int16_t procs;      /* number of processes */
-  int16_t __ignore;   /* padding */
+  int16_t __ignore1;  /* padding */
+  int32_t __ignore2;  /* padding */
   uint64_t totalhigh; /* wut */
   uint64_t freehigh;  /* wut */
   uint32_t mem_unit;  /* ram stuff above is multiples of this */

libc/calls/struct/sysinfo.internal.h

@@ -4,8 +4,8 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int sys_sysinfo(struct sysinfo *) hidden;
-int sys_sysinfo_nt(struct sysinfo *) hidden;
+int sys_sysinfo(struct sysinfo *) _Hide;
+int sys_sysinfo_nt(struct sysinfo *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/struct/timespec.internal.h

@@ -6,24 +6,24 @@
 COSMOPOLITAN_C_START_
 /* clang-format off */
 
-int __sys_utimensat(int, const char *, const struct timespec[2], int) hidden;
-int __utimens(int, const char *, const struct timespec[2], int) hidden;
-int sys_clock_getres(int, struct timespec *) hidden;
-int sys_clock_gettime(int, struct timespec *) hidden;
-int sys_clock_gettime_nt(int, struct timespec *) hidden;
-int sys_clock_gettime_xnu(int, struct timespec *) hidden;
-int sys_clock_nanosleep(int, int, const struct timespec *, struct timespec *) hidden;
-int sys_clock_nanosleep_nt(int, int, const struct timespec *, struct timespec *) hidden;
-int sys_clock_nanosleep_openbsd(int, int, const struct timespec *, struct timespec *) hidden;
-int sys_clock_nanosleep_xnu(int, int, const struct timespec *, struct timespec *) hidden;
-int sys_futimens(int, const struct timespec[2]) hidden;
-int sys_nanosleep(const struct timespec *, struct timespec *) hidden;
-int sys_nanosleep_nt(const struct timespec *, struct timespec *) hidden;
-int sys_nanosleep_xnu(const struct timespec *, struct timespec *) hidden;
-int sys_sem_timedwait(int64_t, const struct timespec *) hidden;
-int sys_utimensat(int, const char *, const struct timespec[2], int) hidden;
-int sys_utimensat_nt(int, const char *, const struct timespec[2], int) hidden;
-int sys_utimensat_xnu(int, const char *, const struct timespec[2], int) hidden;
+int __sys_clock_nanosleep(int, int, const struct timespec *, struct timespec *) _Hide;
+int __sys_utimensat(int, const char *, const struct timespec[2], int) _Hide;
+int __utimens(int, const char *, const struct timespec[2], int) _Hide;
+int sys_clock_getres(int, struct timespec *) _Hide;
+int sys_clock_gettime(int, struct timespec *) _Hide;
+int sys_clock_gettime_nt(int, struct timespec *) _Hide;
+int sys_clock_gettime_xnu(int, struct timespec *) _Hide;
+int sys_clock_nanosleep_nt(int, int, const struct timespec *, struct timespec *) _Hide;
+int sys_clock_nanosleep_openbsd(int, int, const struct timespec *, struct timespec *) _Hide;
+int sys_clock_nanosleep_xnu(int, int, const struct timespec *, struct timespec *) _Hide;
+int sys_futimens(int, const struct timespec[2]) _Hide;
+int sys_nanosleep(const struct timespec *, struct timespec *) _Hide;
+int sys_nanosleep_nt(const struct timespec *, struct timespec *) _Hide;
+int sys_nanosleep_xnu(const struct timespec *, struct timespec *) _Hide;
+int sys_sem_timedwait(int64_t, const struct timespec *) _Hide;
+int sys_utimensat(int, const char *, const struct timespec[2], int) _Hide;
+int sys_utimensat_nt(int, const char *, const struct timespec[2], int) _Hide;
+int sys_utimensat_xnu(int, const char *, const struct timespec[2], int) _Hide;
 
 const char *DescribeTimespec(char[45], int, const struct timespec *);
 #define DescribeTimespec(rc, ts) DescribeTimespec(alloca(45), rc, ts)

libc/calls/struct/timeval.internal.h

@@ -5,14 +5,14 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-axdx_t sys_gettimeofday(struct timeval *, struct timezone *, void *) hidden;
-int sys_futimes(int, const struct timeval *) hidden;
-int sys_futimesat(int, const char *, const struct timeval *) hidden;
-int sys_lutimes(const char *, const struct timeval *) hidden;
-int sys_utimes(const char *, const struct timeval *) hidden;
-axdx_t sys_gettimeofday_xnu(struct timeval *, struct timezone *, void *) hidden;
-axdx_t sys_gettimeofday_nt(struct timeval *, struct timezone *, void *) hidden;
-int sys_utimes_nt(const char *, const struct timeval[2]) hidden;
+axdx_t sys_gettimeofday(struct timeval *, struct timezone *, void *) _Hide;
+int sys_futimes(int, const struct timeval *) _Hide;
+int sys_futimesat(int, const char *, const struct timeval *) _Hide;
+int sys_lutimes(const char *, const struct timeval *) _Hide;
+int sys_utimes(const char *, const struct timeval *) _Hide;
+axdx_t sys_gettimeofday_xnu(struct timeval *, struct timezone *, void *) _Hide;
+axdx_t sys_gettimeofday_nt(struct timeval *, struct timezone *, void *) _Hide;
+int sys_utimes_nt(const char *, const struct timeval[2]) _Hide;
 axdx_t sys_gettimeofday_metal(struct timeval *, struct timezone *, void *);
 
 COSMOPOLITAN_C_END_

libc/calls/struct/ucontext.internal.h

@@ -5,8 +5,8 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-void _ntcontext2linux(struct ucontext *, const struct NtContext *) hidden;
-void _ntlinux2context(struct NtContext *, const ucontext_t *) hidden;
+void _ntcontext2linux(struct ucontext *, const struct NtContext *) _Hide;
+void _ntlinux2context(struct NtContext *, const ucontext_t *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/struct/winsize.internal.h

@@ -5,7 +5,7 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int ioctl_tiocgwinsz_nt(struct Fd *, struct winsize *) hidden;
+int ioctl_tiocgwinsz_nt(struct Fd *, struct winsize *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/syscall-nt.internal.h

@@ -3,40 +3,40 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-bool32 sys_isatty_nt(int) hidden;
-char *sys_getcwd_nt(char *, size_t) hidden;
-int sys_chdir_nt(const char *) hidden;
-int sys_close_epoll_nt(int) hidden;
-int sys_dup_nt(int, int, int, int) hidden;
-int sys_execve_nt(const char *, char *const[], char *const[]) hidden;
-int sys_faccessat_nt(int, const char *, int, uint32_t) hidden;
-int sys_fadvise_nt(int, uint64_t, uint64_t, int) hidden;
-int sys_fchdir_nt(int) hidden;
-int sys_fchmodat_nt(int, const char *, uint32_t, int) hidden;
-int sys_fcntl_nt(int, int, uintptr_t) hidden;
-int sys_fdatasync_nt(int) hidden;
-int sys_flock_nt(int, int) hidden;
-int sys_fork_nt(uint32_t) hidden;
-int sys_ftruncate_nt(int64_t, uint64_t) hidden;
-int sys_getloadavg_nt(double *, int) hidden;
-int sys_getppid_nt(void) hidden;
-int sys_getpriority_nt(int, unsigned) hidden;
-int sys_kill_nt(int, int) hidden;
-int sys_linkat_nt(int, const char *, int, const char *) hidden;
-int sys_madvise_nt(void *, size_t, int) hidden;
-int sys_mkdirat_nt(int, const char *, uint32_t) hidden;
-int sys_msync_nt(char *, size_t, int) hidden;
-int sys_open_nt(int, const char *, uint32_t, int32_t) dontdiscard hidden;
-int sys_pipe_nt(int[hasatleast 2], unsigned) hidden;
-int sys_renameat_nt(int, const char *, int, const char *) hidden;
-int sys_sched_yield_nt(void) hidden;
-int sys_setpriority_nt(int, unsigned, int) hidden;
-int sys_symlinkat_nt(const char *, int, const char *) hidden;
-int sys_sync_nt(void) hidden;
-int sys_truncate_nt(const char *, uint64_t) hidden;
-int sys_unlinkat_nt(int, const char *, int) hidden;
-int64_t sys_lseek_nt(int, int64_t, int) hidden;
-ssize_t sys_readlinkat_nt(int, const char *, char *, size_t) hidden;
+bool32 sys_isatty_nt(int) _Hide;
+char *sys_getcwd_nt(char *, size_t) _Hide;
+int sys_chdir_nt(const char *) _Hide;
+int sys_close_epoll_nt(int) _Hide;
+int sys_dup_nt(int, int, int, int) _Hide;
+int sys_execve_nt(const char *, char *const[], char *const[]) _Hide;
+int sys_faccessat_nt(int, const char *, int, uint32_t) _Hide;
+int sys_fadvise_nt(int, uint64_t, uint64_t, int) _Hide;
+int sys_fchdir_nt(int) _Hide;
+int sys_fchmodat_nt(int, const char *, uint32_t, int) _Hide;
+int sys_fcntl_nt(int, int, uintptr_t) _Hide;
+int sys_fdatasync_nt(int) _Hide;
+int sys_flock_nt(int, int) _Hide;
+int sys_fork_nt(uint32_t) _Hide;
+int sys_ftruncate_nt(int64_t, uint64_t) _Hide;
+int sys_getloadavg_nt(double *, int) _Hide;
+int sys_getppid_nt(void) _Hide;
+int sys_getpriority_nt(int, unsigned) _Hide;
+int sys_kill_nt(int, int) _Hide;
+int sys_linkat_nt(int, const char *, int, const char *) _Hide;
+int sys_madvise_nt(void *, size_t, int) _Hide;
+int sys_mkdirat_nt(int, const char *, uint32_t) _Hide;
+int sys_msync_nt(char *, size_t, int) _Hide;
+int sys_open_nt(int, const char *, uint32_t, int32_t) dontdiscard _Hide;
+int sys_pipe_nt(int[hasatleast 2], unsigned) _Hide;
+int sys_renameat_nt(int, const char *, int, const char *) _Hide;
+int sys_sched_yield_nt(void) _Hide;
+int sys_setpriority_nt(int, unsigned, int) _Hide;
+int sys_symlinkat_nt(const char *, int, const char *) _Hide;
+int sys_sync_nt(void) _Hide;
+int sys_truncate_nt(const char *, uint64_t) _Hide;
+int sys_unlinkat_nt(int, const char *, int) _Hide;
+int64_t sys_lseek_nt(int, int64_t, int) _Hide;
+ssize_t sys_readlinkat_nt(int, const char *, char *, size_t) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/syscall-sysv.internal.h

@@ -10,133 +10,135 @@ COSMOPOLITAN_C_START_
 │ cosmopolitan § syscalls » system five » structless synthetic jump slots  ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
 
-axdx_t __sys_fork(void) hidden;
-axdx_t __sys_pipe(i32[hasatleast 2], i32) hidden;
-axdx_t sys_getpid(void) hidden;
-char *sys_getcwd(char *, u64) hidden;
-char *sys_getcwd_xnu(char *, u64) hidden;
-i32 __sys_dup3(i32, i32, i32) hidden;
-i32 __sys_execve(const char *, char *const[], char *const[]) hidden;
-i32 __sys_fcntl(i32, i32, ...) hidden;
-i32 __sys_fcntl_cp(i32, i32, ...) hidden;
-i32 __sys_fstat(i32, void *) hidden;
-i32 __sys_fstatat(i32, const char *, void *, i32) hidden;
-i32 __sys_gettid(i64 *) hidden;
-i32 __sys_munmap(void *, u64) hidden;
-i32 __sys_openat(i32, const char *, i32, u32) hidden;
-i32 __sys_openat_nc(i32, const char *, i32, u32) hidden;
-i32 __sys_pipe2(i32[hasatleast 2], u32) hidden;
-i32 sys_arch_prctl(i32, i64) hidden;
-i32 sys_chdir(const char *) hidden;
-i32 sys_chroot(const char *) hidden;
-i32 sys_close(i32) hidden;
-i32 sys_close_range(u32, u32, u32) hidden;
-i32 sys_closefrom(i32) hidden;
-i32 sys_creat(const char *, u32) hidden;
-i32 sys_dup(i32) hidden;
-i32 sys_dup2(i32, i32) hidden;
-i32 sys_dup3(i32, i32, i32) hidden;
-i32 sys_execve(const char *, char *const[], char *const[]) hidden;
-i32 sys_faccessat(i32, const char *, i32, u32) hidden;
-i32 sys_faccessat2(i32, const char *, i32, u32) hidden;
-i32 sys_fadvise(i32, i64, i64, i32) hidden;
-i32 sys_fchdir(i32) hidden;
-i32 sys_fchmod(i32, u32) hidden;
-i32 sys_fchmodat(i32, const char *, u32, u32) hidden;
-i32 sys_fchown(i64, u32, u32) hidden;
-i32 sys_fchownat(i32, const char *, u32, u32, u32) hidden;
-i32 sys_fcntl(i32, i32, u64, i32 (*)(i32, i32, ...)) hidden;
-i32 sys_fdatasync(i32) hidden;
-i32 sys_flock(i32, i32) hidden;
-i32 sys_fork(void) hidden;
-i32 sys_fsync(i32) hidden;
-i32 sys_ftruncate(i32, i64, i64) hidden;
-i32 sys_getcontext(void *) hidden;
-i32 sys_getpgid(i32) hidden;
-i32 sys_getpgrp(void) hidden;
-i32 sys_getppid(void) hidden;
-i32 sys_getpriority(i32, u32) hidden;
-i32 sys_getresgid(u32 *, u32 *, u32 *) hidden;
-i32 sys_getresuid(u32 *, u32 *, u32 *) hidden;
-i32 sys_getsid(i32) hidden;
-i32 sys_gettid(void) hidden;
-i32 sys_ioctl(i32, u64, ...) hidden;
-i32 sys_ioctl_cp(i32, u64, ...) hidden;
-i32 sys_issetugid(void) hidden;
-i32 sys_kill(i32, i32, i32) hidden;
-i32 sys_linkat(i32, const char *, i32, const char *, i32) hidden;
-i32 sys_madvise(void *, size_t, i32) hidden;
-i32 sys_memfd_create(const char *, u32) hidden;
-i32 sys_mincore(void *, u64, unsigned char *) hidden;
-i32 sys_mkdirat(i32, const char *, u32) hidden;
-i32 sys_mkfifo(const char *, u32) hidden;
-i32 sys_mknod(const char *, u32, u64) hidden;
-i32 sys_mprotect(void *, u64, i32) hidden;
-i32 sys_msync(void *, u64, i32) hidden;
-i32 sys_munmap(void *, u64) hidden;
-i32 sys_open(const char *, i32, u32) hidden;
-i32 sys_openat(i32, const char *, i32, u32) hidden;
-i32 sys_pause(void) hidden;
-i32 sys_pipe(i32[hasatleast 2]) hidden;
-i32 sys_pipe2(i32[hasatleast 2], u32) hidden;
-i32 sys_pivot_root(const char *, const char *) hidden;
-i32 sys_pledge(const char *, const char *) hidden;
-i32 sys_posix_openpt(i32) hidden;
-i32 sys_renameat(i32, const char *, i32, const char *) hidden;
-i32 sys_sem_close(i64) hidden;
-i32 sys_sem_destroy(i64) hidden;
-i32 sys_sem_getvalue(i64, u32 *) hidden;
-i32 sys_sem_init(u32, i64 *) hidden;
-i32 sys_sem_open(const char *, int, u32, i64 *) hidden;
-i32 sys_sem_post(i64) hidden;
-i32 sys_sem_trywait(i64) hidden;
-i32 sys_sem_unlink(const char *) hidden;
-i32 sys_sem_wait(i64) hidden;
-i32 sys_setfsgid(i32) hidden;
-i32 sys_setfsuid(i32) hidden;
-i32 sys_setgid(i32) hidden;
-i32 sys_setpgid(i32, i32) hidden;
-i32 sys_setpriority(i32, u32, i32) hidden;
-i32 sys_setregid(u32, u32) hidden;
-i32 sys_setresgid(u32, u32, u32) hidden;
-i32 sys_setresuid(u32, u32, u32) hidden;
-i32 sys_setreuid(u32, u32) hidden;
-i32 sys_setsid(void) hidden;
-i32 sys_setuid(i32) hidden;
-i32 sys_sigaction(i32, const void *, void *, i64, i64) hidden;
-i32 sys_sigaltstack(const void *, void *) hidden;
-i32 sys_symlinkat(const char *, i32, const char *) hidden;
-i32 sys_sync(void) hidden;
-i32 sys_sync_file_range(i32, i64, i64, u32) hidden;
-i32 sys_syslog(i32, char *, i32) hidden;
-i32 sys_tgkill(i32, i32, i32) hidden;
-i32 sys_tkill(i32, i32, void *) hidden;
-i32 sys_truncate(const char *, u64, u64) hidden;
-i32 sys_uname(void *) hidden;
-i32 sys_unlink(const char *) hidden;
-i32 sys_unlinkat(i32, const char *, i32) hidden;
-i32 sys_unmount(const char *, i32) hidden;
-i32 sys_unveil(const char *, const char *) hidden;
-i64 __sys_ptrace(i32, i32, i64, long *) hidden;
-i64 sys_copy_file_range(i32, long *, i32, long *, u64, u32) hidden;
-i64 sys_getrandom(void *, u64, u32) hidden;
-i64 sys_lseek(i32, i64, i64, i64) hidden;
-i64 sys_pread(i32, void *, u64, i64, i64) hidden;
-i64 sys_pwrite(i32, const void *, u64, i64, i64) hidden;
-i64 sys_read(i32, void *, u64) hidden;
-i64 sys_readlink(const char *, char *, u64) hidden;
-i64 sys_readlinkat(i32, const char *, char *, u64) hidden;
-i64 sys_sendfile(i32, i32, i64 *, u64) hidden;
-i64 sys_splice(i32, i64 *, i32, i64 *, u64, u32) hidden;
-i64 sys_write(i32, const void *, u64) hidden;
-u32 sys_getegid(void) hidden;
-u32 sys_geteuid(void) hidden;
-u32 sys_getgid(void) hidden;
-u32 sys_getuid(void) hidden;
-u32 sys_umask(u32) hidden;
-void *__sys_mmap(void *, u64, u32, u32, i64, i64, i64) hidden;
-void *sys_mremap(void *, u64, u64, i32, void *) hidden;
-void sys_exit(i32) hidden;
+axdx_t __sys_fork(void) _Hide;
+axdx_t __sys_pipe(i32[hasatleast 2], i32) _Hide;
+axdx_t sys_getpid(void) _Hide;
+char *sys_getcwd(char *, u64) _Hide;
+char *sys_getcwd_xnu(char *, u64) _Hide;
+i32 __sys_dup3(i32, i32, i32) _Hide;
+i32 __sys_execve(const char *, char *const[], char *const[]) _Hide;
+i32 __sys_fcntl(i32, i32, ...) _Hide;
+i32 __sys_fcntl_cp(i32, i32, ...) _Hide;
+i32 __sys_fstat(i32, void *) _Hide;
+i32 __sys_fstatat(i32, const char *, void *, i32) _Hide;
+i32 __sys_gettid(i64 *) _Hide;
+i32 __sys_munmap(void *, u64) _Hide;
+i32 __sys_openat(i32, const char *, i32, u32) _Hide;
+i32 __sys_openat_nc(i32, const char *, i32, u32) _Hide;
+i32 __sys_pipe2(i32[hasatleast 2], u32) _Hide;
+i32 sys_arch_prctl(i32, i64) _Hide;
+i32 sys_chdir(const char *) _Hide;
+i32 sys_chroot(const char *) _Hide;
+i32 sys_close(i32) _Hide;
+i32 sys_close_range(u32, u32, u32) _Hide;
+i32 sys_closefrom(i32) _Hide;
+i32 sys_creat(const char *, u32) _Hide;
+i32 sys_dup(i32) _Hide;
+i32 sys_dup2(i32, i32) _Hide;
+i32 sys_dup3(i32, i32, i32) _Hide;
+i32 sys_execve(const char *, char *const[], char *const[]) _Hide;
+i32 sys_execveat(i32, const char *, char *const[], char *const[], i32) _Hide;
+i32 sys_faccessat(i32, const char *, i32, u32) _Hide;
+i32 sys_faccessat2(i32, const char *, i32, u32) _Hide;
+i32 sys_fadvise(i32, i64, i64, i32) _Hide;
+i32 sys_fchdir(i32) _Hide;
+i32 sys_fchmod(i32, u32) _Hide;
+i32 sys_fchmodat(i32, const char *, u32, u32) _Hide;
+i32 sys_fchown(i64, u32, u32) _Hide;
+i32 sys_fchownat(i32, const char *, u32, u32, u32) _Hide;
+i32 sys_fcntl(i32, i32, u64, i32 (*)(i32, i32, ...)) _Hide;
+i32 sys_fdatasync(i32) _Hide;
+i32 sys_fexecve(i32, char *const[], char *const[]) _Hide;
+i32 sys_flock(i32, i32) _Hide;
+i32 sys_fork(void) _Hide;
+i32 sys_fsync(i32) _Hide;
+i32 sys_ftruncate(i32, i64, i64) _Hide;
+i32 sys_getcontext(void *) _Hide;
+i32 sys_getpgid(i32) _Hide;
+i32 sys_getpgrp(void) _Hide;
+i32 sys_getppid(void) _Hide;
+i32 sys_getpriority(i32, u32) _Hide;
+i32 sys_getresgid(u32 *, u32 *, u32 *) _Hide;
+i32 sys_getresuid(u32 *, u32 *, u32 *) _Hide;
+i32 sys_getsid(i32) _Hide;
+i32 sys_gettid(void) _Hide;
+i32 sys_ioctl(i32, u64, ...) _Hide;
+i32 sys_ioctl_cp(i32, u64, ...) _Hide;
+i32 sys_issetugid(void) _Hide;
+i32 sys_kill(i32, i32, i32) _Hide;
+i32 sys_linkat(i32, const char *, i32, const char *, i32) _Hide;
+i32 sys_madvise(void *, size_t, i32) _Hide;
+i32 sys_memfd_create(const char *, u32) _Hide;
+i32 sys_mincore(void *, u64, unsigned char *) _Hide;
+i32 sys_mkdirat(i32, const char *, u32) _Hide;
+i32 sys_mkfifo(const char *, u32) _Hide;
+i32 sys_mknod(const char *, u32, u64) _Hide;
+i32 sys_mprotect(void *, u64, i32) _Hide;
+i32 sys_msync(void *, u64, i32) _Hide;
+i32 sys_munmap(void *, u64) _Hide;
+i32 sys_open(const char *, i32, u32) _Hide;
+i32 sys_openat(i32, const char *, i32, u32) _Hide;
+i32 sys_pause(void) _Hide;
+i32 sys_pipe(i32[hasatleast 2]) _Hide;
+i32 sys_pipe2(i32[hasatleast 2], u32) _Hide;
+i32 sys_pivot_root(const char *, const char *) _Hide;
+i32 sys_pledge(const char *, const char *) _Hide;
+i32 sys_posix_openpt(i32) _Hide;
+i32 sys_renameat(i32, const char *, i32, const char *) _Hide;
+i32 sys_sem_close(i64) _Hide;
+i32 sys_sem_destroy(i64) _Hide;
+i32 sys_sem_getvalue(i64, u32 *) _Hide;
+i32 sys_sem_init(u32, i64 *) _Hide;
+i32 sys_sem_open(const char *, int, u32, i64 *) _Hide;
+i32 sys_sem_post(i64) _Hide;
+i32 sys_sem_trywait(i64) _Hide;
+i32 sys_sem_unlink(const char *) _Hide;
+i32 sys_sem_wait(i64) _Hide;
+i32 sys_setfsgid(i32) _Hide;
+i32 sys_setfsuid(i32) _Hide;
+i32 sys_setgid(i32) _Hide;
+i32 sys_setpgid(i32, i32) _Hide;
+i32 sys_setpriority(i32, u32, i32) _Hide;
+i32 sys_setregid(u32, u32) _Hide;
+i32 sys_setresgid(u32, u32, u32) _Hide;
+i32 sys_setresuid(u32, u32, u32) _Hide;
+i32 sys_setreuid(u32, u32) _Hide;
+i32 sys_setsid(void) _Hide;
+i32 sys_setuid(i32) _Hide;
+i32 sys_sigaction(i32, const void *, void *, i64, i64) _Hide;
+i32 sys_sigaltstack(const void *, void *) _Hide;
+i32 sys_symlinkat(const char *, i32, const char *) _Hide;
+i32 sys_sync(void) _Hide;
+i32 sys_sync_file_range(i32, i64, i64, u32) _Hide;
+i32 sys_syslog(i32, char *, i32) _Hide;
+i32 sys_tgkill(i32, i32, i32) _Hide;
+i32 sys_tkill(i32, i32, void *) _Hide;
+i32 sys_truncate(const char *, u64, u64) _Hide;
+i32 sys_uname(void *) _Hide;
+i32 sys_unlink(const char *) _Hide;
+i32 sys_unlinkat(i32, const char *, i32) _Hide;
+i32 sys_unmount(const char *, i32) _Hide;
+i32 sys_unveil(const char *, const char *) _Hide;
+i64 __sys_ptrace(i32, i32, i64, long *) _Hide;
+i64 sys_copy_file_range(i32, long *, i32, long *, u64, u32) _Hide;
+i64 sys_getrandom(void *, u64, u32) _Hide;
+i64 sys_lseek(i32, i64, i64, i64) _Hide;
+i64 sys_pread(i32, void *, u64, i64, i64) _Hide;
+i64 sys_pwrite(i32, const void *, u64, i64, i64) _Hide;
+i64 sys_read(i32, void *, u64) _Hide;
+i64 sys_readlink(const char *, char *, u64) _Hide;
+i64 sys_readlinkat(i32, const char *, char *, u64) _Hide;
+i64 sys_sendfile(i32, i32, i64 *, u64) _Hide;
+i64 sys_splice(i32, i64 *, i32, i64 *, u64, u32) _Hide;
+i64 sys_write(i32, const void *, u64) _Hide;
+u32 sys_getegid(void) _Hide;
+u32 sys_geteuid(void) _Hide;
+u32 sys_getgid(void) _Hide;
+u32 sys_getuid(void) _Hide;
+u32 sys_umask(u32) _Hide;
+void *__sys_mmap(void *, u64, u32, u32, i64, i64, i64) _Hide;
+void *sys_mremap(void *, u64, u64, i32, void *) _Hide;
+void sys_exit(i32) _Hide;
 
 #undef i32
 #undef i64

libc/calls/syscall_support-nt.internal.h

@@ -3,25 +3,25 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-bool isdirectory_nt(const char *) hidden;
-bool isregularfile_nt(const char *) hidden;
-bool issymlink_nt(const char *) hidden;
-bool32 ntsetprivilege(int64_t, const char16_t *, uint32_t) hidden;
-char16_t *CreatePipeName(char16_t *) hidden;
-int __mkntpath(const char *, char16_t[hasatleast PATH_MAX]) hidden;
-int __mkntpath2(const char *, char16_t[hasatleast PATH_MAX], int) hidden;
-int __mkntpathat(int, const char *, int, char16_t[hasatleast PATH_MAX]) hidden;
-int __sample_pids(int[hasatleast 64], int64_t[hasatleast 64], bool) hidden;
-int ntaccesscheck(const char16_t *, uint32_t) paramsnonnull() hidden;
-int sys_pause_nt(void) hidden;
-int64_t __fix_enotdir(int64_t, char16_t *) hidden;
-int64_t __fix_enotdir3(int64_t, char16_t *, char16_t *) hidden;
+bool isdirectory_nt(const char *) _Hide;
+bool isregularfile_nt(const char *) _Hide;
+bool issymlink_nt(const char *) _Hide;
+bool32 ntsetprivilege(int64_t, const char16_t *, uint32_t) _Hide;
+char16_t *CreatePipeName(char16_t *) _Hide;
+int __mkntpath(const char *, char16_t[hasatleast PATH_MAX]) _Hide;
+int __mkntpath2(const char *, char16_t[hasatleast PATH_MAX], int) _Hide;
+int __mkntpathat(int, const char *, int, char16_t[hasatleast PATH_MAX]) _Hide;
+int __sample_pids(int[hasatleast 64], int64_t[hasatleast 64], bool) _Hide;
+int ntaccesscheck(const char16_t *, uint32_t) paramsnonnull() _Hide;
+int sys_pause_nt(void) _Hide;
+int64_t __fix_enotdir(int64_t, char16_t *) _Hide;
+int64_t __fix_enotdir3(int64_t, char16_t *, char16_t *) _Hide;
 int64_t __winerr(void) nocallback privileged;
 int64_t ntreturn(uint32_t);
-void *GetProcAddressModule(const char *, const char *) hidden;
-void WinMainForked(void) hidden;
-void _check_sigalrm(void) hidden;
-void _check_sigchld(void) hidden;
+void *GetProcAddressModule(const char *, const char *) _Hide;
+void WinMainForked(void) _Hide;
+void _check_sigalrm(void) _Hide;
+void _check_sigchld(void) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/syscall_support-sysv.internal.h

@@ -6,27 +6,27 @@ COSMOPOLITAN_C_START_
 │ cosmopolitan § syscalls » system five » structless support               ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
 
-bool __is_linux_2_6_23(void) hidden;
+bool __is_linux_2_6_23(void) _Hide;
 bool32 sys_isatty_metal(int);
-int __fixupnewfd(int, int) hidden;
+int __fixupnewfd(int, int) _Hide;
 int __notziposat(int, const char *);
-int __tkill(int, int, void *) hidden;
-int _fork(uint32_t) hidden;
-int _isptmaster(int) hidden;
-int _ptsname(int, char *, size_t) hidden;
-int getdomainname_linux(char *, size_t) hidden;
-int gethostname_bsd(char *, size_t, int) hidden;
-int gethostname_linux(char *, size_t) hidden;
-int gethostname_nt(char *, size_t, int) hidden;
+int __tkill(int, int, void *) _Hide;
+int _fork(uint32_t) _Hide;
+int _isptmaster(int) _Hide;
+int _ptsname(int, char *, size_t) _Hide;
+int getdomainname_linux(char *, size_t) _Hide;
+int gethostname_bsd(char *, size_t, int) _Hide;
+int gethostname_linux(char *, size_t) _Hide;
+int gethostname_nt(char *, size_t, int) _Hide;
 int sys_msyscall(void *, size_t);
 long sys_bogus(void);
-ssize_t __getrandom(void *, size_t, unsigned) hidden;
-void *__vdsosym(const char *, const char *) hidden;
-void __onfork(void) hidden;
-void __restore_rt() hidden;
-void __restore_rt_netbsd(void) hidden;
-void cosmo2flock(uintptr_t) hidden;
-void flock2cosmo(uintptr_t) hidden;
+ssize_t __getrandom(void *, size_t, unsigned) _Hide;
+void *__vdsosym(const char *, const char *) _Hide;
+void __onfork(void) _Hide;
+void __restore_rt() _Hide;
+void __restore_rt_netbsd(void) _Hide;
+void cosmo2flock(uintptr_t) _Hide;
+void flock2cosmo(uintptr_t) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/sysinfo.c

@@ -21,7 +21,6 @@
 #include "libc/calls/struct/sysinfo.internal.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timeval.h"
-#include "libc/calls/struct/vmmeter-meta.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
 #include "libc/intrin/strace.internal.h"
@@ -32,7 +31,7 @@
 #define CTL_KERN      1
 #define CTL_HW        6
 #define KERN_BOOTTIME 21
-#define HW_PHYSMEM    5
+#define HW_PHYSMEM    (IsXnu() ? 24 : 5)
 
 static int64_t GetUptime(void) {
   if (IsNetbsd()) return 0;  // TODO(jart): Why?
@@ -44,7 +43,7 @@ static int64_t GetUptime(void) {
 }
 
 static int64_t GetPhysmem(void) {
-  uint64_t x;
+  uint64_t x = 0;
   size_t n = sizeof(x);
   int mib[] = {CTL_HW, HW_PHYSMEM};
   if (sys_sysctl(mib, ARRAYLEN(mib), &x, &n, 0, 0) == -1) return 0;

libc/calls/tcgetwinsize.c

@@ -0,0 +1,28 @@
+/*-*- 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                              │
+│                                                                              │
+│ 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/ioctl.h"
+#include "libc/calls/struct/winsize.h"
+
+/**
+ * Gets terminal window size.
+ */
+int tcgetwinsize(int fd, struct winsize *ws) {
+  return ioctl_tiocgwinsz(fd, ws);
+}

libc/calls/tcsetwinsize.c

@@ -0,0 +1,28 @@
+/*-*- 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                              │
+│                                                                              │
+│ 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/ioctl.h"
+#include "libc/calls/struct/winsize.h"
+
+/**
+ * Sets terminal window size attributes.
+ */
+int tcsetwinsize(int fd, const struct winsize *ws) {
+  return ioctl_tiocswinsz(fd, ws);
+}

libc/calls/termios.h

@@ -35,6 +35,8 @@ int cfsetospeed(struct termios *, unsigned);
 int cfsetispeed(struct termios *, unsigned);
 uint32_t cfgetospeed(const struct termios *);
 uint32_t cfgetispeed(const struct termios *);
+int tcsetwinsize(int, const struct winsize *);
+int tcgetwinsize(int, struct winsize *);
 
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § teletypewriter » undiamonding                             ─╬─│┼

libc/calls/timespec_mono.c

@@ -29,6 +29,6 @@
  */
 struct timespec timespec_mono(void) {
   struct timespec ts;
-  _npassert(!clock_gettime(CLOCK_MONOTONIC_FAST, &ts));
+  _npassert(!clock_gettime(CLOCK_MONOTONIC, &ts));
   return ts;
 }

libc/calls/timespec_real.c

@@ -31,6 +31,6 @@
  */
 struct timespec timespec_real(void) {
   struct timespec ts;
-  _npassert(!clock_gettime(CLOCK_REALTIME_FAST, &ts));
+  _npassert(!clock_gettime(CLOCK_REALTIME, &ts));
   return ts;
 }

libc/calls/timespec_tonanos.c

@@ -22,7 +22,7 @@
 /**
  * Converts timespec to scalar.
  *
-. * This returns the absolute number of nanoseconds in a timespec. If
+ * This returns the absolute number of nanoseconds in a timespec. If
  * overflow happens, then `INT64_MAX` or `INT64_MIN` is returned. The
  * `errno` variable isn't changed.
  *

libc/calls/ttydefaults.h

@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_TTYDEFAULTS_H_
 #define COSMOPOLITAN_LIBC_CALLS_TTYDEFAULTS_H_
-#include "libc/sysv/consts/baud.h"
+#include "libc/sysv/consts/baud.internal.h"
 #include "libc/sysv/consts/termios.h"
 
 #define TTYDEF_IFLAG (BRKINT | ISTRIP | ICRNL | IMAXBEL | IXON | IXANY)

libc/calls/unveil.c

@@ -31,6 +31,7 @@
 #include "libc/fmt/conv.h"
 #include "libc/intrin/strace.internal.h"
 #include "libc/macros.internal.h"
+#include "libc/nexgen32e/vendor.internal.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
@@ -353,7 +354,9 @@ int sys_unveil_linux(const char *path, const char *permissions) {
 int unveil(const char *path, const char *permissions) {
   int e, rc;
   e = errno;
-  if (IsLinux()) {
+  if (IsGenuineBlink()) {
+    rc = 0;  // blink doesn't support landlock
+  } else if (IsLinux()) {
     rc = sys_unveil_linux(path, permissions);
   } else {
     rc = sys_unveil(path, permissions);

libc/calls/wait4.h

@@ -4,7 +4,7 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int sys_wait4_nt(int, int *, int, struct rusage *) hidden;
+int sys_wait4_nt(int, int *, int, struct rusage *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/wincrash.internal.h

@@ -7,7 +7,7 @@ COSMOPOLITAN_C_START_
 
 unsigned __wincrash_nt(struct NtExceptionPointers *);
 struct NtOverlapped *_offset2overlap(int64_t, int64_t,
-                                     struct NtOverlapped *) hidden;
+                                     struct NtOverlapped *) _Hide;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/dns/getntnameservers.c

@@ -16,11 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/mem/arraylist.internal.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dns/dns.h"
 #include "libc/dns/resolvconf.h"
+#include "libc/mem/arraylist.internal.h"
 #include "libc/nt/enum/keyaccess.h"
 #include "libc/nt/enum/reggetvalueflags.h"
 #include "libc/nt/registry.h"
@@ -42,6 +42,7 @@ textwindows int GetNtNameServers(struct ResolvConf *resolv) {
   int rc;
   char value8[128];
   int64_t hkInterfaces;
+  char *state, *addr, *tmp;
   struct sockaddr_in nameserver;
   char16_t value[128], uuid[64];
   uint32_t i, keycount, valuebytes, uuidlen;
@@ -75,8 +76,12 @@ textwindows int GetNtNameServers(struct ResolvConf *resolv) {
                          ((valuebytes = sizeof(value)), &valuebytes)) &&
             valuebytes > 2 * sizeof(char16_t)))) {
         tprecode16to8(value8, sizeof(value8), value);
-        if (inet_pton(AF_INET, value8, &nameserver.sin_addr.s_addr) == 1) {
-          if (append(&resolv->nameservers, &nameserver) != -1) ++rc;
+        tmp = value8;
+        while ((addr = strtok_r(tmp, ", ", &state))) {
+          if (inet_pton(AF_INET, addr, &nameserver.sin_addr.s_addr) == 1) {
+            if (append(&resolv->nameservers, &nameserver) != -1) ++rc;
+          }
+          tmp = NULL;
         }
       }
     }

libc/fmt/fmt.c

@@ -109,7 +109,7 @@ static int __fmt_atoi(const char **str) {
  * @asyncsignalsafe if floating point isn't used
  * @vforksafe if floating point isn't used
  */
-hidden int __fmt(void *fn, void *arg, const char *format, va_list va) {
+_Hide int __fmt(void *fn, void *arg, const char *format, va_list va) {
   long ld;
   void *p;
   unsigned u;

libc/fmt/fmt.h

@@ -26,7 +26,7 @@ int sscanf(const char *, const char *, ...) scanfesque(2);
 int vsscanf(const char *, const char *, va_list);
 int vcscanf(int (*)(void *), int (*)(int, void *), void *, const char *,
             va_list);
-int __fmt(void *, void *, const char *, va_list) hidden;
+int __fmt(void *, void *, const char *, va_list) _Hide;
 char *itoa(int, char *, int) compatfn;
 char *fcvt(double, int, int *, int *);
 char *ecvt(double, int, int *, int *);

libc/fmt/fmt.internal.h

@@ -15,13 +15,13 @@ COSMOPOLITAN_C_START_
   } while (0)
 
 int __fmt_pad(int (*)(const char *, void *, size_t), void *,
-              unsigned long) hidden;
+              unsigned long) _Hide;
 int __fmt_stoa(int (*)(const char *, void *, size_t), void *, void *,
                unsigned long, unsigned long, unsigned long, unsigned char,
-               unsigned char) hidden;
+               unsigned char) _Hide;
 int __fmt_ntoa(int (*)(const char *, void *, size_t), void *, va_list,
                unsigned char, unsigned long, unsigned long, unsigned long,
-               unsigned char, const char *) hidden;
+               unsigned char, const char *) _Hide;
 int __fmt_dtoa(int (*)(const char *, void *, size_t), void *, int, int, int,
                int, int, bool, char, unsigned char, const char *, va_list);
 

libc/fmt/magnumstrs.internal.h

@@ -16,16 +16,16 @@ struct MagnumStr {
   int x, s;
 };
 
-hidden extern const struct MagnumStr kClockNames[];
-hidden extern const struct MagnumStr kErrnoDocs[];
-hidden extern const struct MagnumStr kErrnoNames[];
-hidden extern const struct MagnumStr kFcntlCmds[];
-hidden extern const struct MagnumStr kIpOptnames[];
-hidden extern const struct MagnumStr kOpenFlags[];
-hidden extern const struct MagnumStr kRlimitNames[];
-hidden extern const struct MagnumStr kSignalNames[];
-hidden extern const struct MagnumStr kSockOptnames[];
-hidden extern const struct MagnumStr kTcpOptnames[];
+_Hide extern const struct MagnumStr kClockNames[];
+_Hide extern const struct MagnumStr kErrnoDocs[];
+_Hide extern const struct MagnumStr kErrnoNames[];
+_Hide extern const struct MagnumStr kFcntlCmds[];
+_Hide extern const struct MagnumStr kIpOptnames[];
+_Hide extern const struct MagnumStr kOpenFlags[];
+_Hide extern const struct MagnumStr kRlimitNames[];
+_Hide extern const struct MagnumStr kSignalNames[];
+_Hide extern const struct MagnumStr kSockOptnames[];
+_Hide extern const struct MagnumStr kTcpOptnames[];
 
 char *GetMagnumStr(const struct MagnumStr *, int);
 char *DescribeMagnum(char *, const struct MagnumStr *, const char *, int);