@amritk/nish 0.11.0 → 0.13.0

package/runtime/{runtime_parallel.c → runtime-parallel.c}

@@ -1,9 +1,9 @@
 /* Nish runtime, the parallel half: how one range of work becomes several
  * threads, and nothing else.
  *
- * A third translation unit rather than a third of `runtime_os.c`, for the
+ * A third translation unit rather than a third of `runtime-os.c`, for the
  * reason that file's header gives for being a second one: a budget should mean
- * one thing. `runtime_os.c` is the syscall wrappers and it had 29 bytes of its
+ * one thing. `runtime-os.c` is the syscall wrappers and it had 29 bytes of its
  * ceiling left; `pthread_create` plus a partitioner does not fit in 29 bytes,
  * and raising the syscall half's ceiling to make room would move the number a
  * reader sees for "the operating-system surface" for a reason that has nothing
@@ -21,11 +21,16 @@
  * function exists. The thread-local arena the divided case needs is WP20 T0 and
  * arrives with the same macro.
  *
- * There is no language surface here and nothing in the language calls this yet:
- * docs/wp29-thread-surface.md is the surface, and this is the stage under it.
+ * docs/wp29-thread-surface.md is the surface this is the stage under: P1's
+ * `parallelMapInto` and `parallelReduce` divide a range here, and P2's scopes
+ * run their tasks here (`nish_scope_spawn`, `nish_scope_join`).
  */
 #include "nish.h"
 
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
 #if defined(NISH_THREADS) && !defined(__wasi__) && !defined(__wasm__)
 #define NISH_PAR_REAL 1
 #include <pthread.h>
@@ -154,3 +159,106 @@ void nish_parallel_range(nish_par_body body, void *ctx, int64_t len, int64_t gra
   body(0, len, ctx);
 #endif
 }
+
+/* ---- A scope's tasks (wp29 P2) ----
+ *
+ * A task is filed when it is spawned and run when its scope joins, which is
+ * what keeps a scope race-free without a borrow checker: while the tasks run,
+ * the thread that opened the scope is inside the join and runs nothing else,
+ * the tasks write nothing but their own payloads (the language's rule), and
+ * every store into the caller's memory is a `finish` made on the caller's
+ * thread after the last task has finished.
+ *
+ * The filed tasks are one list per thread, newest first, and each carries the
+ * scope it belongs to. Only the thread that opened a scope files into it or
+ * joins it, so the list needs no lock, and scopes may nest: a join takes its
+ * own scope's tasks out of the list and leaves the rest. */
+typedef struct nish_task {
+  struct nish_task *next;
+  void *scope;
+  nish_task_fn run;
+  nish_task_fn finish;
+#ifdef NISH_PAR_REAL
+  pthread_t th;
+  int started;
+#endif
+  /* The copied payload, aligned for any field it holds. */
+  uint64_t payload[];
+} nish_task;
+
+static NISH_TLS nish_task *nish_tasks = 0;
+
+void nish_scope_spawn(void *scope, nish_task_fn run, nish_task_fn finish, const void *payload, int64_t size) {
+  nish_task *t = (nish_task *)malloc(sizeof(nish_task) + (size_t)size);
+  /* Out of memory is the end of the program, as it is for every other
+   * allocation the runtime makes: running the task here instead would store
+   * its answer ahead of tasks filed before it, and a later spawn into the same
+   * slot has to be the one that stays. */
+  if (!t) {
+    (void)!write(2, "nish: out of memory\n", 20);
+    _exit(1);
+  }
+  t->scope = scope;
+  t->run = run;
+  t->finish = finish;
+  memcpy(t->payload, payload, (size_t)size);
+  t->next = nish_tasks;
+  nish_tasks = t;
+}
+
+#ifdef NISH_PAR_REAL
+static void *nish_task_worker(void *p) {
+  nish_task *t = (nish_task *)p;
+  /* A task is one thread's work, as a chunk is, so a region inside it runs on
+   * this thread rather than multiplying the threads. */
+  nish_par_depth = 1;
+  t->run(t->payload);
+  nish_free_arena(); /* as `nish_par_worker`: this thread's arena, and only it */
+  return 0;
+}
+#endif
+
+void nish_scope_join(void *scope) {
+  /* This scope's tasks, oldest first: the list is newest first, and moving each
+   * one to the front of `mine` reverses it. */
+  nish_task *mine = 0;
+  nish_task **link = &nish_tasks;
+  while (*link) {
+    nish_task *t = *link;
+    if (t->scope == scope) {
+      *link = t->next;
+      t->next = mine;
+      mine = t;
+    } else {
+      link = &t->next;
+    }
+  }
+  if (!mine) return;
+#ifdef NISH_PAR_REAL
+  /* Every task but the first on a thread of its own, and the first on this
+   * one, so N tasks cost N-1 spawns and this thread is not idle. A task inside
+   * a region or another task's thread runs here, as a nested region does. */
+  for (nish_task *t = mine->next; t; t = t->next) {
+    t->started = nish_par_depth == 0 && pthread_create(&t->th, 0, nish_task_worker, t) == 0;
+  }
+  nish_par_depth++;
+  mine->run(mine->payload);
+  for (nish_task *t = mine->next; t; t = t->next) {
+    if (!t->started) t->run(t->payload);
+  }
+  nish_par_depth--;
+  for (nish_task *t = mine->next; t; t = t->next) {
+    if (t->started) pthread_join(t->th, 0);
+  }
+#else
+  for (nish_task *t = mine; t; t = t->next) t->run(t->payload);
+#endif
+  /* The stores, in the order the tasks were spawned, so two tasks with one
+   * destination leave the later one's answer there, as they would in sequence. */
+  while (mine) {
+    nish_task *t = mine;
+    mine = t->next;
+    t->finish(t->payload);
+    free(t);
+  }
+}

