Pay off more technical debt

This makes breaking changes to add underscores to many non-standard function names provided by the c library. MODE=tiny is now tinier and we now use smaller locks that are better for tiny apps in this mode. Some headers have been renamed to be in the same folder as the build package, so it'll be easier to know which build dependency is needed. Certain old misguided interfaces have been removed. Intel intrinsics headers are now listed in libc/isystem (but not in the amalgamation) to help further improve open source compatibility. Header complexity has also been reduced. Lastly, more shell scripts are now available.
2025-06-27 14:58:30 +00:00 · 2022-09-12 23:10:38 -07:00 · 2022-09-12 23:10:38 -07:00 · 6f7d0cb1c3
commit 6f7d0cb1c3
parent b69f3d2488
960 changed files with 4072 additions and 4873 deletions
--- a/libc/runtime/arch_prctl.c
+++ b/libc/runtime/arch_prctl.c
@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
--- a/libc/runtime/buffer.internal.h
+++ b/libc/runtime/buffer.internal.h
@ -1,5 +1,5 @@
-#ifndef COSMOPOLITAN_LIBC_RUNTIME_BUFFER_H_
-#define COSMOPOLITAN_LIBC_RUNTIME_BUFFER_H_
+#ifndef COSMOPOLITAN_LIBC_RUNTIME_BUFFER_INTERNAL_H_
+#define COSMOPOLITAN_LIBC_RUNTIME_BUFFER_INTERNAL_H_
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_

@ -12,4 +12,4 @@ void bfree(struct GuardedBuffer *);

 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_RUNTIME_BUFFER_H_ */
+#endif /* COSMOPOLITAN_LIBC_RUNTIME_BUFFER_INTERNAL_H_ */
--- a/libc/runtime/clearenv.c
+++ b/libc/runtime/clearenv.c
@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/runtime/runtime.h"

 /**
--- a/libc/runtime/clktck.c
+++ b/libc/runtime/clktck.c
@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/_getauxval.internal.h"
+#include "libc/intrin/_getauxval.internal.h"
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
 #include "libc/fmt/conv.h"
--- a/libc/runtime/getinstructionlengths.c
+++ b/libc/runtime/getinstructionlengths.c
@ -1,5 +1,5 @@
-/*-*- 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│
+/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
+│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2022 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
@ -16,44 +16,41 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
 #include "libc/macros.internal.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sysv/consts/map.h"
-#include "libc/sysv/consts/prot.h"
-#include "third_party/xed/x86.h"
+.privileged

-/**
- * Returns lengths of x86 ops in binary.
- *
- * The first decoded instruction is at `_ereal`. Lengths can be 1 to 15
- * bytes. Each byte in the return value is in that range, and the array
- * is NUL terminated. The returned memory is memoized, since this costs
- * some time. For example, for a 10mb Python binary, it takes 20 millis
- * so the basic idea is is you can use this output multiple times which
- * is a faster way to iterate over the binary than calling Xed.
- *
- * @return nul-terminated length array on success, or null
- */
-privileged unsigned char *GetInstructionLengths(void) {
-  static bool once;
-  int i, n, err, len, rem;
-  static unsigned char *res;
-  struct XedDecodedInst xedd;
-  unsigned char *p, *mem, *code;
-  if (!once) {
-    if ((mem = mmap(0, ROUNDUP(__privileged_addr - _ereal + 1, FRAMESIZE),
-                    PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1,
-                    0)) != MAP_FAILED) {
-      for (p = mem, code = _ereal; code < __privileged_addr; code += len) {
-        rem = __privileged_addr - code;
-        xed_decoded_inst_zero_set_mode(&xedd, XED_MACHINE_MODE_LONG_64);
-        err = xed_instruction_length_decode(&xedd, code, rem);
-        *p++ = len = !err ? xedd.length : 1;
-      }
-      res = mem;
-    }
-    once = true;
-  }
-  return res;
-}
+//	Invokes clone() system call on GNU/Systemd.
+//
+//	@param	rdi is flags
+//	@param	rsi is top of stack
+//	@param	rdx is ptid
+//	@param	rcx is ctid
+//	@param	r8 is tls
+//	@param	r9 is func(void*,int)→int
+//	@param	8(rsp) is arg
+//	@return	tid of child on success, or -1 w/ errno
+sys_clone_linux:
+	push	%rbp
+	mov	%rsp,%rbp
+	push	%rbx
+	mov	%rcx,%r10
+	mov	16(%rbp),%rbx
+	mov	$56,%eax		# __NR_clone
+	syscall
+	test	%rax,%rax
+	jz	2f
+	cmp	$-4095,%rax
+	jae	1f
+0:	pop	%rbx
+	pop	%rbp
+	ret
+1:	call	systemfive_error
+	jmp	0b
+2:	xor	%ebp,%ebp		# child thread
+	mov	%rbx,%rdi		# arg
+	mov	(%r10),%esi		# tid
+	call	*%r9			# func(arg,tid)
+	xchg	%eax,%edi		# func(arg,tid) → exitcode
+	mov	$60,%eax		# __NR_exit(exitcode)
+	syscall
+	.endfn	sys_clone_linux,globl,hidden
--- a/libc/runtime/clone-nt.S
+++ b/libc/runtime/clone-nt.S
@ -0,0 +1,47 @@
+/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
+│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/macros.internal.h"
+.text.windows
+
+//	Used by clone() on Windows to launch thread.
+//
+//	Windows owns the stack memory when we initially enter threads.
+//	This function switches us over, so that we can start using the
+//	runtime facilities.
+//
+//	@param	%rdi is arg
+//	@param	%rsi is tid
+//	@param	%rdx is func
+//	@param	%rcx is stack
+//	@return	%rax is exit code
+//	@see	clone()
+WinThreadLaunch:
+	push	%rbx
+	push	%r15
+	mov	%rbp,%r15
+	mov	%rsp,%rbx
+	mov	%rcx,%rsp
+	xor	%rbp,%rbp
+	call	*%rdx
+	mov	%r15,%rbp
+	mov	%rbx,%rsp
+	pop	%r15
+	pop	%rbx
+	ret
+	.endfn	WinThreadLaunch,globl,hidden
--- a/libc/runtime/clone-openbsd.S
+++ b/libc/runtime/clone-openbsd.S
@ -1,7 +1,7 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
+│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
 ╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@ -16,20 +16,30 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/intrin/lockxchg.h"
-#include "libc/runtime/runtime.h"
+#include "libc/macros.internal.h"

