@amritk/nish 0.12.0 → 0.14.0

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:
  *
@@ -42,6 +42,7 @@
  * The rewrite rules that call these helpers are listed in docs/wp13-differential.md.
  */
 import child_process from "node:child_process";
+import { webcrypto } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 
@@ -91,6 +92,37 @@ export function bitsToF64(b) {
   return BITS.getFloat64(0);
 }
 
+/**
+ * `ctSelect` / `ctEq` (WP34 N6). A `u32` is a `number` here and a `u64` a
+ * BigInt, so the operands' kind picks the width, and a mix of the two — which
+ * the native checker refuses, and which a `u64` written as a bare literal is
+ * under an unrewritten run — throws the `TypeError` BigInt arithmetic throws
+ * rather than comparing a number with a BigInt and answering zero. JavaScript's
+ * `&` reads a `number` as a signed 32-bit integer, so each answer is put back in
+ * range with `>>> 0` or `asUintN(64, ...)`. These branch: only the native
+ * lowering promises constant time.
+ */
+function ctWide(name, first, second, third) {
+  const wide = typeof first === "bigint";
+  if ((typeof second === "bigint") !== wide || (typeof third === "bigint") !== wide) {
+    throw new TypeError(`${name}: cannot mix a u64 (BigInt) with a u32 (number)`);
+  }
+  return wide;
+}
+
+const U64_ONES = (1n << 64n) - 1n;
+
+export function ctSelect(mask, a, b) {
+  if (ctWide("ctSelect", mask, a, b)) return wrapU64((a & mask) | (b & ~mask));
+  return ((a & mask) | (b & ~mask)) >>> 0;
+}
+
+export function ctEq(a, b) {
+  // `ctEq` has two operands, so the second one stands in for the third.
+  if (ctWide("ctEq", a, b, b)) return wrapU64(a ^ b) === 0n ? U64_ONES : 0n;
+  return (a ^ b) === 0 ? 0xffffffff : 0;
+}
+
 /** Wrap a BigInt to the i64 range: every i64 `+ - * /` and unary minus goes through here. */
 export function wrapI64(x) {
   return BigInt.asIntN(64, x);
@@ -401,6 +433,28 @@ export function updIdx(a, i, f) {
   return v;
 }
 
+/**
+ * `dst.set(src, offset)` (WP34 N2): `TypedArray.prototype.set`'s copy on the
+ * plain array a `u8[]` is here. The source is copied first, so a self-copy or
+ * an overlapping one reads what was there before, as `memmove` does natively;
+ * a range past the end fails with the native panic and its words, where a
+ * typed array would throw a `RangeError` for the same offsets.
+ */
+export function arraySet(dst, src, offset) {
+  // `ToIntegerOrInfinity`: NaN is 0, as `llvm.fptosi.sat` makes it natively.
+  // `Math.trunc` rather than `toIndex`, which converts a bigint: an `i64` or
+  // `u64` offset is a bigint here, and it throws the `TypeError` the typed
+  // array and `Array.prototype.fill` throw for one, instead of being rounded
+  // to the nearest double past 2^53 (docs/RUN_UNDER_NODE.md).
+  const at = offset === undefined ? 0 : Math.trunc(offset) || 0;
+  const end = at + src.length;
+  if (!(at >= 0 && end <= dst.length)) panicSlice(at, end, dst.length);
+  // Two plain arrays overlap only when they are one array, which is the one
+  // case that must read the source before writing it.
+  const from = src === dst ? src.slice() : src;
+  for (let i = 0; i < from.length; i++) dst[at + i] = from[i];
+}
+
 /** `new Array<T>(n)`: `n` zero-filled elements (`0`, `0n`, or `false`). */
 export function newArray(n, zero) {
   return new Array(toIndex(n)).fill(zero);
@@ -434,6 +488,15 @@ export function readFileSyncOrNull(path) {
   }
 }
 
+/** `readFileBytesSync(path)` (WP34 N2): the bytes as a plain array of numbers, or null. */
+export function readFileBytesSync(path) {
+  try {
+    return Array.from(fs.readFileSync(path));
+  } catch {
+    return null;
+  }
+}
+
 export function writeFileSync(path, data) {
   try {
     fs.writeFileSync(path, data, "utf8");
@@ -486,10 +549,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 +589,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 +616,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 +669,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
@@ -618,6 +681,65 @@ export function monotonicNanos() {
   return process.hrtime.bigint();
 }
 
+// ---- The host (WP34 N3) ------------------------------------------------------
+
+/**
+ * `statMtimeSync(path)`: Node's `mtimeMs` for the path, or NaN when it cannot
+ * be stat'd, which is the native answer too. `mtimeMs` is the same arithmetic
+ * `runtime-host.c` does, so the two print the same digits, fraction and all.
+ */
+export function statMtimeSync(path) {
+  const st = fs.statSync(path, { throwIfNoEntry: false });
+  if (st === undefined) {
+    return Number.NaN;
+  }
+  return st.mtimeMs;
+}
+
+/**
+ * Node's own fill, taken before `runtime/nish.mjs` puts the one below in its
+ * place on the same object: `webcrypto` is the global `crypto`.
+ */
+const webRandom = webcrypto.getRandomValues.bind(webcrypto);
+
+/**
+ * `crypto.getRandomValues(bytes)` for the plain array a `u8[]` is here. Node's
+ * own takes only a typed array, so the bytes are drawn into one and copied
+ * across. More than 65,536 fails with the native panic and its words, where
+ * Node would throw a `QuotaExceededError`: the exit status is 1 either way. A
+ * typed array goes straight through.
+ */
+export function getRandomValues(bytes) {
+  if (!Array.isArray(bytes)) {
+    return webRandom(bytes);
+  }
+  if (bytes.length > 65536) {
+    panic(`crypto.getRandomValues: ${bytes.length} bytes asked for, and one call fills at most 65536`);
+  }
+  const drawn = webRandom(new Uint8Array(bytes.length));
+  for (let i = 0; i < drawn.length; i++) {
+    bytes[i] = drawn[i];
+  }
+  return bytes;
+}
+
+/**
+ * `signalFd()` and `readSignal(fd)` have no faithful reading under Node, and
+ * these say so rather than answer something else. Node delivers a signal to
+ * its event loop (`process.on("SIGTERM")`), and a blocking read keeps the loop
+ * from ever running, so no synchronous function here can learn that one
+ * arrived. docs/wp33-round-trip.md §3.5 has the row and the translation.
+ */
+export function signalFd() {
+  throw new Error(
+    "signalFd has no synchronous reading under Node: a signal reaches the event loop, which a blocking readSignal never returns to (docs/wp33-round-trip.md)"
+  );
+}
+
+export function readSignal() {
+  return signalFd();
+}
+
 /** `process.argv`: index 0 is the program (the script here, the executable natively), then the arguments. */
 export function argv() {
   return process.argv.slice(1);

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

@@ -3,11 +3,12 @@
 #
 #   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
+# The C runtime is four translation units and is named as one: an input
+# <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
-# threads. Each of those files says why they are compiled and measured apart.
+# <dir>/runtime-parallel.c, the half that divides a range of work across
+# threads, and <dir>/runtime-host.c, the wall clock, entropy, file times and
+# signals. Each of those files says why they are compiled and measured apart.
 #
 # Profiles:
 #   debug  clang defaults: no optimisation, symbols kept. The "before" number.
@@ -15,7 +16,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
@@ -83,13 +84,13 @@ done
 [ ${#inputs[@]} -gt 0 ] || { echo "error: no input files" >&2; exit 2; }
 [ -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
-# beside it. They were one file until the operating-system half was split out
+# The runtime is four translation units, and a caller names one: whoever passes
+# <dir>/runtime.c gets <dir>/runtime-os.c, <dir>/runtime-parallel.c and
+# <dir>/runtime-host.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 +98,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 runtime-host.c; do
         side="${i%runtime.c}$half"
         have=0
         for j in "${inputs[@]}"; do
@@ -133,8 +134,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 +163,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 +172,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 +270,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)"