package/runtime/{runtime_wasm.c → runtime-wasm.c}

@@ -1,7 +1,7 @@
 /* Nish runtime for the freestanding wasm profile (WP8): the arena and the
  * array cold paths, without libc. Link it next to the module when a function
  * takes or returns an array:
- *   scripts/build.sh x.ll runtime/runtime_wasm.c -o x.wasm --profile wasm
+ *   scripts/build.sh x.ll runtime/runtime-wasm.c -o x.wasm --profile wasm
  *
  * Linear memory past `__heap_base` (the linker's end-of-data symbol) is one
  * arena chunk that grows with `memory.grow`; there is no chunk list because
@@ -97,3 +97,8 @@ void nish_panic_index(uint64_t idx, uint64_t len) { (void)idx; (void)len; __buil
 void nish_panic_slice(int64_t s, int64_t e, int64_t len) { (void)s; (void)e; (void)len; __builtin_trap(); }
 void nish_panic_div(_Bool by_zero) { (void)by_zero; __builtin_trap(); }
 void nish_exit(int32_t code) { (void)code; __builtin_trap(); }
+/* A panic's message (`panic`, `expect`, a failed range entry) has no stderr to
+ * go to here; the `nish_exit` that follows it is the trap. An exported function
+ * with a ranged parameter checks it on entry (WP31 §9), so this is what lets
+ * such a module link; the loader throws a RangeError before the call reaches it. */
+void nish_write(const void *s, int32_t fd, _Bool newline) { (void)s; (void)fd; (void)newline; }

package/runtime/runtime.c

@@ -4,13 +4,13 @@
  * it is also the half with the tighter size budget: the arena, strings, number
  * formatting, the array cold paths, `process.argv`, `Math.random`, and the two
  * panics. Files, directories, subprocesses, the environment and the clock are
- * in runtime_os.c — every one of those wraps a system call, so that surface
+ * in runtime-os.c — every one of those wraps a system call, so that surface
  * grows as the language reaches further into the operating system, and a
  * program that reaches nowhere should not pay for it or be measured with it.
