@scriptc/runtime 0.0.25 → 0.0.27

package/src/scr_lib.c

@@ -104,14 +104,14 @@ extern char **environ; /* env snapshot (scr_env_pairs) */
 
 /* ── process ─────────────────────────────────────────────────────────── */
 
-static int scr_lib_argc = 0;
-static char **scr_lib_argv = NULL;
-static ScrArr *scr_argv_arr = NULL;    /* interned process.argv */
-static ScrStr *scr_platform_str = NULL; /* interned process.platform */
-static ScrStr *scr_exec_path_str = NULL; /* interned process.execPath */
-static ScrStr *scr_arch_str = NULL;      /* interned process.arch */
-static ScrStr *scr_versions_node_str = NULL; /* interned process.versions.node */
-static ScrStr *scr_versions_openssl_str = NULL; /* interned process.versions.openssl */
+static SCR_TL int scr_lib_argc = 0;
+static SCR_TL char **scr_lib_argv = NULL;
+static SCR_TL ScrArr *scr_argv_arr = NULL;    /* interned process.argv */
+static SCR_TL ScrStr *scr_platform_str = NULL; /* interned process.platform */
+static SCR_TL ScrStr *scr_exec_path_str = NULL; /* interned process.execPath */
+static SCR_TL ScrStr *scr_arch_str = NULL;      /* interned process.arch */
+static SCR_TL ScrStr *scr_versions_node_str = NULL; /* interned process.versions.node */
+static SCR_TL ScrStr *scr_versions_openssl_str = NULL; /* interned process.versions.openssl */
 
 static void scr_lib_cleanup(void) {
   scr_arr_release(scr_argv_arr);
@@ -175,6 +175,8 @@ ScrStr *scr_process_platform(void) {
     scr_platform_str = scr_str_new("darwin", 6);
 #elif defined(__linux__)
     scr_platform_str = scr_str_new("linux", 5);
+#elif defined(__wasi__)
+    scr_platform_str = scr_str_new("wasi", 4);
 #elif defined(_WIN32)
     scr_platform_str = scr_str_new("win32", 5);
 #else
@@ -188,7 +190,11 @@ ScrStr *scr_process_platform(void) {
  * Node spells its own build's arch. Interned like process.platform. */
 ScrStr *scr_process_arch(void) {
   if (!scr_arch_str) {
-#if defined(__aarch64__) || defined(_M_ARM64)
+#if defined(__wasm32__)
+    scr_arch_str = scr_str_new("wasm32", 6);
+#elif defined(__wasm64__)
+    scr_arch_str = scr_str_new("wasm64", 6);
+#elif defined(__aarch64__) || defined(_M_ARM64)
     scr_arch_str = scr_str_new("arm64", 5);
 #elif defined(__x86_64__) || defined(_M_X64)
     scr_arch_str = scr_str_new("x64", 3);
@@ -350,11 +356,11 @@ ScrArr *scr_env_pairs(void) {
 
 double scr_process_pid(void) { return (double)getpid(); }
 
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
 /* No uids/gids exist on Windows: Node's process object simply has no
  * getuid/getgid members there, so a call is the property-access TypeError
  * below — thrown catchably, exactly what `process.getuid()` does under
- * Windows Node. */
+ * Windows Node. WASI has no uid/gid process model either. */
 double scr_process_getuid(void) {
   scr_throw_error_msg(SCR_ERR_TYPE, "process.getuid is not a function", 32);
   return 0;
@@ -532,6 +538,14 @@ static int scr_win_kill(int pid, int sig) {
   return 0;
 }
 #define scr_sys_kill(pid, sig) scr_win_kill((int)(pid), (sig))
+#elif defined(__wasi__)
+static int scr_wasi_kill(int pid, int sig) {
+  (void)pid;
+  (void)sig;
+  errno = ENOSYS;
+  return -1;
+}
+#define scr_sys_kill(pid, sig) scr_wasi_kill((int)(pid), (sig))
 #else
 #define scr_sys_kill(pid, sig) kill((pid_t)(pid), (sig))
 #endif
@@ -689,6 +703,27 @@ ScrStr *scr_os_tmpdir(void) {
   if (len > 1 && (buf[len - 1] == '\\' || buf[len - 1] == '/')) len--;
   return scr_str_new(buf, len);
 }
+#elif defined(__wasi__)
+/* WASI has an inherited environment but no passwd database, uname, or
+ * physical-memory query. Keep the useful environment-backed answers and
+ * spell the platform explicitly for the rest. */
+ScrStr *scr_os_homedir(void) {
+  const char *home = getenv("HOME");
+  return scr_str_new(home ? home : "", home ? strlen(home) : 0);
+}
+ScrStr *scr_os_user_name(void) {
+  const char *user = getenv("USER");
+  return scr_str_new(user ? user : "", user ? strlen(user) : 0);
+}
+ScrStr *scr_os_user_shell(void) { return scr_str_new("", 0); }
+ScrStr *scr_os_user_homedir(void) { return scr_os_homedir(); }
+ScrStr *scr_os_release(void) { return scr_str_new("", 0); }
+ScrStr *scr_os_type(void) { return scr_str_new("WASI", 4); }
+double scr_os_totalmem(void) { return 0; }
+/* The guest temp namespace is stable across hosts. `scriptc run` preopens
+ * the host's /tmp at this path; other WASI hosts can provide the same
+ * capability without leaking a host-specific TMPDIR into the module. */
+ScrStr *scr_os_tmpdir(void) { return scr_str_new("/tmp", 4); }
 #else
 ScrStr *scr_os_homedir(void) {
   /* uv_os_homedir: $HOME when set (even empty is "set" only if non-NULL;
@@ -1068,8 +1103,27 @@ void scr_process_exit(double code) {
  * attribute monotonic stamp — the binary's own start, which is what
  * "the current Node.js process" means for a compiled program). */
 #ifdef _WIN32
+#if defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)
+/* The uptime anchor belongs to the host PROCESS, not to a library
+ * instance. InitOnce keeps the lazy Windows spelling race-free when
+ * several thread instances ask for the clock concurrently. */
+static INIT_ONCE scr_uptime_once = INIT_ONCE_STATIC_INIT;
 static double scr_uptime_t0_ms;
+static BOOL CALLBACK scr_uptime_anchor_once(PINIT_ONCE once, PVOID param,
+                                             PVOID *ctx) {
+  (void)once;
+  (void)param;
+  (void)ctx;
+  scr_uptime_t0_ms = (double)GetTickCount64();
+  return TRUE;
+}
+static void scr_uptime_anchor_init(void) {
+  InitOnceExecuteOnce(&scr_uptime_once, scr_uptime_anchor_once, NULL, NULL);
+}
+#else
+static SCR_TL double scr_uptime_t0_ms;
 static void scr_uptime_anchor_init(void) { scr_uptime_t0_ms = (double)GetTickCount64(); }
+#endif
 static double scr_uptime_now_ms(void) { return (double)GetTickCount64(); }
 #else
 #include <sys/resource.h>
@@ -1077,6 +1131,10 @@ static double scr_uptime_now_ms(void) { return (double)GetTickCount64(); }
 #ifdef __APPLE__
 #include <mach/mach.h>
 #endif
+/* A load-time, process-wide anchor: the constructor runs on only the
+ * initial thread, while thread-instanced archives are entered from worker
+ * threads whose TLS slots would otherwise stay zero. It is immutable once
+ * main starts, so sharing it adds no cross-instance mutable state. */
 static double scr_uptime_t0_ms;
 static double scr_uptime_now_ms(void) {
   struct timespec ts;
@@ -1089,7 +1147,9 @@ __attribute__((constructor)) static void scr_uptime_anchor_init(void) {
 #endif
 
 double scr_process_uptime(void) {
-#ifdef _WIN32
+#if defined(_WIN32) && defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)
+  scr_uptime_anchor_init();
+#elif defined(_WIN32)
   if (scr_uptime_t0_ms == 0) scr_uptime_anchor_init();
 #endif
   return (scr_uptime_now_ms() - scr_uptime_t0_ms) / 1000.0;
@@ -1099,7 +1159,9 @@ double scr_process_uptime(void) {
  * start (Node's timeOrigin anchor), fractional — the same monotonic
  * clock and anchor as uptime, in Node's performance.now units. */
 double scr_perf_now(void) {
-#ifdef _WIN32
+#if defined(_WIN32) && defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)
+  scr_uptime_anchor_init();
+#elif defined(_WIN32)
   if (scr_uptime_t0_ms == 0) scr_uptime_anchor_init();
 #endif
   return scr_uptime_now_ms() - scr_uptime_t0_ms;
@@ -1226,7 +1288,7 @@ double scr_thread_cpu_system_diff(double prev) { return scr_thread_cpu_system()
  * Darwin's bytes by 1024; the rest are getrusage's own counters, zero
  * where the platform never fills them). */
 double scr_process_rusage(double idx) {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
   /* uv fills only the CPU times and page-fault/maxRSS slice on Windows;
    * everything else answers 0 — Node's own shape there. */
   switch ((int)idx) {
@@ -1318,7 +1380,7 @@ double scr_available_memory(void) {
 /* process._exiting — true once the exit sequence began (set above and by
  * scr_run_exit_listeners in scr_events.c; the flag lives HERE so reading
  * it never forces the events unit into the link). */
-bool scr_process_in_exit = false;
+SCR_TL bool scr_process_in_exit = false;
 
 bool scr_process_exiting(void) { return scr_process_in_exit; }
 
@@ -1336,6 +1398,11 @@ double scr_process_umask(double mask) {
     _umask_s((int)mask, &prev);
   }
   return (double)prev;
+#elif defined(__wasi__)
+  static SCR_TL mode_t current = 022;
+  mode_t prev = current;
+  if (mask >= 0) current = (mode_t)mask;
+  return (double)prev;
 #else
   mode_t prev;
   if (mask < 0) {
@@ -1359,7 +1426,7 @@ void scr_process_chdir(ScrStr *dir) {
 /* net's process-wide happy-eyeballs attempt budget (Node's
  * getDefaultAutoSelectFamilyAttemptTimeout pair, default 250ms). Lives in
  * the core unit so the knob never forces scr_net.c into the link. */
-static double scr_net_autosel_timeout_ms = 250;
+static SCR_TL double scr_net_autosel_timeout_ms = 250;
 
 double scr_net_get_autosel_timeout(void) { return scr_net_autosel_timeout_ms; }
 
@@ -1653,9 +1720,10 @@ void scr_fs_chmod(ScrStr *path, double mode) {
 }
 
 void scr_fs_chown(ScrStr *path, double uid, double gid) {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
   /* libuv's uv_fs_chown on Windows is an unconditional no-op success —
-   * Node's chownSync "works" and changes nothing there; same here. */
+   * Node's chownSync "works" and changes nothing there; WASI likewise has
+   * no ownership model. */
   (void)path; (void)uid; (void)gid;
 #else
   /* Node passes the ids straight to chown(2); -1 is the POSIX "leave
@@ -1863,7 +1931,7 @@ static bool scr_fs_write_fd_valid(double fd) {
  * call, preserving any signal that was already pending. */
 static ssize_t scr_fs_write_once(int fd, const void *data, size_t length,
                                  bool positioned, double position) {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
   return positioned
     ? scr_fs_pwrite(fd, data, length, position)
     : write(fd, data, length);
@@ -2520,23 +2588,23 @@ void scr_fs_rm_opts_retry(ScrStr *path, bool recursive, bool force, double max_r
   scr_str_release(f.path);
 }
 
-#ifdef _WIN32
-/* No mkdtemp in the CRT: libuv's own fallback shape — six random
+#if defined(_WIN32) || defined(__wasi__)
+/* No mkdtemp in the Windows CRT or WASI libc: libuv's own fallback shape — six random
  * [a-z0-9] name characters from the CSPRNG, retried on EEXIST. */
-static char *scr_win_mkdtemp(char *tmpl) {
+static char *scr_portable_mkdtemp(char *tmpl) {
   static const char cs[] = "abcdefghijklmnopqrstuvwxyz0123456789";
   size_t len = strlen(tmpl);
   for (int tries = 0; tries < 32; tries++) {
     unsigned char r[6];
     arc4random_buf(r, sizeof r);
     for (size_t i = 0; i < 6; i++) tmpl[len - 6 + i] = cs[r[i] % 36];
-    if (mkdir(tmpl) == 0) return tmpl;
+    if (scr_sys_mkdir(tmpl, 0777) == 0) return tmpl;
     if (errno != EEXIST) break;
   }
   memcpy(tmpl + len - 6, "XXXXXX", 6); /* the error message shows the template */
   return NULL;
 }
-#define mkdtemp scr_win_mkdtemp
+#define mkdtemp scr_portable_mkdtemp
 #endif
 
 ScrStr *scr_fs_mkdtemp(ScrStr *prefix) {
@@ -2688,6 +2756,8 @@ double scr_process_columns(double fd) {
   CONSOLE_SCREEN_BUFFER_INFO info;
   if (h == INVALID_HANDLE_VALUE || !GetConsoleScreenBufferInfo(h, &info)) return -1;
   return (double)(info.srWindow.Right - info.srWindow.Left + 1);
+#elif defined(__wasi__)
+  return -1;
 #else
   struct winsize ws;
   if (ioctl((int)fd, TIOCGWINSZ, &ws) != 0) return -1;
@@ -2702,8 +2772,8 @@ double scr_process_columns(double fd) {
  * NON-TTY stdin: Node's process.stdin is a Socket with no setRawMode
  * member at all, so the call throws Node's exact catchable TypeError. */
 #ifdef _WIN32
-static DWORD scr_stdin_cooked;
-static bool scr_stdin_cooked_saved = false;
+static SCR_TL DWORD scr_stdin_cooked;
+static SCR_TL bool scr_stdin_cooked_saved = false;
 
 void scr_process_stdin_set_raw_mode(bool raw) {
   if (!isatty(0)) {
@@ -2728,9 +2798,15 @@ void scr_process_stdin_set_raw_mode(bool raw) {
     (void)SetConsoleMode(h, scr_stdin_cooked);
   }
 }
+#elif defined(__wasi__)
+void scr_process_stdin_set_raw_mode(bool raw) {
+  (void)raw;
+  const char msg[] = "process.stdin.setRawMode is not a function";
+  scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+}
 #else
-static struct termios scr_stdin_cooked;
-static bool scr_stdin_cooked_saved = false;
+static SCR_TL struct termios scr_stdin_cooked;
+static SCR_TL bool scr_stdin_cooked_saved = false;
 
 void scr_process_stdin_set_raw_mode(bool raw) {
   if (!isatty(0)) {

package/src/scr_library.c

@@ -10,6 +10,24 @@
  * profile-agnostic and the program TU carries every profile-named symbol —
  * one place for the conformance symbol audit to look.
  *
+ * Multi-instance processes (the profile's abi.localize_runtime): the
+ * archive build demotes this file's externals — and every other runtime
+ * internal — to LOCAL symbols, so each linked archive carries its own
+ * private copy of all the state here: its own sink registration, poison
+ * flag, arena, and entry-symbol slot. Sinks therefore register per
+ * instance, and a trap poisons only the instance it fired in. Nothing in
+ * this file is thread-aware; the embedder contract is one thread per
+ * instance (an instance is never entered from two threads).
+ *
+ * Thread-instanced archives (the profile's abi.instance_per_thread) take
+ * the same story one level down: SCR_TL moves this file's state — and
+ * every other mutable static in the archive — into thread-local storage,
+ * so ONE linked archive serves one independent instance per embedder
+ * thread. A thread registers its own sink and calls the init entry before
+ * serving; its trap poisons only its own instance while sibling threads'
+ * instances keep answering. The one-thread-per-instance contract is
+ * unchanged — the calling thread IS the instance selector.
+ *
  * State after a sink call: none is legal. The trap fired mid-operation with
  * no unwinding — heap, arena, and collector state are unspecified; the library
  * is POISONED. Every runtime-touching entry prologue aborts on the flag
@@ -23,9 +41,9 @@
 
 /* ── sink registration + poison ───────────────────────────────────────── */
 
-static ScrLibSinkFn scr_library_sink = NULL;
-static void *scr_library_sink_ctx = NULL;
-static bool scr_library_poisoned = false;
+static SCR_TL ScrLibSinkFn scr_library_sink = NULL;
+static SCR_TL void *scr_library_sink_ctx = NULL;
+static SCR_TL bool scr_library_poisoned = false;
 
 void scr_library_set_sink(ScrLibSinkFn fn, void *ctx) {
   /* Latest registration wins; re-registration is permitted before a trap.
@@ -62,10 +80,12 @@ void scr_library_set_sink(ScrLibSinkFn fn, void *ctx) {
 
 /* The current-entry slot: every generated entry's prologue records its
  * external symbol before dispatching into core code. A single static slot
- * is sound — exactly one core is live per process (the one-live-core rule),
- * entries never nest, and a trap can only fire while an entry is on the
- * stack. NULL (never entered) renders as the empty symbol field. */
-static const char *scr_library_entry_symbol = NULL;
+ * is sound — exactly one core is live per copy of this state (the sole
+ * core in a classic process; each archive's own instance under
+ * abi.localize_runtime, where this slot is a per-instance local), entries
+ * never nest, and a trap can only fire while an entry is on the stack.
+ * NULL (never entered) renders as the empty symbol field. */
+static SCR_TL const char *scr_library_entry_symbol = NULL;
 
 /* Detected-trap classification: the runtime's trap sites self-classify
  * through their message conventions (the exact bytes the executable lane
@@ -103,7 +123,7 @@ static _Noreturn void scr_library_trap_deliver(const char *msg, size_t len, uint
      * no malloc on the failure path; text truncates before structure ever
      * would (codes and symbols are short; an oversized remediation drops
      * whole, never split). */
-    static char buf[2048];
+    static SCR_TL char buf[2048];
     const char *code = scr_library_trap_code(msg, len);
     const char *text = msg;
     size_t text_len = len;
@@ -168,7 +188,7 @@ __attribute__((noinline)) _Noreturn void scr_trap_len(const char *msg, size_t le
 }
 
 __attribute__((noinline)) _Noreturn void scr_trap_fmt(const char *fmt, ...) {
-  static char buf[512]; /* no malloc on the invariant-failure path */
+  static SCR_TL char buf[512]; /* no malloc on the invariant-failure path */
   va_list ap;
   va_start(ap, fmt);
   int n = vsnprintf(buf, sizeof buf, fmt, ap);
@@ -202,8 +222,8 @@ typedef struct {
   bool is_str; /* ScrStr vs ScrBytes — picks the release */
 } ScrCoreArenaEnt;
 
-static ScrCoreArenaEnt *scr_library_arena = NULL;
-static size_t scr_library_arena_n = 0, scr_library_arena_cap = 0;
+static SCR_TL ScrCoreArenaEnt *scr_library_arena = NULL;
+static SCR_TL size_t scr_library_arena_n = 0, scr_library_arena_cap = 0;
 
 static void scr_library_arena_keep(void *v, bool is_str) {
   if (scr_library_arena_n == scr_library_arena_cap) {
@@ -285,8 +305,8 @@ void scr_library_bytes_out(ScrBytes *b, const uint8_t **out, size_t *out_len) {
  * satisfied because the entry persists. */
 
 #define SCR_LIB_MAX_RESETS 32
-static void (*scr_library_resets[SCR_LIB_MAX_RESETS])(void);
-static size_t scr_library_nresets = 0;
+static SCR_TL void (*scr_library_resets[SCR_LIB_MAX_RESETS])(void);
+static SCR_TL size_t scr_library_nresets = 0;
 
 void scr_library_register_reset(void (*fn)(void)) {
   for (size_t i = 0; i < scr_library_nresets; i++) {

package/src/scr_map.c

@@ -24,7 +24,7 @@
 /* Live heap-map count for the RC audit lane (-DSCR_RC_AUDIT); same contract
  * as scr_str_live_count in scr_string.c. */
 #ifdef SCR_RC_AUDIT
-static long scr_live_maps = 0;
+static SCR_TL long scr_live_maps = 0;
 long scr_map_live_count(void) { return scr_live_maps; }
 #endif
 

package/src/scr_musl.c

@@ -0,0 +1,274 @@
+/* musl libc shim — compiled into linux-musl target builds only (cc.ts adds
+ * this TU together with -DSCR_MUSL). musl deliberately provides no libc
+ * identification macro, so the target-selected project macro is the guard.
+ *
+ * The x86_64 ucontext implementation below is derived from libucontext
+ * commit 49e671dd52ff6791295d8161ad3b6da7dc5f6f9d:
+ * https://github.com/kaniini/libucontext
+ *
+ * Copyright (c) 2018-2025 Ariadne Conill <ariadne@dereferenced.org>
+ *
+ * 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.
+ *
+ * This software is provided 'as is' and without any warranty, express or
+ * implied. In no event shall the authors be liable for any damages arising
+ * from the use of this software. */
+#ifdef SCR_MUSL
+
+#include "scr_runtime.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/random.h>
+#ifndef SCR_LIB
+#include <stdarg.h>
+#include <ucontext.h>
+#endif
+
+#if !defined(__x86_64__)
+#error "scriptc's musl runtime currently supports x86_64 only"
+#endif
+
+/* The scriptc runtime uses arc4random_buf as its infallible CSPRNG contract.
+ * Linux getrandom has the same kernel source and needs neither mutable state
+ * nor an fd. Retry interrupts and short reads; any other failure enters the
+ * runtime trap funnel rather than returning predictable or partially
+ * initialized bytes. Executables still print and abort there, while library
+ * artifacts deliver the failure to their registered panic sink. */
+void arc4random_buf(void *buf, size_t n) {
+  unsigned char *p = buf;
+  while (n > 0) {
+    ssize_t got = getrandom(p, n, 0);
+    if (got > 0) {
+      p += (size_t)got;
+      n -= (size_t)got;
+      continue;
+    }
+    if (got < 0 && errno == EINTR) continue;
+    scr_trap("scriptc: getrandom failed\n");
+  }
+}
+
+/* Library artifacts contain no fibers or event loop, so they need only the
+ * CSPRNG shim above and must not acquire context-switching definitions. */
+#ifndef SCR_LIB
+
+/* musl exposes the POSIX ucontext types but intentionally omits these legacy
+ * functions. scriptc's async/generator fibers need only user-space register
+ * swaps; they never use a context to mutate the process signal mask. This is
+ * libucontext's fast (non-POSIX-signal-mask) x86_64 implementation, emitted
+ * under the standard symbol names that musl leaves unresolved. */
+_Static_assert(offsetof(ucontext_t, uc_mcontext.gregs) == 40,
+               "unexpected musl x86_64 ucontext layout");
+_Static_assert(offsetof(ucontext_t, uc_mcontext.fpregs) == 224,
+               "unexpected musl x86_64 fpregs layout");
+_Static_assert(offsetof(ucontext_t, __fpregs_mem) == 424,
+               "unexpected musl x86_64 fpregs storage layout");
+
+/* Keep the assembler independent of whether the sysroot exposes glibc's
+ * REG_* spellings as enum constants, self-referential macros, or neither. */
+#undef REG_R8
+#undef REG_R9
+#undef REG_R10
+#undef REG_R11
+#undef REG_R12
+#undef REG_R13
+#undef REG_R14
+#undef REG_R15
+#undef REG_RDI
+#undef REG_RSI
+#undef REG_RBP
+#undef REG_RBX
+#undef REG_RDX
+#undef REG_RAX
+#undef REG_RCX
+#undef REG_RSP
+#undef REG_RIP
+#define REG_R8 0
+#define REG_R9 1
+#define REG_R10 2
+#define REG_R11 3
+#define REG_R12 4
+#define REG_R13 5
+#define REG_R14 6
+#define REG_R15 7
+#define REG_RDI 8
+#define REG_RSI 9
+#define REG_RBP 10
+#define REG_RBX 11
+#define REG_RDX 12
+#define REG_RAX 13
+#define REG_RCX 14
+#define REG_RSP 15
+#define REG_RIP 16
+
+#define SCR_STR_INNER(x) #x
+#define SCR_STR(x) SCR_STR_INNER(x)
+#define SCR_UC_GREG(reg) (40 + ((reg) * 8))
+
+__asm__(
+    ".text\n"
+    ".global getcontext\n"
+    "getcontext:\n"
+    "  movq %r8, "  SCR_STR(SCR_UC_GREG(REG_R8))  "(%rdi)\n"
+    "  movq %r9, "  SCR_STR(SCR_UC_GREG(REG_R9))  "(%rdi)\n"
+    "  movq %r10, " SCR_STR(SCR_UC_GREG(REG_R10)) "(%rdi)\n"
+    "  movq %r11, " SCR_STR(SCR_UC_GREG(REG_R11)) "(%rdi)\n"
+    "  movq %r12, " SCR_STR(SCR_UC_GREG(REG_R12)) "(%rdi)\n"
+    "  movq %r13, " SCR_STR(SCR_UC_GREG(REG_R13)) "(%rdi)\n"
+    "  movq %r14, " SCR_STR(SCR_UC_GREG(REG_R14)) "(%rdi)\n"
+    "  movq %r15, " SCR_STR(SCR_UC_GREG(REG_R15)) "(%rdi)\n"
+    "  movq %rdi, " SCR_STR(SCR_UC_GREG(REG_RDI)) "(%rdi)\n"
+    "  movq %rsi, " SCR_STR(SCR_UC_GREG(REG_RSI)) "(%rdi)\n"
+    "  movq %rbp, " SCR_STR(SCR_UC_GREG(REG_RBP)) "(%rdi)\n"
+    "  movq %rbx, " SCR_STR(SCR_UC_GREG(REG_RBX)) "(%rdi)\n"
+    "  movq %rdx, " SCR_STR(SCR_UC_GREG(REG_RDX)) "(%rdi)\n"
+    "  movq %rax, " SCR_STR(SCR_UC_GREG(REG_RAX)) "(%rdi)\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RCX)) "(%rdi)\n"
+    "  movq (%rsp), %rcx\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RIP)) "(%rdi)\n"
+    "  leaq 8(%rsp), %rcx\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RSP)) "(%rdi)\n"
+    "  leaq 424(%rdi), %rcx\n"
+    "  movq %rcx, 224(%rdi)\n"
+    "  fnstenv (%rcx)\n"
+    "  fldenv (%rcx)\n"
+    "  stmxcsr 448(%rdi)\n"
+    "  xorl %eax, %eax\n"
+    "  ret\n"
+
+    ".global setcontext\n"
+    "setcontext:\n"
+    "  movq 224(%rdi), %rcx\n"
+    "  fldenv (%rcx)\n"
+    "  ldmxcsr 448(%rdi)\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R8))  "(%rdi), %r8\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R9))  "(%rdi), %r9\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R10)) "(%rdi), %r10\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R11)) "(%rdi), %r11\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R12)) "(%rdi), %r12\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R13)) "(%rdi), %r13\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R14)) "(%rdi), %r14\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R15)) "(%rdi), %r15\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RSI)) "(%rdi), %rsi\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RBP)) "(%rdi), %rbp\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RBX)) "(%rdi), %rbx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RDX)) "(%rdi), %rdx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RAX)) "(%rdi), %rax\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RCX)) "(%rdi), %rcx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RSP)) "(%rdi), %rsp\n"
+    "  pushq " SCR_STR(SCR_UC_GREG(REG_RIP)) "(%rdi)\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RDI)) "(%rdi), %rdi\n"
+    "  xorl %eax, %eax\n"
+    "  ret\n"
+
+    ".global swapcontext\n"
+    "swapcontext:\n"
+    "  movq %r8, "  SCR_STR(SCR_UC_GREG(REG_R8))  "(%rdi)\n"
+    "  movq %r9, "  SCR_STR(SCR_UC_GREG(REG_R9))  "(%rdi)\n"
+    "  movq %r10, " SCR_STR(SCR_UC_GREG(REG_R10)) "(%rdi)\n"
+    "  movq %r11, " SCR_STR(SCR_UC_GREG(REG_R11)) "(%rdi)\n"
+    "  movq %r12, " SCR_STR(SCR_UC_GREG(REG_R12)) "(%rdi)\n"
+    "  movq %r13, " SCR_STR(SCR_UC_GREG(REG_R13)) "(%rdi)\n"
+    "  movq %r14, " SCR_STR(SCR_UC_GREG(REG_R14)) "(%rdi)\n"
+    "  movq %r15, " SCR_STR(SCR_UC_GREG(REG_R15)) "(%rdi)\n"
+    "  movq %rdi, " SCR_STR(SCR_UC_GREG(REG_RDI)) "(%rdi)\n"
+    "  movq %rsi, " SCR_STR(SCR_UC_GREG(REG_RSI)) "(%rdi)\n"
+    "  movq %rbp, " SCR_STR(SCR_UC_GREG(REG_RBP)) "(%rdi)\n"
+    "  movq %rbx, " SCR_STR(SCR_UC_GREG(REG_RBX)) "(%rdi)\n"
+    "  movq %rdx, " SCR_STR(SCR_UC_GREG(REG_RDX)) "(%rdi)\n"
+    "  movq %rax, " SCR_STR(SCR_UC_GREG(REG_RAX)) "(%rdi)\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RCX)) "(%rdi)\n"
+    "  movq (%rsp), %rcx\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RIP)) "(%rdi)\n"
+    "  leaq 8(%rsp), %rcx\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RSP)) "(%rdi)\n"
+    "  leaq 424(%rdi), %rcx\n"
+    "  movq %rcx, 224(%rdi)\n"
+    "  fnstenv (%rcx)\n"
+    "  fldenv (%rcx)\n"
+    "  stmxcsr 448(%rdi)\n"
+    "  movq 224(%rsi), %rcx\n"
+    "  fldenv (%rcx)\n"
+    "  ldmxcsr 448(%rsi)\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R8))  "(%rsi), %r8\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R9))  "(%rsi), %r9\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R10)) "(%rsi), %r10\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R11)) "(%rsi), %r11\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R12)) "(%rsi), %r12\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R13)) "(%rsi), %r13\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R14)) "(%rsi), %r14\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R15)) "(%rsi), %r15\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RDI)) "(%rsi), %rdi\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RBP)) "(%rsi), %rbp\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RBX)) "(%rsi), %rbx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RDX)) "(%rsi), %rdx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RAX)) "(%rsi), %rax\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RCX)) "(%rsi), %rcx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RSP)) "(%rsi), %rsp\n"
+    "  pushq " SCR_STR(SCR_UC_GREG(REG_RIP)) "(%rsi)\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RSI)) "(%rsi), %rsi\n"
+    "  xorl %eax, %eax\n"
+    "  ret\n"
+
+    ".hidden scr_musl_context_trampoline\n"
+    "scr_musl_context_trampoline:\n"
+    "  movq (%rbx), %rdi\n"
+    "  testq %rdi, %rdi\n"
+    "  je 1f\n"
+    "  call setcontext\n"
+    "  ud2\n"
+    "1:\n"
+    "  xorl %edi, %edi\n"
+    "  call exit\n"
+    "  ud2\n");
+
+extern void scr_musl_context_trampoline(void);
+
+void makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...) {
+  greg_t *sp;
+  va_list va;
+  int i;
+  unsigned int link_slot = (unsigned int)(argc > 6 ? argc - 6 : 0) + 1;
+
+  sp = (greg_t *)((uintptr_t)ucp->uc_stack.ss_sp + ucp->uc_stack.ss_size);
+  sp -= link_slot;
+  sp = (greg_t *)(((uintptr_t)sp & ~(uintptr_t)15) - 8);
+
+  ucp->uc_mcontext.fpregs = (void *)&ucp->__fpregs_mem;
+  ucp->uc_mcontext.gregs[REG_RIP] = (greg_t)(uintptr_t)func;
+  ucp->uc_mcontext.gregs[REG_RBX] = (greg_t)(uintptr_t)&sp[link_slot];
+  ucp->uc_mcontext.gregs[REG_RSP] = (greg_t)(uintptr_t)sp;
+
+  sp[0] = (greg_t)(uintptr_t)&scr_musl_context_trampoline;
+  sp[link_slot] = (greg_t)(uintptr_t)ucp->uc_link;
+
+  va_start(va, argc);
+  for (i = 0; i < argc; i++) {
+    greg_t arg = va_arg(va, greg_t);
+    switch (i) {
+      case 0: ucp->uc_mcontext.gregs[REG_RDI] = arg; break;
+      case 1: ucp->uc_mcontext.gregs[REG_RSI] = arg; break;
+      case 2: ucp->uc_mcontext.gregs[REG_RDX] = arg; break;
+      case 3: ucp->uc_mcontext.gregs[REG_RCX] = arg; break;
+      case 4: ucp->uc_mcontext.gregs[REG_R8] = arg; break;
+      case 5: ucp->uc_mcontext.gregs[REG_R9] = arg; break;
+      default: sp[i - 5] = arg; break;
+    }
+  }
+  va_end(va);
+}
+
+#undef SCR_UC_GREG
+#undef SCR_STR
+#undef SCR_STR_INNER
+
+#endif /* !SCR_LIB */
+
+#else /* !SCR_MUSL */
+
+typedef int scr_musl_unused;
+
+#endif /* SCR_MUSL */