-/**
- * Closes file descriptor.
- *
- * The caller's variable is made -1 so subsequent calls are no-ops.
- *
- * @return 0 on success, or -1 w/ errno
- * @asyncsignalsafe
- */
-int close_s(int *fdp) {
-  int fd = -1;
-  if (lockxchg(fdp, &fd) == -1) return 0;
-  return close(fd);
-}
+#define SYS___tfork 8
+
+//	Creates thread on OpenBSD.
+//
+//	@param	rdi is params
+//	@param	rsi is size of params
+//	@param	rdx is start function
+//	@param	rcx is start parameter
+//	@return	thread id or negative errno
+__tfork_thread:
+	mov	%rdx,%r8
+	mov	%rcx,%r9
+	mov	$SYS___tfork,%eax
+	syscall
+	jc	2f
+	test	%eax,%eax
+	jz	1f
+	ret
+1:	xor	%ebp,%ebp
+	mov	%r9,%rdi
+	jmp	*%r8
+	.unreachable
+2:	neg	%eax
+	ret
+	.endfn	__tfork_thread,globl
--- a/libc/runtime/clone.c
+++ b/libc/runtime/clone.c
@ -0,0 +1,641 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/intrin/strace.internal.h"
+#include "libc/calls/struct/ucontext-netbsd.internal.h"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/asan.internal.h"
+#include "libc/limits.h"
+#include "libc/macros.internal.h"
+#include "libc/nt/runtime.h"
+#include "libc/nt/thread.h"
+#include "libc/nt/thunk/msabi.h"
+#include "libc/runtime/clone.internal.h"
+#include "libc/runtime/internal.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdalign.internal.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/clone.h"
+#include "libc/sysv/consts/futex.h"
+#include "libc/sysv/consts/nr.h"
+#include "libc/sysv/consts/nrlinux.h"
+#include "libc/sysv/errfuns.h"
+#include "libc/thread/freebsd.internal.h"
+#include "libc/thread/openbsd.internal.h"
+#include "libc/thread/thread.h"
+#include "libc/thread/tls.h"
+#include "libc/thread/xnu.internal.h"
+
+#define __NR_thr_new                      455
+#define __NR_clone_linux                  56
+#define __NR__lwp_create                  309
+#define __NR_getcontext_netbsd            307
+#define __NR_bsdthread_create             0x02000168
+#define __NR_thread_fast_set_cthread_self 0x03000003
+#define PTHREAD_START_CUSTOM_XNU          0x01000000
+#define LWP_DETACHED                      0x00000040
+#define LWP_SUSPENDED                     0x00000080
+
+__msabi extern typeof(TlsSetValue) *const __imp_TlsSetValue;
+__msabi extern typeof(ExitThread) *const __imp_ExitThread;
+
+struct CloneArgs {
+  union {
+    int tid;
+    uint32_t utid;
+    int64_t tid64;
+  };
+  pthread_spinlock_t lock;
+  int *ptid;
+  int *ctid;
+  int *ztid;
+  char *tls;
+  int (*func)(void *, int);
+  void *arg;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// THE NEW TECHNOLOGY
+
+int WinThreadLaunch(void *arg,                 // rdi
+                    int tid,                   // rsi
+                    int (*func)(void *, int),  // rdx
+                    intptr_t rsp);             // rcx
+
+// we can't log this function because:
+//   1. windows owns the backtrace pointer right now
+//   2. ftrace unwinds rbp to determine depth
+//   3. tid in tls for ftrace isn't set yet
+// we can't use address sanitizer because:
+//   1. __asan_handle_no_return wipes stack
+//   2. windows owns the stack memory right now
+// we need win32 raw imports because:
+//   1. generated thunks are function logged
+noasan noinstrument static textwindows wontreturn void  //
+WinThreadEntry(int rdi,                                 // rcx
+               int rsi,                                 // rdx
+               int rdx,                                 // r8
+               struct CloneArgs *wt) {                  // r9
+  int rc;
+  if (wt->tls) {
+    asm("mov\t%1,%%gs:%0"
+        : "=m"(*((long *)0x1480 + __tls_index))
+        : "r"(wt->tls));
+  }
+  *wt->ptid = wt->tid;
+  *wt->ctid = wt->tid;
+  rc = WinThreadLaunch(wt->arg, wt->tid, wt->func, (intptr_t)wt & -16);
+  // we can now clear ctid directly since we're no longer using our own
+  // stack memory, which can now be safely free'd by the parent thread.
+  *wt->ztid = 0;
+  // since we didn't indirect this function through NT2SYSV() it's not
+  // safe to simply return, and as such, we just call ExitThread().
+  __imp_ExitThread(rc);
+  unreachable;
+}
+
+static textwindows int CloneWindows(int (*func)(void *, int), char *stk,
+                                    size_t stksz, int flags, void *arg,
+                                    void *tls, int *ptid, int *ctid) {
+  int64_t h;
+  struct CloneArgs *wt;
+  wt = (struct CloneArgs *)(((intptr_t)(stk + stksz) -
+                             sizeof(struct CloneArgs)) &
+                            -alignof(struct CloneArgs));
+  wt->ptid = flags & CLONE_PARENT_SETTID ? ptid : &wt->tid;
+  wt->ctid = flags & CLONE_CHILD_SETTID ? ctid : &wt->tid;
+  wt->ztid = flags & CLONE_CHILD_CLEARTID ? ctid : &wt->tid;
+  wt->func = func;
+  wt->arg = arg;
+  wt->tls = flags & CLONE_SETTLS ? tls : 0;
+  if ((h = CreateThread(0, 4096, (void *)WinThreadEntry, wt, 0, &wt->utid))) {
+    CloseHandle(h);
+    return wt->tid;
+  } else {
+    return -1;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// XNU'S NOT UNIX
+
+void XnuThreadThunk(void *pthread,          // rdi
+                    int machport,           // rsi
+                    void *(*func)(void *),  // rdx
+                    void *arg,              // rcx
+                    intptr_t *stack,        // r8
+                    unsigned xnuflags);     // r9
+asm("XnuThreadThunk:\n\t"
+    "xor\t%ebp,%ebp\n\t"
+    "mov\t%r8,%rsp\n\t"
+    "and\t$-16,%rsp\n\t"
+    "push\t%rax\n\t"
+    "jmp\tXnuThreadMain\n\t"
+    ".size\tXnuThreadThunk,.-XnuThreadThunk");
+__attribute__((__used__, __no_reorder__))
+
+static wontreturn void
+XnuThreadMain(void *pthread,                    // rdi
+              int tid,                          // rsi
+              int (*func)(void *arg, int tid),  // rdx
+              void *arg,                        // rcx
+              struct CloneArgs *wt,             // r8
+              unsigned xnuflags) {              // r9
+  int ax;
+  wt->tid = tid;
+  *wt->ptid = tid;
+  *wt->ctid = tid;
+  pthread_spin_unlock(&wt->lock);
+
+  if (wt->tls) {
+    // XNU uses the same 0x30 offset as the WIN32 TIB x64. They told the
+    // Go team at Google that they Apply stands by our ability to use it
+    // https://github.com/golang/go/issues/23617#issuecomment-376662373
+    asm volatile("syscall"
+                 : "=a"(ax)
+                 : "0"(__NR_thread_fast_set_cthread_self), "D"(wt->tls - 0x30)
+                 : "rcx", "rdx", "r8", "r9", "r10", "r11", "memory", "cc");
+  }
+
+  func(arg, tid);
+
+  // we no longer use the stack after this point
+  // %rax = int bsdthread_terminate(%rdi = void *stackaddr,
+  //                                %rsi = size_t freesize,
+  //                                %rdx = uint32_t port,
+  //                                %r10 = uint32_t sem);
+  asm volatile("movl\t$0,%0\n\t"         // *wt->ztid = 0
+               "xor\t%%r10d,%%r10d\n\t"  // sem = 0
+               "syscall\n\t"             // __bsdthread_terminate()
+               "ud2"
+               : "=m"(*wt->ztid)
+               : "a"(0x2000000 | 361), "D"(0), "S"(0), "d"(0)
+               : "rcx", "r10", "r11", "memory");
+  unreachable;
+}
+
+static int CloneXnu(int (*fn)(void *), char *stk, size_t stksz, int flags,
+                    void *arg, void *tls, int *ptid, int *ctid) {
+  int rc;
+  bool failed;
+  static bool once;
+  static int broken;
+  struct CloneArgs *wt;
+  if (!once) {
+    if (bsdthread_register(XnuThreadThunk, 0, 0, 0, 0, 0, 0) == -1) {
+      broken = errno;
+    }
+    once = true;
+  }
+  if (broken) {
+    errno = broken;
+    return -1;
+  }
+  wt = (struct CloneArgs *)(((intptr_t)(stk + stksz) -
+                             sizeof(struct CloneArgs)) &
+                            -alignof(struct CloneArgs));
+  wt->ptid = flags & CLONE_PARENT_SETTID ? ptid : &wt->tid;
+  wt->ctid = flags & CLONE_CHILD_SETTID ? ctid : &wt->tid;
+  wt->ztid = flags & CLONE_CHILD_CLEARTID ? ctid : &wt->tid;
+  wt->tls = flags & CLONE_SETTLS ? tls : 0;
+  wt->lock._lock = 1;
+  if ((rc = bsdthread_create(fn, arg, wt, 0, PTHREAD_START_CUSTOM_XNU)) != -1) {
+    pthread_spin_lock(&wt->lock);
+    rc = wt->tid;
+    pthread_spin_unlock(&wt->lock);
+  }
+  return rc;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// FREE BESIYATA DISHMAYA
+
+static wontreturn void FreebsdThreadMain(void *p) {
+  struct CloneArgs *wt = p;
+  *wt->ptid = wt->tid;
+  *wt->ctid = wt->tid;
+  wt->func(wt->arg, wt->tid);
+  // we no longer use the stack after this point
+  // void thr_exit(%rdi = long *state);
+  asm volatile("movl\t$0,%0\n\t"  // *wt->ztid = 0
+               "syscall"          // thr_exit()
+               : "=m"(*wt->ztid)
+               : "a"(431), "D"(0)
+               : "rcx", "r11", "memory");
+  unreachable;
+}
+
+static int CloneFreebsd(int (*func)(void *, int), char *stk, size_t stksz,
+                        int flags, void *arg, void *tls, int *ptid, int *ctid) {
+  int ax;
+  bool failed;
+  int64_t tid;
+  struct CloneArgs *wt;
+  wt = (struct CloneArgs *)(((intptr_t)(stk + stksz) -
+                             sizeof(struct CloneArgs)) &
+                            -alignof(struct CloneArgs));
+  wt->ptid = flags & CLONE_PARENT_SETTID ? ptid : &wt->tid;
+  wt->ctid = flags & CLONE_CHILD_SETTID ? ctid : &wt->tid;
+  wt->ztid = flags & CLONE_CHILD_CLEARTID ? ctid : &wt->tid;
+  wt->tls = tls;
+  wt->func = func;
+  wt->arg = arg;
+  struct thr_param params = {
+      .start_func = FreebsdThreadMain,
+      .arg = wt,
+      .stack_base = stk,
+      .stack_size = (((intptr_t)wt - (intptr_t)stk) & -16) - 8,
+      .tls_base = flags & CLONE_SETTLS ? tls : 0,
+      .tls_size = 64,
+      .child_tid = &wt->tid64,
+      .parent_tid = &tid,
+  };
+  asm volatile(CFLAG_ASM("syscall")
+               : CFLAG_CONSTRAINT(failed), "=a"(ax)
+               : "1"(__NR_thr_new), "D"(&params), "S"(sizeof(params))
+               : "rcx", "rdx", "r8", "r9", "r10", "r11", "memory");
+  if (failed) {
+    errno = ax;
+    tid = -1;
+  }
+  return tid;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// OPEN BESIYATA DISHMAYA
+
+static void *oldrsp;
+
+__attribute__((__constructor__)) static void OpenbsdGetSafeRsp(void) {
+  // main thread stack should never be freed during process lifetime. we
+  // won't actually change this stack below. we just need need a place
+  // where threads can park RSP for a few instructions while dying.
+  oldrsp = __builtin_frame_address(0);
+}
+
+// we can't use address sanitizer because:
+//   1. __asan_handle_no_return wipes stack [todo?]
+noasan static wontreturn void OpenbsdThreadMain(void *p) {
+  struct CloneArgs *wt = p;
+  *wt->ptid = wt->tid;
+  *wt->ctid = wt->tid;
+  wt->func(wt->arg, wt->tid);
+  // we no longer use the stack after this point. however openbsd
+  // validates the rsp register too so a race condition can still
+  // happen if the parent tries to free the stack. we'll solve it
+  // by simply changing rsp back to the old value before exiting!
+  // although ideally there should be a better solution.
+  //
+  // void __threxit(%rdi = int32_t *notdead);
+  asm volatile("mov\t%2,%%rsp\n\t"
+               "movl\t$0,(%%rdi)\n\t"  // *wt->ztid = 0
+               "syscall\n\t"           // futex()
+               "mov\t$302,%%eax\n\t"   // threxit()
+               "syscall"
+               : "=m"(*wt->ztid)
+               : "a"(83), "m"(oldrsp), "D"(wt->ztid), "S"(FUTEX_WAKE),
+                 "d"(INT_MAX)
+               : "rcx", "r11", "memory");
+  unreachable;
+}
+
+static int CloneOpenbsd(int (*func)(void *, int), char *stk, size_t stksz,
+                        int flags, void *arg, void *tls, int *ptid, int *ctid) {
+  int tid;
+  intptr_t sp;
+  struct __tfork *tf;
+  struct CloneArgs *wt;
+  sp = (intptr_t)stk + stksz;
+  sp -= sizeof(struct __tfork);
+  sp &= -alignof(struct __tfork);
+  tf = (struct __tfork *)sp;
+  sp -= sizeof(struct CloneArgs);
+  sp &= -MAX(16, alignof(struct CloneArgs));
+  wt = (struct CloneArgs *)sp;
+  wt->ptid = flags & CLONE_PARENT_SETTID ? ptid : &wt->tid;
+  wt->ctid = flags & CLONE_CHILD_SETTID ? ctid : &wt->tid;
+  wt->ztid = flags & CLONE_CHILD_CLEARTID ? ctid : &wt->tid;
+  wt->arg = arg;
+  wt->func = func;
+  tf->tf_stack = (char *)wt - 8;
+  tf->tf_tcb = flags & CLONE_SETTLS ? tls : 0;
+  tf->tf_tid = &wt->tid;
+  if ((tid = __tfork_thread(tf, sizeof(*tf), OpenbsdThreadMain, wt)) < 0) {
+    errno = -tid;
+    tid = -1;
+  }
+  return tid;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NET BESIYATA DISHMAYA
+
+static wontreturn void NetbsdThreadMain(void *arg,                 // rdi
+                                        int (*func)(void *, int),  // rsi
+                                        int *tid,                  // rdx
+                                        int *ctid,                 // rcx
+                                        int *ztid,                 // r8
+                                        int *ptid) {               // r9
+  int ax, dx;
+  // TODO(jart): Why are we seeing flakes where *tid is zero?
+  // ax = *tid;
+  ax = sys_gettid();
+  *ctid = ax;
+  func(arg, ax);
+  // we no longer use the stack after this point
+  // %eax = int __lwp_exit(void);
+  asm volatile("movl\t$0,%2\n\t"  // *wt->ztid = 0
+               "syscall\n\t"      // __lwp_exit()
+               "ud2"
+               : "=a"(ax), "=d"(dx), "=m"(*ztid)
+               : "0"(310)
+               : "rcx", "r11", "memory");
+  unreachable;
+}
+
+static int CloneNetbsd(int (*func)(void *, int), char *stk, size_t stksz,
+                       int flags, void *arg, void *tls, int *ptid, int *ctid) {
+  // NetBSD has its own clone() and it works, but it's technically a
+  // second-class API, intended to help Linux folks migrate to this.
+  bool failed;
+  int ax, *tid;
+  intptr_t dx, sp;
+  static bool once;
+  static int broken;
+  struct ucontext_netbsd *ctx;
+  static struct ucontext_netbsd netbsd_clone_template;
+
+  // memoize arbitrary valid processor state structure
+  if (!once) {
+    asm volatile(CFLAG_ASM("syscall")
+                 : CFLAG_CONSTRAINT(failed), "=a"(ax)
+                 : "1"(__NR_getcontext_netbsd), "D"(&netbsd_clone_template)
+                 : "rcx", "rdx", "r8", "r9", "r10", "r11", "memory");
+    if (failed) {
+      broken = ax;
+    }
+    once = true;
+  }
+  if (broken) {
+    errno = broken;
+    return -1;
+  }
+  sp = (intptr_t)(stk + stksz);
+
+  // allocate memory for tid
+  sp -= sizeof(int);
+  sp = sp & -alignof(int);
+  tid = (int *)sp;
+  *tid = 0;
+
+  // align the stack
+  sp = sp & -16;
+
+  // simulate call to misalign stack and ensure backtrace looks good
+  sp -= 8;
+  *(intptr_t *)sp = (intptr_t)CloneNetbsd + 1;
+
+  // place the giant 784 byte ucontext structure in the red zone!
+  // it only has to live long enough for the thread to come alive
+  ctx = (struct ucontext_netbsd *)((sp - sizeof(struct ucontext_netbsd)) &
+                                   -alignof(struct ucontext_netbsd));
+
+  // pass parameters in process state
+  memcpy(ctx, &netbsd_clone_template, sizeof(*ctx));
+  ctx->uc_link = 0;
+  ctx->uc_mcontext.rbp = 0;
+  ctx->uc_mcontext.rsp = sp;
+  ctx->uc_mcontext.rip = (intptr_t)NetbsdThreadMain;
+  ctx->uc_mcontext.rdi = (intptr_t)arg;
+  ctx->uc_mcontext.rsi = (intptr_t)func;
+  ctx->uc_mcontext.rdx = (intptr_t)tid;
+  ctx->uc_mcontext.rcx = (intptr_t)(flags & CLONE_CHILD_SETTID ? ctid : tid);
+  ctx->uc_mcontext.r8 = (intptr_t)(flags & CLONE_CHILD_CLEARTID ? ctid : tid);
+  ctx->uc_mcontext.r9 = (intptr_t)(flags & CLONE_PARENT_SETTID ? ptid : tid);
+  ctx->uc_flags |= _UC_STACK;
+  ctx->uc_stack.ss_sp = stk;
+  ctx->uc_stack.ss_size = stksz;
+  ctx->uc_stack.ss_flags = 0;
+  if (flags & CLONE_SETTLS) {
+    ctx->uc_flags |= _UC_TLSBASE;
+    ctx->uc_mcontext._mc_tlsbase = (intptr_t)tls;
+  }
+
+  // perform the system call
+  asm volatile(CFLAG_ASM("syscall")
+               : CFLAG_CONSTRAINT(failed), "=a"(ax), "=d"(dx)
+               : "1"(__NR__lwp_create), "D"(ctx), "S"(LWP_DETACHED), "2"(tid)
+               : "rcx", "r8", "r9", "r10", "r11", "memory");
+  if (!failed) {
+    return *tid;
+  } else {
+    errno = ax;
+    return -1;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// GNU/SYSTEMD
+
+int sys_clone_linux(int flags,   // rdi
+                    long sp,     // rsi
+                    int *ptid,   // rdx
+                    int *ctid,   // rcx
+                    void *tls,   // r8
+                    void *func,  // r9
+                    void *arg);  // 8(rsp)
+
+static int CloneLinux(int (*func)(void *arg, int tid), char *stk, size_t stksz,
+                      int flags, void *arg, void *tls, int *ptid, int *ctid) {
+  long sp;
+  sp = (intptr_t)(stk + stksz);
+  if (~flags & CLONE_CHILD_SETTID) {
+    flags |= CLONE_CHILD_SETTID;
+    sp -= sizeof(int);
+    sp = sp & -alignof(int);
+    ctid = (int *)sp;
+  }
+  sp = sp & -16;  // align the stack
+  return sys_clone_linux(flags, sp, ptid, ctid, tls, func, arg);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// COSMOPOLITAN
+
+/**
+ * Creates thread without malloc being linked, e.g.
+ *
+ *     int worker(void *arg) {
+ *       return 0;
+ *     }
+ *
+ *     struct CosmoTib tib = {
+ *         .tib_self = &tib,
+ *         .tib_self2 = &tib,
+ *         .tib_tid = -1,
+ *     };
+ *     char *stk = _mapstack();
+ *     tid = clone(worker, stk, GetStackSize() - 16,
+ *                 CLONE_VM | CLONE_THREAD | CLONE_FS | CLONE_FILES |
+ *                 CLONE_SIGHAND | CLONE_CHILD_SETTID |
+ *                 CLONE_CHILD_CLEARTID | CLONE_SETTLS,
+ *                 arg, 0, &tib, &tib.tib_tid);
+ *     // ...
+ *     while (atomic_load(&tib.tib_tid)) sched_yield();
+ *     _freestack(stk);
+ *
+ * Threads are created in a detached manner. They currently can't be
+ * synchronized using wait() or posix signals. Threads created by this
+ * function should be synchronized using shared memory operations.
+ *
+ * Any memory that's required by this system call wrapper is allocated
+ * to the top of your stack. This shouldn't be more than 128 bytes.
+ *
+ * Your function is called from within the stack you specify. A return
+ * address is pushed onto your stack, that causes returning to jump to
+ * _Exit1() which terminates the thread. Even though the callback says
+ * it supports a return code, that'll only work on Linux and Windows.
+ *
+ * This function follows the same ABI convention as the Linux userspace
+ * libraries, with a few small changes. The varargs has been removed to
+ * help prevent broken code, and the stack size and tls size parameters
+ * are introduced for compatibility with FreeBSD.
+ *
+ * To keep this system call lightweight, only the thread creation use
+ * case is polyfilled across platforms. For example, if you want fork
+ * that works on OpenBSD for example, don't do it with clone(SIGCHLD)
+ * and please just call fork(). Even if you do that on Linux, it will
+ * effectively work around libc features like atfork(), so that means
+ * other calls like getpid() may return incorrect values.
+ *
+ * @param func is your callback function, which this wrapper requires
+ *     not be null, otherwise EINVAL is raised. It is passed two args
+ *     within the child thread: (1) the caller-supplied `arg` and (2)
+ *     the new tid is always passed in the second arg for convenience
+ *
+ * @param stk points to the bottom of a caller allocated stack, which
+ *     must be allocated via mmap() using the MAP_STACK flag, or else
+ *     you won't get optimal performance and it won't work on OpenBSD
+ *
+ * @param stksz is the size of that stack in bytes, we recommend that
+ *     that this be set to GetStackSize() or else memory safety tools
+ *     like kprintf() can't do as good and quick of a job; this value
+ *     must be 16-aligned plus it must be at least 4192 bytes in size
+ *     and it's advised to have the bottom-most page, be a guard page
+ *
+ * @param flags which SHOULD always have all of these flags:
+ *
+ *     - `CLONE_THREAD`
+ *     - `CLONE_VM`
+ *     - `CLONE_FS`
+ *     - `CLONE_FILES`
+ *     - `CLONE_SIGHAND`
+ *
+ *     This system call wrapper is intended for threads, and as such, we
+ *     won't polyfill Linux's ability to simulate unrelated calls (e.g.
+ *     fork, vfork) via clone() on other platforms. Please just call
+ *     fork() and vfork() when that's what you want.
+ *
+ *     Your `flags` may also optionally also additionally bitwise-OR any
+ *     combination of the following additional flags:
+ *
+ *     - `CLONE_PARENT_SETTID` must be specified if you intend to set
+ *       the `ptid` argument, which is guaranteed to be updated with the
+ *       child tid BEFORE BOTH clone() returns and `func` is invoked
+ *
+ *     - `CLONE_CHILD_SETTID` must be specified if you intend to set the
+ *       `ctid` argument, which is guaranteed to be updated with the
+ *       child tid before `func` is called, however we CAN NOT guarantee
+ *       this will happen BEFORE clone() returns
+ *
+ *     - `CLONE_CHILD_CLEARTID` causes `*ctid = 0` upon child thread
+ *       termination. This is used to implement join so that the parent
+ *       may know when it's safe to free the child's stack memory, and
+ *       as such, is guaranteed to happen AFTER the child thread has
+ *       either terminated or has finished using its stack memory
+ *
+ *     - `CLONE_SETTLS` is needed if you intend to specify the `tls`
+ *       argument, which after thread creation may be accessed using
+ *       __get_tls(). Doing this means that `errno`, gettid(), etc.
+ *       correctly work. Caveat emptor if you choose not to do this.
+ *
+ * @param arg is passed as an argument to `func` in the child thread
+ * @param tls may be used to set the thread local storage segment;
+ *     this parameter is ignored if `CLONE_SETTLS` is not set
+ * @param ctid lets the child receive its thread id without having to
+ *     call gettid() and is ignored if `CLONE_CHILD_SETTID` isn't set
+ * @return tid of child on success, or -1 w/ errno
+ * @threadsafe
+ */
+int clone(void *func, void *stk, size_t stksz, int flags, void *arg, int *ptid,
+          void *tls, void *ctid) {
+  int rc;
+  struct CloneArgs *wt;
+
+  if (flags & CLONE_THREAD) {
+    __enable_threads();
+  }
+
+  if (!func) {
+    rc = einval();
+  } else if (!IsTiny() &&
+             ((flags & CLONE_VM) && (stksz < PAGESIZE || (stksz & 15)))) {
+    rc = einval();
+  } else if (IsAsan() &&
+             (((flags & CLONE_SETTLS) && !__asan_is_valid(tls, 64)) ||
+              ((flags & CLONE_PARENT_SETTID) &&
+               !__asan_is_valid(ptid, sizeof(*ptid))) ||
+              ((flags & CLONE_CHILD_SETTID) &&
+               !__asan_is_valid(ctid, sizeof(int))))) {
+    rc = efault();
+  } else if (IsLinux()) {
+    rc = CloneLinux(func, stk, stksz, flags, arg, tls, ptid, ctid);
+  } else if (!IsTiny() &&
+             (flags & ~(CLONE_SETTLS | CLONE_PARENT_SETTID |
+                        CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)) !=
+                 (CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES |
+                  CLONE_SIGHAND)) {
+    STRACE("clone flag unsupported on this platform");
+    rc = einval();
+  } else if (IsXnu()) {
+    rc = CloneXnu(func, stk, stksz, flags, arg, tls, ptid, ctid);
+  } else if (IsFreebsd()) {
+    rc = CloneFreebsd(func, stk, stksz, flags, arg, tls, ptid, ctid);
+  } else if (IsNetbsd()) {
+    rc = CloneNetbsd(func, stk, stksz, flags, arg, tls, ptid, ctid);
+  } else if (IsOpenbsd()) {
+    rc = CloneOpenbsd(func, stk, stksz, flags, arg, tls, ptid, ctid);
+  } else if (IsWindows()) {
+    rc = CloneWindows(func, stk, stksz, flags, arg, tls, ptid, ctid);
+  } else {
+    rc = enosys();
+  }
+
+  // TODO(jart): do we need it?
+  if (rc != -1 && (flags & CLONE_PARENT_SETTID)) {
+    *ptid = rc;
+  }
+
+  STRACE("clone(%t, %p, %'zu, %#x, %p, %p, %p, %p) → %d% m", func, stk, stksz,
+         flags, arg, ptid, tls, ctid, rc);
+
+  return rc;
+}
--- a/libc/runtime/clone.internal.h
+++ b/libc/runtime/clone.internal.h
@ -0,0 +1,11 @@
+#ifndef COSMOPOLITAN_LIBC_RUNTIME_CLONE_INTERNAL_H_
+#define COSMOPOLITAN_LIBC_RUNTIME_CLONE_INTERNAL_H_
+#include "libc/atomic.h"
+#if !(__ASSEMBLER__ + __LINKER__ + 0)
+COSMOPOLITAN_C_START_
+
+int clone(void *, void *, size_t, int, void *, int *, void *, void *);
+
+COSMOPOLITAN_C_END_
+#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+#endif /* COSMOPOLITAN_LIBC_RUNTIME_CLONE_INTERNAL_H_ */
--- a/libc/runtime/cosmo.S
+++ b/libc/runtime/cosmo.S
@ -20,7 +20,7 @@
 #include "libc/notice.inc"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/map.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/dce.h"
 .text.startup
--- a/libc/runtime/enable_threads.c
+++ b/libc/runtime/enable_threads.c
@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/thread/tls.h"
 #include "libc/runtime/runtime.h"

--- a/libc/runtime/enable_tls.c
+++ b/libc/runtime/enable_tls.c
@ -111,9 +111,9 @@ privileged void __enable_tls(void) {
    // malloc() being linked, which links _mapanon().  otherwise
    // if you exceed this, you need to STATIC_YOINK("_mapanon").
    // please note that it's probably too early to call calloc()
-    assert(weaken(_mapanon));
+    assert(_weaken(_mapanon));
    siz = ROUNDUP(siz, FRAMESIZE);
-    mem = weaken(_mapanon)(siz);
+    mem = _weaken(_mapanon)(siz);
    assert(mem);
  }
  if (IsAsan()) {
--- a/libc/runtime/exit.c
+++ b/libc/runtime/exit.c
@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
-#include "libc/calls/strace.internal.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"

@ -35,12 +35,11 @@
 wontreturn void exit(int exitcode) {
  const uintptr_t *p;
  STRACE("exit(%d)", exitcode);
-  if (weaken(__cxa_finalize)) {
-    weaken(__cxa_finalize)(NULL);
+  if (_weaken(__cxa_finalize)) {
+    _weaken(__cxa_finalize)(NULL);
  }
  for (p = __fini_array_end; p > __fini_array_start;) {
    ((void (*)(void))(*--p))();
  }
-  __restorewintty();
-  _Exit(exitcode);
+  _Exitr(exitcode);
 }
--- a/libc/runtime/fork-nt.c
+++ b/libc/runtime/fork-nt.c
@ -19,17 +19,16 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/ntspawn.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/strace.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/calls/wincrash.internal.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/kprintf.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
 #include "libc/macros.internal.h"
 #include "libc/mem/alloca.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/nt2sysv.h"
-#include "libc/thread/tls.h"
 #include "libc/nt/console.h"
 #include "libc/nt/createfile.h"
 #include "libc/nt/enum/accessmask.h"
@ -53,6 +52,7 @@
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
+#include "libc/thread/tls.h"

 STATIC_YOINK("_check_sigchld");

@ -243,14 +243,14 @@ textwindows void WinMainForked(void) {
 #ifdef SYSDEBUG
  RemoveVectoredExceptionHandler(oncrash);
 #endif
-  if (weaken(__wincrash_nt)) {
+  if (_weaken(__wincrash_nt)) {
    if (!IsTiny()) {
      RemoveVectoredExceptionHandler(__wincrashearly);
    }
-    AddVectoredExceptionHandler(1, (void *)weaken(__wincrash_nt));
+    AddVectoredExceptionHandler(1, (void *)_weaken(__wincrash_nt));
  }
-  if (weaken(__onntconsoleevent_nt)) {
-    SetConsoleCtrlHandler(weaken(__onntconsoleevent_nt), 1);
+  if (_weaken(__onntconsoleevent_nt)) {
+    SetConsoleCtrlHandler(_weaken(__onntconsoleevent_nt), 1);
  }

  // jump back into function below
--- a/libc/runtime/fork.c
+++ b/libc/runtime/fork.c
@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
--- a/libc/runtime/gc.h
+++ b/libc/runtime/gc.h
@ -1,27 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_RUNTIME_GC_H_
-#define COSMOPOLITAN_LIBC_RUNTIME_GC_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-COSMOPOLITAN_C_START_
-
-void *_gc(void *);
-void *_defer(void *, void *);
-void __defer(void *, void *, void *);
-void _gclongjmp(void *, int) dontthrow wontreturn;
-void _gc_free(void *);
-
-#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
-#define _gc(THING) _defer((void *)_gc_free, (void *)(THING))
-#define _defer(FN, ARG)                           \
-  ({                                              \
-    autotype(ARG) Arg = (ARG);                    \
-    /* prevent weird opts like tail call */       \
-    asm volatile("" : "+g"(Arg) : : "memory");    \
-    __defer(__builtin_frame_address(0), FN, Arg); \
-    asm volatile("" : "+g"(Arg) : : "memory");    \
-    Arg;                                          \
-  })
-#endif /* defined(__GNUC__) && !defined(__STRICT_ANSI__) */
-
-COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_RUNTIME_GC_H_ */
--- a/libc/runtime/gc.internal.h
+++ b/libc/runtime/gc.internal.h
@ -1,11 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_RUNTIME_GC_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_RUNTIME_GC_INTERNAL_H_
-#include "libc/runtime/gc.h"
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-
-#define gc(THING)          _gc(THING)
-#define defer(FN, ARG)     _defer(FN, ARG)
-#define gclongjmp(JB, ARG) _gclongjmp(JB, ARG)
-
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_RUNTIME_GC_INTERNAL_H_ */
--- a/libc/runtime/getdosargv.c
+++ b/libc/runtime/getdosargv.c
@ -18,10 +18,10 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bits.h"
 #include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/tpenc.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/runtime/internal.h"
 #include "libc/str/str.h"
-#include "libc/str/tpenc.h"
 #include "libc/str/utf16.h"

 struct DosArgv {
@ -49,7 +49,7 @@ textwindows noasan void DecodeDosArgv(int ignore, struct DosArgv *st) {

 static textwindows noasan void AppendDosArgv(wint_t wc, struct DosArgv *st) {
  uint64_t w;
-  w = tpenc(wc);
+  w = _tpenc(wc);
  do {
    if (st->p >= st->pe) break;
    *st->p++ = w & 0xff;
--- a/libc/runtime/getdosenviron.c
+++ b/libc/runtime/getdosenviron.c
@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bits.h"
+#include "libc/intrin/tpenc.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
-#include "libc/str/tpenc.h"
 #include "libc/str/utf16.h"

 #define ToUpper(c) ((c) >= 'a' && (c) <= 'z' ? (c) - 'a' + 'A' : (c))
@ -57,7 +57,7 @@ static textwindows noasan noinstrument axdx_t Recode16to8(char *dst,
        x = ToUpper(x);
      }
    }
-    w = tpenc(x);
+    w = _tpenc(x);
    do {
      if (r.ax + 1 < dstsize) {
        dst[r.ax++] = w;
--- a/libc/runtime/getsymboltable.c
+++ b/libc/runtime/getsymboltable.c
@ -17,16 +17,16 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
-#include "libc/calls/strace.internal.h"
 #include "libc/intrin/bits.h"
 #include "libc/intrin/promises.internal.h"
-#include "libc/thread/thread.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
 #include "libc/macros.internal.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
 #include "libc/str/str.h"
+#include "libc/thread/thread.h"
 #include "libc/x/x.h"
 #include "libc/zip.h"
 #include "libc/zipos/zipos.internal.h"
@ -127,7 +127,7 @@ struct SymbolTable *GetSymbolTable(void) {
  struct Zipos *z;
  if (pthread_spin_trylock(&g_lock)) return 0;
  if (!__symtab && !__isworker) {
-    if (weaken(__zipos_get) && (z = weaken(__zipos_get)())) {
+    if (_weaken(__zipos_get) && (z = _weaken(__zipos_get)())) {
      if ((__symtab = GetSymbolTableFromZip(z))) {
        __symtab->names =
            (uint32_t *)((char *)__symtab + __symtab->names_offset);
--- a/libc/runtime/grow.c
+++ b/libc/runtime/grow.c
@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/fmt/conv.h"
 #include "libc/intrin/bits.h"
 #include "libc/intrin/weaken.h"
-#include "libc/fmt/conv.h"
 #include "libc/macros.internal.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
@ -50,7 +50,7 @@ bool __grow(void *pp, size_t *capacity, size_t itemsize, size_t extra) {
  n2 = (*p ? n1 + (n1 >> 1) : MAX(4, INITIAL_CAPACITY / itemsize)) + extra;
  if (!__builtin_mul_overflow(n1, itemsize, &t1) &&
      !__builtin_mul_overflow(n2, itemsize, &t2)) {
-    if (weaken(realloc) && (p2 = weaken(realloc)(p1, ROUNDUP(t2, 32)))) {
+    if (_weaken(realloc) && (p2 = _weaken(realloc)(p1, ROUNDUP(t2, 32)))) {
      if (!p1 && *p) memcpy(p2, *p, t1);
      bzero((char *)p2 + t1, t2 - t1);
      *capacity = n2;
--- a/libc/runtime/inflate.c
+++ b/libc/runtime/inflate.c
@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
-#include "libc/calls/strace.internal.h"
 #include "libc/macros.internal.h"
 #include "libc/runtime/runtime.h"
 #include "third_party/zlib/puff.h"
@ -35,7 +35,7 @@
 int __inflate(void *out, size_t outsize, const void *in, size_t insize) {
  int rc;
  z_stream zs;
-  if (weaken(inflateInit2) && weaken(inflate) && weaken(inflateEnd)) {
+  if (_weaken(inflateInit2) && _weaken(inflate) && _weaken(inflateEnd)) {
    zs.next_in = in;
    zs.avail_in = insize;
    zs.total_in = insize;
@ -44,9 +44,9 @@ int __inflate(void *out, size_t outsize, const void *in, size_t insize) {
    zs.total_out = outsize;
    zs.zalloc = Z_NULL;
    zs.zfree = Z_NULL;
-    if ((rc = weaken(inflateInit2)(&zs, -MAX_WBITS)) == Z_OK &&
-        (rc = weaken(inflate)(&zs, Z_FINISH)) == Z_STREAM_END &&
-        (rc = weaken(inflateEnd)(&zs)) == Z_OK) {
+    if ((rc = _weaken(inflateInit2)(&zs, -MAX_WBITS)) == Z_OK &&
+        (rc = _weaken(inflate)(&zs, Z_FINISH)) == Z_STREAM_END &&
+        (rc = _weaken(inflateEnd)(&zs)) == Z_OK) {
      rc = 0;
    } else if (rc == Z_OK) {
      rc = Z_STREAM_END;  // coerce to nonzero
--- a/libc/runtime/mapanon.c
+++ b/libc/runtime/mapanon.c
@ -16,10 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/weaken.h"
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
-#include "libc/nexgen32e/bsr.h"
+#include "libc/intrin/weaken.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
@ -63,8 +62,8 @@ void *_mapanon(size_t size) {
  if (m != MAP_FAILED) {
    return m;
  }
-  if (errno == ENOMEM && weaken(__oom_hook)) {
-    weaken(__oom_hook)(size);
+  if (errno == ENOMEM && _weaken(__oom_hook)) {
+    _weaken(__oom_hook)(size);
  }
  return 0;
 }
--- a/libc/runtime/mapshared.c
+++ b/libc/runtime/mapshared.c
@ -16,9 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/weaken.h"
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
+#include "libc/intrin/weaken.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
@ -34,8 +34,8 @@ void *_mapshared(size_t size) {
  if (m != MAP_FAILED) {
    return m;
  }
-  if (errno == ENOMEM && weaken(__oom_hook)) {
-    weaken(__oom_hook)(size);
+  if (errno == ENOMEM && _weaken(__oom_hook)) {
+    _weaken(__oom_hook)(size);
  }
  return 0;
 }
--- a/libc/runtime/memtracknt.c
+++ b/libc/runtime/memtracknt.c
@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/runtime.h"
 #include "libc/runtime/memtrack.internal.h"
--- a/libc/runtime/mmap.c
+++ b/libc/runtime/mmap.c
@ -19,7 +19,6 @@
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/strace.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
@ -28,8 +27,8 @@
 #include "libc/intrin/bits.h"
 #include "libc/intrin/describeflags.internal.h"
 #include "libc/intrin/likely.h"
-#include "libc/thread/thread.h"
 #include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
 #include "libc/log/backtrace.internal.h"
@ -49,6 +48,7 @@
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/thread.h"

 #define MAP_ANONYMOUS_linux   0x00000020
 #define MAP_ANONYMOUS_openbsd 0x00001000
@ -64,10 +64,9 @@
 #define FRAME(x)   ((int)((intptr_t)(x) >> 16))

 static wontreturn void OnUnrecoverableMmapError(const char *s) {
-  if (weaken(__die)) weaken(__die)();
+  if (_weaken(__die)) _weaken(__die)();
  STRACE("%s %m", s);
-  __restorewintty();
-  _Exit(199);
+  _Exitr(199);
 }

 static noasan inline bool OverlapsExistingMapping(char *p, size_t n) {
@ -165,8 +164,8 @@ static noasan void *FinishMemory(void *addr, size_t size, int prot, int flags,
    }
    return MAP_FAILED;
  }
-  if (weaken(__asan_map_shadow) && !OverlapsShadowSpace(addr, size)) {
-    weaken(__asan_map_shadow)((intptr_t)addr, size);
+  if (_weaken(__asan_map_shadow) && !OverlapsShadowSpace(addr, size)) {
+    _weaken(__asan_map_shadow)((intptr_t)addr, size);
  }
  return addr;
 }
@ -227,8 +226,8 @@ static textwindows dontinline noasan void *MapMemories(char *addr, size_t size,
      OnUnrecoverableMmapError("MapMemories unrecoverable #2");
    }
  }
-  if (weaken(__asan_map_shadow) && !OverlapsShadowSpace(addr, size)) {
-    weaken(__asan_map_shadow)((intptr_t)addr, size);
+  if (_weaken(__asan_map_shadow) && !OverlapsShadowSpace(addr, size)) {
+    _weaken(__asan_map_shadow)((intptr_t)addr, size);
  }
  return addr;
 }
@ -323,7 +322,7 @@ static noasan inline void *Mmap(void *addr, size_t size, int prot, int flags,
    return VIP(einval());
  }

-  a = max(1, rounddown2pow(size) >> 16);
+  a = max(1, _rounddown2pow(size) >> 16);

  f = (flags & ~MAP_FIXED_NOREPLACE) | MAP_FIXED;
  if (flags & MAP_FIXED) {
--- a/libc/runtime/morph.greg.c
+++ b/libc/runtime/morph.greg.c
@ -19,7 +19,7 @@
 #define ShouldUseMsabiAttribute() 1
 #include "libc/assert.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
--- a/libc/runtime/mprotect.c
+++ b/libc/runtime/mprotect.c
@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
--- a/libc/runtime/mremap.c
+++ b/libc/runtime/mremap.c
@ -17,13 +17,13 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
-#include "libc/intrin/likely.h"
-#include "libc/intrin/weaken.h"
 #include "libc/calls/calls.h"
-#include "libc/calls/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
 #include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/likely.h"
+#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/weaken.h"
 #include "libc/macros.internal.h"
 #include "libc/nt/runtime.h"
 #include "libc/runtime/directmap.internal.h"
@ -152,8 +152,8 @@ void *mremap(void *p, size_t n, size_t m, int f, ... /* void *q */) {
    if (TrackMemoryInterval(&_mmi, ((uintptr_t)p + n) >> 16,
                            ((uintptr_t)p + m - FRAMESIZE) >> 16, dm.maphandle,
                            prot, flags, false, false, 0, m - n) != -1) {
-      if (weaken(__asan_map_shadow)) {
-        weaken(__asan_map_shadow)((uintptr_t)dm.addr, m - n);
+      if (_weaken(__asan_map_shadow)) {
+        _weaken(__asan_map_shadow)((uintptr_t)dm.addr, m - n);
      }
      return p;
    } else {
@ -186,12 +186,12 @@ void *mremap(void *p, size_t n, size_t m, int f, ... /* void *q */) {
                               ((uintptr_t)p + n - FRAMESIZE) >> 16, 0) != -1 &&
        TrackMemoryInterval(&_mmi, a, b, -1, prot, flags, false, false, 0, m) !=
            -1) {
-      if (weaken(__asan_poison)) {
+      if (_weaken(__asan_poison)) {
        if (!OverlapsShadowSpace(p, n)) {
-          weaken(__asan_poison)((intptr_t)p, n, kAsanUnmapped);
+          _weaken(__asan_poison)((intptr_t)p, n, kAsanUnmapped);
        }
        if (!OverlapsShadowSpace(q, m)) {
-          weaken(__asan_map_shadow)((intptr_t)q, m);
+          _weaken(__asan_map_shadow)((intptr_t)q, m);
        }
      }
      return (void *)ADDR(a);
--- a/libc/runtime/msync.c
+++ b/libc/runtime/msync.c
@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
--- a/libc/runtime/munmap.c
+++ b/libc/runtime/munmap.c
@ -18,13 +18,12 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/strace.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/asan.internal.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/weaken.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/log/backtrace.internal.h"
 #include "libc/log/libfatal.internal.h"
 #include "libc/log/log.h"
--- a/libc/runtime/opensymboltable.greg.c
+++ b/libc/runtime/opensymboltable.greg.c
@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/elf/def.h"
 #include "libc/elf/scalar.h"
@ -164,7 +164,7 @@ struct SymbolTable *OpenSymbolTable(const char *filename) {
    x = sym->st_value - t->addr_base;
    stp[m++] = (unsigned long)x << 32 | i;
  }
-  longsort(stp, m);
+  _longsort(stp, m);
  for (j = i = 0; i < m; ++i) {
    sym = symtab + (stp[i] & 0x7fffffff);
    x = stp[i] >> 32;
--- a/libc/runtime/printargs.c
+++ b/libc/runtime/printargs.c
@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/calls/struct/rlimit.h"
 #include "libc/calls/struct/sched_param.h"
 #include "libc/calls/struct/sigset.h"
--- a/libc/runtime/runtime.h
+++ b/libc/runtime/runtime.h
@ -63,6 +63,7 @@ void _longjmp(jmp_buf, int) libcesque wontreturn paramsnonnull();
 void exit(int) wontreturn;
 void _exit(int) libcesque wontreturn;
 void _Exit(int) libcesque wontreturn;
+void _Exitr(int) libcesque wontreturn;
 void _Exit1(int) libcesque wontreturn;
 void quick_exit(int) wontreturn;
 void abort(void) wontreturn;
@ -87,25 +88,22 @@ long gethostid(void);
 int sethostid(long);
 char *getlogin(void);
 int getlogin_r(char *, size_t);
-int lchown(const char *, uint32_t, uint32_t);
 int getpagesize(void);
 int syncfs(int);
 int vhangup(void);
 int getdtablesize(void);
 int sethostname(const char *, size_t);
 int acct(const char *);
-void longsort(long *, size_t);
-
+void _longsort(long *, size_t);
 bool _isheap(void *);
 int NtGetVersion(void) pureconst;
-long missingno();
+long _missingno();
 void __oom_hook(size_t);
 void _loadxmm(void *);
 void _peekall(void);
 void _savexmm(void *);
 void _weakfree(void *);
 void free_s(void *) paramsnonnull() libcesque;
-int close_s(int *) paramsnonnull() libcesque;
 int OpenExecutable(void);
 int ftrace_install(void);
 long GetResourceLimit(int);
@ -117,13 +115,11 @@ void __paginate(int, const char *);
 int __arg_max(void);
 void __morph_begin(void);
 void __morph_end(void);
-unsigned char *GetFirstInstruction(void);
-unsigned char *GetInstructionLengths(void);
 void __print_maps(void);
 void __warn_if_powersave(void);
 const char *__describe_os(void);
 bool IsDynamicExecutable(const char *);
-void __restorewintty(void);
+void _restorewintty(void);

 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
--- a/libc/runtime/stackchkfail.c
+++ b/libc/runtime/stackchkfail.c
@ -21,6 +21,5 @@

 privileged noasan noinstrument void __stack_chk_fail(void) {
  kprintf("stack smashed\n");
-  __restorewintty();
-  _Exit(207);
+  _Exitr(207);
 }
--- a/libc/runtime/straceinit.greg.c
+++ b/libc/runtime/straceinit.greg.c
@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/safemacros.internal.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/log/libfatal.internal.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
--- a/libc/runtime/symbols.c
+++ b/libc/runtime/symbols.c
@ -16,15 +16,15 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/weaken.h"
 #include "libc/dce.h"
+#include "libc/intrin/weaken.h"
 #include "libc/log/backtrace.internal.h"
 #include "libc/log/log.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"

 void __init_symbols(void) {
-  if (__strace || (IsAsan() && weaken(__die))) {
+  if (__strace || (IsAsan() && _weaken(__die))) {
    GetSymbolTable();
  }
 }
--- a/libc/runtime/vfork.S
+++ b/libc/runtime/vfork.S
@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/calls/strace.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/macros.internal.h"
 .privileged

--- a/libc/runtime/warnifpowersave.c
+++ b/libc/runtime/warnifpowersave.c
@ -37,6 +37,6 @@ void __warn_if_powersave(void) {
  if ((fd = open(FILE, O_RDONLY)) == -1) return;
  read(fd, buf, 15);
  close(fd);
-  if (!startswith(buf, "powersave")) return;
+  if (!_startswith(buf, "powersave")) return;
  write(2, WARN, sizeof(WARN) - 1);
 }
--- a/libc/runtime/weakfree.c
+++ b/libc/runtime/weakfree.c
@ -24,7 +24,7 @@
 * Thunks free() if it's linked, otherwise do nothing.
 */
 void _weakfree(void *p) {
-  if (weaken(free)) {
-    weaken(free)(p);
+  if (_weaken(free)) {
+    _weaken(free)(p);
  }
 }
--- a/libc/runtime/winmain.greg.c
+++ b/libc/runtime/winmain.greg.c
@ -17,7 +17,6 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/state.internal.h"
-#include "libc/calls/strace.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/elf/pf2prot.internal.h"
@ -27,10 +26,10 @@
 #include "libc/intrin/describeflags.internal.h"
 #include "libc/intrin/nomultics.internal.h"
 #include "libc/intrin/pushpop.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/libfatal.internal.h"
 #include "libc/macros.internal.h"
-#include "libc/nexgen32e/bsr.h"
 #include "libc/nexgen32e/nt2sysv.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/nt/console.h"
@ -57,7 +56,6 @@
 #include "libc/runtime/winargs.internal.h"
 #include "libc/sock/internal.h"
 #include "libc/str/str.h"
-#include "libc/str/tpenc.h"
 #include "libc/str/utf16.h"

 #if IsTiny()
@ -281,7 +279,7 @@ __msabi textwindows int64_t WinMain(int64_t hInstance, int64_t hPrevInstance,
 #endif
  NTTRACE("WinMain()");
  MakeLongDoubleLongAgain();
-  if (weaken(WinSockInit)) weaken(WinSockInit)();
-  if (weaken(WinMainForked)) weaken(WinMainForked)();
+  if (_weaken(WinSockInit)) _weaken(WinSockInit)();
+  if (_weaken(WinMainForked)) _weaken(WinMainForked)();
  WinMainNew(cmdline);
 }