- * runtime_os.c's header comment has the reasoning; tests/run.js gates the two
+ * runtime-os.c's header comment has the reasoning; tests/run.js gates the two
  * `.text*` budgets separately and docs/wp7-runtime.md records both.
  *
- * Nothing here calls into runtime_os.c, which is why an old link line that
+ * Nothing here calls into runtime-os.c, which is why an old link line that
  * names runtime.c alone still builds a program that uses none of that surface.
  * The other direction does happen: `nish_readdir` allocates through
  * `nish_alloc_struct` and `nish_str_new`, so those calls no longer inline into
@@ -50,7 +50,7 @@ int __main_argc_argv(int argc, char **argv) { return nish_c_main(argc, argv); }
    definition. Off by default so the ordinary build pays nothing.
 
    The same definition is in runtime/nish.h (for a host that includes it) and
-   runtime/runtime_wasm.c; they are one contract and move together. */
+   runtime/runtime-wasm.c; they are one contract and move together. */
 #ifdef NISH_THREADS
 #define NISH_TLS _Thread_local
 #else
@@ -59,7 +59,7 @@ int __main_argc_argv(int argc, char **argv) { return nish_c_main(argc, argv); }
 
 /* ---- Arena: %struct.nish_arena = type { i8*, i64, i64, i8* }
 
-   The widths are fixed rather than `size_t` for the reason runtime_wasm.c
+   The widths are fixed rather than `size_t` for the reason runtime-wasm.c
    gives for its own copy: every compiled function inlines the bump allocator
    and reads these fields directly, so the IR's `i64` is what `off` and `cap`
    have to be on every target, not just the 64-bit ones. With `size_t` they

package/runtime/shim.mjs

@@ -4,7 +4,7 @@
  * The differential runner (tests/differential/run.js) rewrites an Nish
  * program into plain JavaScript and runs it under Node with this module as
  * `__nish`. Every helper here reproduces the *runtime* semantics the compiled
- * binary has (runtime/runtime.c and runtime/runtime_os.c, the system-call half,
+ * binary has (runtime/runtime.c and runtime/runtime-os.c, the system-call half,
  * plus the intrinsics in docs/wp7-runtime.md) where JavaScript's own semantics
  * differ:
  *
@@ -486,10 +486,10 @@ export function isDirectorySync(path) {
  * the directory cannot be read. Node throws where the runtime answers a value,
  * so the `catch` is what makes the two agree, and a directory that exists and
  * is empty answers an empty array on both sides. Node's readdir never yields
- * `.` or `..` — the pair `runtime_os.c` skips explicitly — so there is nothing
+ * `.` or `..` — the pair `runtime-os.c` skips explicitly — so there is nothing
  * to filter out here.
  *
- * The sort is the semantic point. `runtime_os.c` orders the names with
+ * The sort is the semantic point. `runtime-os.c` orders the names with
  * `strcmp`, which compares UTF-8 bytes, and `Array#sort` compares UTF-16 code
  * units. The two agree on ASCII names and part company above the BMP, where a
  * surrogate pair sorts below `U+E000`..`U+FFFF` in UTF-16 and above them in
@@ -526,7 +526,7 @@ export function realpathSync(path) {
 
 /**
  * `process.platform` / `process.arch` (WP14 §7a). Node's spellings are the
- * ones `runtime_os.c` answers with, so on any machine this compiler has a
+ * ones `runtime-os.c` answers with, so on any machine this compiler has a
  * triple for the two runtimes give the same string; elsewhere the native build
  * says `unknown` where Node names the platform, which is the one place they
  * part.
@@ -553,7 +553,7 @@ export function getenv(name) {
  * `spawnSync(argv)` and `spawnSyncTo(argv, out, err)` (WP14 D4), which are one
  * run with its streams answered differently: the child's exit status, 128 + n
  * when signal n killed it, -1 for an empty vector or a program that would not
- * start. `runtime_os.c` puts one `static nish_spawn_impl` behind both builtins
+ * start. `runtime-os.c` puts one `static nish_spawn_impl` behind both builtins
  * for the same reason this module puts one function behind both helpers — the
  * argument vector, the wait and the signal convention are written once and
  * cannot drift between the two.
@@ -606,7 +606,7 @@ export function spawnSyncTo(argv, out, err) {
 /**
  * `monotonicNanos()`: `process.hrtime.bigint()`, a monotonic clock in
  * nanoseconds (`CLOCK_MONOTONIC` on every platform that has it, which is the
- * one `runtime_os.c` reads). The value is a BigInt because that is how an `i64`
+ * one `runtime-os.c` reads). The value is a BigInt because that is how an `i64`
  * is held on this side.
  *
  * No rewrite can make a *reading* agree with a native run: both origins are

package/scripts/bootstrap.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Build the self-hosted compiler: `self/`, compiled by `self/`.
+# Build the self-hosted compiler: `src/`, compiled by `src/`.
 #
 #   scripts/bootstrap.sh [-o <exe>] [--stages 1|2|3] [--profile speed|size|debug]
 #                        [--work <dir>] [--verify] [--quiet]
@@ -8,9 +8,9 @@
 # parameter rather than a fixture (docs/wp19-stage0-retirement.md §3, G3):
 #
 #   seed     whatever compiles stage1              NISH_BOOTSTRAP, or build/seed
-#   stage1   self/, built by the seed
-#   stage2   self/, built by stage1                the default output
-#   stage3   self/, built by stage2                --verify only
+#   stage1   src/, built by the seed
+#   stage2   src/, built by stage1                the default output
+#   stage3   src/, built by stage2                --verify only
 #
 # NISH_BOOTSTRAP=<path> names the seed, the way GOROOT_BOOTSTRAP names the Go
 # that builds Go. It is either a released `nish`, executed directly, or a Node
@@ -31,14 +31,14 @@
 #
 # --verify runs the equalities the proof is made of, byte for byte:
 #
-#   IR(seed, self/)   == IR(stage1, self/)     reported, never asserted
-#   IR(stage1, self/) == IR(stage2, self/)     the fixed point: self-hosted
+#   IR(seed, src/)   == IR(stage1, src/)     reported, never asserted
+#   IR(stage1, src/) == IR(stage2, src/)     the fixed point: self-hosted
 #   stage3 == stage2                           as files, on ELF and on Mach-O
 #                                              alike; see below for what the
 #                                              Mach-O half took
 #
 # The last two are properties of the working tree and of nothing else: whatever
-# built stage1, the compiler `self/` describes has to agree with itself and
+# built stage1, the compiler `src/` describes has to agree with itself and
 # then reproduce itself. Both are asserted whatever the seed is.
 #
 # The third is a raw byte comparison, and on Mach-O two links of the same input
@@ -59,22 +59,22 @@
 # measurement, byte offsets and all.
 #
 # The first one is reported and not asserted. With a released seed it is one
-# implementation at two points in time: the IR HEAD emits for `self/` is the
+# implementation at two points in time: the IR HEAD emits for `src/` is the
 # IR the last release emitted for it. Nothing in that sentence is about
 # bootstrapping. It is a freeze on codegen between releases, and it fails on
 # exactly the changes a release cycle exists to carry: the first improvement to
-# land broke it, when a flow-sensitive bounds analysis proved 46 of `self/`'s
+# land broke it, when a flow-sensitive bounds analysis proved 46 of `src/`'s
 # 1,206 index checks redundant and 20 of 56 modules "differed" because the
 # optimisation worked. So the difference is reported, and the report is
 # information about this release rather than a verdict on the bootstrap.
 #
-# While `src/` existed, a stage0 seed made the same comparison the second half
+# While stage0's `src/` existed, a stage0 seed made the same comparison the second half
 # of Wheeler's diverse double-compiling, and it was asserted there
-# (docs/wp19-stage0-retirement.md §1, G6). That claim went with `src/`.
+# (docs/wp19-stage0-retirement.md §1, G6). That claim went with stage0's `src/`.
 #
 # What the seeded run buys is not that equality. The rolling freeze — "a
-# construct added in 0.N cannot be used by `self/` until 0.(N+1)" — is enforced
-# by stage1 being built at all: a `self/` that reaches for something the seed
+# construct added in 0.N cannot be used by `src/` until 0.(N+1)" — is enforced
+# by stage1 being built at all: a `src/` that reaches for something the seed
 # has never heard of does not compile, does not link, and never gets as far as
 # a comparison. That failure is loud here whatever the seed is, and it is the
 # whole of what the seeded run proves about the freeze
@@ -115,7 +115,7 @@ usage: scripts/bootstrap.sh [-o <exe>] [--stages 1|2|3] [--profile speed|size|de
 
 Builds the self-hosted compiler. The seed builds stage1, stage1 builds stage2
 (the default output), stage2 builds stage3. --verify compares the IR each stage
-emits for self/ and the stage2/stage3 binaries, byte for byte. The result is
+emits for src/ and the stage2/stage3 binaries, byte for byte. The result is
 the command line itself: -o, --link, --profile and the rest.
 
 IR(seed) == IR(stage1) asks whether codegen has changed since the seed was
@@ -156,10 +156,10 @@ build_to=$stages
 [ "$verify" -eq 1 ] && build_to=3
 
 # The published npm package ships bin/, runtime/, scripts/ and std/ but not
-# self/ -- and, since 0.6.0, no compiler of its own at all -- so say which file
+# src/ -- and, since 0.6.0, no compiler of its own at all -- so say which file
 # is missing rather than failing inside the compiler.
-if [ ! -f self/compile.ts ]; then
-  echo "bootstrap: self/compile.ts is missing; run this from a checkout of the repository" >&2
+if [ ! -f src/compile.ts ]; then
+  echo "bootstrap: src/compile.ts is missing; run this from a checkout of the repository" >&2
   exit 3
 fi
 
@@ -211,7 +211,7 @@ else
   [ -r "$seed" ] || seed_die "is not readable"
   command -v node >/dev/null 2>&1 || seed_die "needs node on PATH, which is not there"
 fi
-# A seed that cannot answer `--version` cannot compile self/ either — a
+# A seed that cannot answer `--version` cannot compile src/ either — a
 # binary built for another platform, a .js that is not a compiler — and
 # finding that out here names the variable and the path the caller set, where
 # finding it out in the stage1 link names a temporary file three stages deep.
@@ -223,7 +223,7 @@ fi
 
 say() { [ "$quiet" -eq 1 ] || printf '%s\n' "$*"; }
 
-# `a` and `b` hold one `.ll` per module of `self/`. Both the module set and
+# `a` and `b` hold one `.ll` per module of `src/`. Both the module set and
 # every byte of every module must match: a stage that emitted one module fewer
 # has not agreed about the rest.
 compare_ir() {
@@ -260,11 +260,11 @@ survey_ir() {
   done
   if [ "$differing" -eq 0 ]; then
     say "  note: IR(seed) vs IR(stage1): all $total modules identical."
-    say "        Not asserted: codegen simply has not moved for self/ since"
+    say "        Not asserted: codegen simply has not moved for src/ since"
     say "        the seed was built."
   else
     say "  note: IR(seed) vs IR(stage1): $differing of $total modules differ."
-    say "        Not a bootstrap failure. Codegen has moved for self/ since the"
+    say "        Not a bootstrap failure. Codegen has moved for src/ since the"
     say "        seed was built, which is what a release carries. See the header"
     say "        of this script and docs/wp19-stage0-retirement.md §3, G3."
   fi
@@ -295,8 +295,8 @@ survey_ir() {
 link_stage() {
   local by="$1" name="$2"
   rm -rf "$work/stage" "$work/stage.modules"
-  "$by" self/compile.ts --link "$work/stage" --profile "$profile" >/dev/null
-  rm -rf "$work/$name" "$work/$name.modules"
+  "$by" src/compile.ts --link "$work/stage" --profile "$profile" >/dev/null
+  rm -rf "${work:?}/${name:?}" "${work:?}/${name:?}.modules"
   mv "$work/stage" "$work/$name"
   mv "$work/stage.modules" "$work/$name.modules"
 }
@@ -310,28 +310,28 @@ outdir=$(dirname "$out")
 # `scripts/build.sh` itself (docs/wp14-selfhost.md §7a). That leaves each
 # stage's IR in `<exe>.modules/`, which is where the equalities read it, and
 # means the chain exercises the same driver a user does.
-say "stage1: self/ compiled by $seed_label"
+say "stage1: src/ compiled by $seed_label"
 rm -rf "$work/stage1.modules"
 # This is the step the rolling freeze is enforced by, so it says so when it
 # fails rather than leaving a reader with the compiler's own diagnostic and no
 # idea which rule it just met.
-if ! run_seed self/compile.ts --link "$work/stage1" --profile "$profile" >/dev/null; then
-  echo "bootstrap: $seed_label could not build stage1 from self/ (its output is above)" >&2
+if ! run_seed src/compile.ts --link "$work/stage1" --profile "$profile" >/dev/null; then
+  echo "bootstrap: $seed_label could not build stage1 from src/ (its output is above)" >&2
   echo "bootstrap: if it refused the source, that is the freeze doing its job: a construct" >&2
-  echo "bootstrap: added in 0.N cannot be used by self/ until 0.(N+1) (docs/wp12-release.md," >&2
+  echo "bootstrap: added in 0.N cannot be used by src/ until 0.(N+1) (docs/wp12-release.md," >&2
   echo "bootstrap: \"The bootstrap seed\"; docs/wp19-stage0-retirement.md §3, G3)" >&2
   exit 1
 fi
 
 if [ "$build_to" -ge 2 ]; then
-  say "stage2: self/ compiled by stage1"
+  say "stage2: src/ compiled by stage1"
   link_stage "$work/stage1" stage2
   # The seed equality, reported and not asserted.
   [ "$verify" -eq 1 ] && survey_ir "$work/stage1.modules" "$work/stage2.modules"
 fi
 
 if [ "$build_to" -ge 3 ]; then
-  say "stage3: self/ compiled by stage2"
+  say "stage3: src/ compiled by stage2"
   link_stage "$work/stage2" stage3
   [ "$verify" -eq 1 ] && compare_ir "$work/stage2.modules" "$work/stage3.modules" "IR(stage1) == IR(stage2)"
   # `stage3 == stage2`, in scripts/verify-binaries.sh: byte-identical, which

package/scripts/build.sh

@@ -4,9 +4,9 @@
 #   scripts/build.sh <module.ll> [more .ll/.c files...] -o <out> [--profile debug|speed|size|wasm]
 #
 # The C runtime is three translation units and is named as one: an input
-# <dir>/runtime.c also compiles <dir>/runtime_os.c, the half that wraps the
+# <dir>/runtime.c also compiles <dir>/runtime-os.c, the half that wraps the
 # system calls (files, directories, subprocesses, the environment, the clock),
-# and <dir>/runtime_parallel.c, the half that divides a range of work across
+# and <dir>/runtime-parallel.c, the half that divides a range of work across
 # threads. Each of those files says why they are compiled and measured apart.
 #
 # Profiles:
@@ -15,7 +15,7 @@
 #   size   -Oz + LTO + section GC + strip + no unwind tables. Rust
 #          `opt-level="z"`, `panic="abort"`, `strip=true` equivalent.
 #   wasm   wasm32 freestanding module exporting every non-internal function;
-#          load it from Node. Add runtime/runtime_wasm.c to the inputs when a
+#          load it from Node. Add runtime/runtime-wasm.c to the inputs when a
 #          function uses arrays (the arena and the array cold paths, no libc);
 #          strings and I/O still need a WASI runtime and are not available.
 #   wasm   wasm32 freestanding module exporting every non-internal function
@@ -84,12 +84,12 @@ done
 [ -n "$out" ] || { echo "error: -o <out> is required" >&2; exit 2; }
 
 # The runtime is three translation units, and a caller names one: whoever passes
-# <dir>/runtime.c gets <dir>/runtime_os.c and <dir>/runtime_parallel.c compiled
+# <dir>/runtime.c gets <dir>/runtime-os.c and <dir>/runtime-parallel.c compiled
 # beside it. They were one file until the operating-system half was split out
 # for its own size budget, and the parallel half followed for the same reason
 # (each file's header comment says why), and a link line is where those splits
 # would otherwise leak: `nish --link` builds its command line in
-# self/compile.ts, the published package's recipe in every document and
+# src/compile.ts, the published package's recipe in every document and
 # README names runtime.c, and a user's own clang line does too. Pairing them
 # here keeps every one of those correct, and keeps "the runtime" one thing to
 # name from the outside. A caller that names one itself is left alone, because
@@ -97,7 +97,7 @@ done
 for i in ${inputs[@]+"${inputs[@]}"}; do
   case "$i" in
     */runtime.c|runtime.c)
-      for half in runtime_os.c runtime_parallel.c; do
+      for half in runtime-os.c runtime-parallel.c; do
         side="${i%runtime.c}$half"
         have=0
         for j in "${inputs[@]}"; do
@@ -133,8 +133,12 @@ case "$(uname -s)" in
     # of one input to one output path, and differing on a link to another. That
     # is what scripts/bootstrap.sh links every comparable stage at one path for,
     # and it is why `stage3 == stage2` holds on Mach-O with the load command in.
-    gc=(-Wl,-dead_strip); strip_flag=(-Wl,-x) ;;
+    # shellcheck disable=SC2054 # -Wl,<flag> is one argument: the comma is the linker's
+    gc=(-Wl,-dead_strip)
+    # shellcheck disable=SC2054
+    strip_flag=(-Wl,-x) ;;
   *)
+    # shellcheck disable=SC2054 # -Wl,<flag> is one argument: the comma is the linker's
     gc=(-Wl,--gc-sections -Wl,--as-needed -Wl,-O2 -Wl,--build-id=none); strip_flag=(-s)
     elf=(-fno-plt)
     # GNU ld needs the gold plugin for LTO; prefer lld when clang can find it.
@@ -158,7 +162,7 @@ if [ "$debug" = 1 ]; then common+=(-g); strip_flag=(); fi
 # own command line instead of using `common`; it is empty on every ordinary
 # build, hence the bash 3.2 expansion spelling explained below.
 #
-# -pthread is for runtime_parallel.c, the translation unit that divides a range
+# -pthread is for runtime-parallel.c, the translation unit that divides a range
 # of work across threads: it is compiled in either configuration and only spawns
 # under this macro, so this is the build where the flag has to be on the command
 # line. On a current glibc the library half is already inside libc and the link
@@ -167,7 +171,7 @@ if [ "$debug" = 1 ]; then common+=(-g); strip_flag=(); fi
 #
 # It is deliberately in `common` and not in `tls`: `tls` is the wasm and wasi
 # command lines, which have no threads to link against, and where
-# runtime_parallel.c compiles to its sequential fallback because it tests
+# runtime-parallel.c compiles to its sequential fallback because it tests
 # __wasi__ and __wasm__ as well as the macro.
 tls=()
 if [ "$threads" = 1 ]; then
@@ -265,6 +269,7 @@ case "$profile" in
     shared=(-shared -fPIC)
     # macOS: the napi_* symbols come from the node binary at load time, so the
     # linker must not insist on resolving them. ELF shared objects allow this.
+    # shellcheck disable=SC2054 # -Wl,<flag> is one argument: the comma is the linker's
     case "$(uname -s)" in Darwin) shared+=(-Wl,-undefined,dynamic_lookup) ;; esac
     # runtime/nish.h is the public ABI header the generated shim includes.
     runtime_inc="$(cd "$(dirname "$0")/../runtime" && pwd)"