@sproutboat/toolchain 0.12.0 → 0.12.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @sproutboat/toolchain
 
+## 0.12.1
+
+### Patch Changes
+
+- 1ff15e6: Keep heap-backed BigInts alive during conservative garbage collection. The native scanner now recognizes the encoded floating-point pointer used by BigInt arithmetic, preventing crashes and incorrect checksums in workloads such as CRC64 and LTX encoding.
+
 ## 0.12.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/toolchain",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/acquire.test.ts

@@ -18,6 +18,11 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
   const files = {
     "runtime/index.js": "fixture:runtime/index.js\n",
     "compiler/render.js": "// sb_native_utf8_scalar_v1\n" +
+      "static void porf_gc_cons_candidate(u32 c);\n" +
+      // Both conservative scanners consume raw f64 values.
+      ("    if (d > 0.0 && d < 4294967296.0) {\n" +
+        "      const i64 iv = (i64)d;\n" +
+        "      if ((f64)iv == d) porf_gc_cons_candidate((u32)(u64)iv);\n    }\n").repeat(2) +
       "static i32 porf_gc_mark_queue_cap = 0;\n    porf_gc_discard_free_runs();\n" +
       "  porf_native_fetch_timer_start(id, (i32)delay_ms, timer->repeat ? (i32)delay_ms : 0);\n" +
       "void porf_native_fetch_collect_normal_from(void* stack_top) {\n" +

package/src/bigint-gc-native.test.ts

@@ -0,0 +1,30 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { ensurePorffor } from "./acquire";
+
+test("conservative roots retain encoded heap BigInts on the stack and in untyped blocks", async () => {
+  const workdir = await mkdtemp(resolve(tmpdir(), "sb-bigint-gc-"));
+  try {
+    const porffor = await ensurePorffor();
+    const source = resolve(import.meta.dir, "../test/gc-bigint.js.txt");
+    const binary = resolve(workdir, "bigint-gc");
+    const compile = Bun.spawn(
+      ["bun", resolve(porffor, "runtime/index.js"), "native", source, "-o", binary, "-O0", "-s"],
+      { stdout: "pipe", stderr: "pipe" },
+    );
+    const [code, stdout, stderr] = await Promise.all([
+      compile.exited,
+      new Response(compile.stdout).text(),
+      new Response(compile.stderr).text(),
+    ]);
+    expect(code, stderr + stdout).toBe(0);
+    const run = Bun.spawnSync([binary], { stdout: "pipe", stderr: "pipe", timeout: 10_000 });
+    expect(run.exitCode, Buffer.from(run.stderr).toString()).toBe(0);
+    const ansi = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+    expect(Buffer.from(run.stdout).toString().replace(ansi, "").trim()).toBe("3");
+  } finally {
+    await rm(workdir, { recursive: true, force: true });
+  }
+}, 120_000);

package/src/fingerprint.ts

@@ -21,7 +21,7 @@ export const PATCH_SOURCES = [
  * patch.ts as the module patch.ts is everywhere else. Kept current by fingerprint.test.ts
  * (UPDATE_FINGERPRINT=1 bun test packages/toolchain/src/fingerprint.test.ts).
  */
-export const RELEASED_FINGERPRINT = "7e12e7bba967";
+export const RELEASED_FINGERPRINT = "ee724d4de68f";
 
 /** The fingerprint of the sources in dir, or null where they are not on disk. */
 export function sourceFingerprint(dir: string): string | null {

package/src/patch.ts

@@ -1925,6 +1925,36 @@ export async function patchSplitGlobals(root: string): Promise<void> {
   await writeFile(file, src);
 }
 
+// The conservative scanner must recognize the encoded f64 form used by BigInt builtins.
+const BIGINT_GC_ANCHOR = "static void porf_gc_cons_candidate(u32 c);\n";
+const BIGINT_GC_HELPER = `static void porf_gc_cons_f64(f64 d) {
+  // Heap BigInts encode their offset above 2^51, including in f64 builtin arguments.
+  if (d >= 2251799813685248.0 && d < 2251804108652544.0) d -= 2251799813685248.0;
+  if (d > 0.0 && d < 4294967296.0) {
+    const u32 ptr = (u32)d;
+    if ((f64)ptr == d) porf_gc_cons_candidate(ptr);
+  }
+}
+`;
+const BIGINT_GC_SCAN = `    if (d > 0.0 && d < 4294967296.0) {
+      const i64 iv = (i64)d;
+      if ((f64)iv == d) porf_gc_cons_candidate((u32)(u64)iv);
+    }`;
+
+export async function patchBigIntRoots(root: string): Promise<void> {
+  const file = resolve(root, "compiler/render.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes(BIGINT_GC_HELPER) && src.split("    porf_gc_cons_f64(d);").length === 3) return;
+  if (src.split(BIGINT_GC_ANCHOR).length !== 2 || src.split(BIGINT_GC_SCAN).length !== 3)
+    throw new Error(`could not patch Porffor's BigInt GC roots: anchor not found in ${file}`);
+  await writeFile(
+    file,
+    src
+      .replace(BIGINT_GC_ANCHOR, BIGINT_GC_ANCHOR + BIGINT_GC_HELPER)
+      .replaceAll(BIGINT_GC_SCAN, "    porf_gc_cons_f64(d);"),
+  );
+}
+
 const FETCH_CLASSES_MARKER = "sproutboat: Fetch-spec Request and Response";
 /** Replaces Porffor's Request and Response (fetch-classes.ts); covers patchResponseDefaults. */
 export async function patchFetchClasses(root: string): Promise<void> {
@@ -2023,6 +2053,7 @@ export async function ensurePorfforPatched(root: string): Promise<void> {
   await patchClassSelfName(root);
   await patchUwebsockets(root);
   await patchRenderJs(root);
+  await patchBigIntRoots(root);
   await patchStreamingResponses(root);
   await patchQuietCollection(root);
   await patchAsyncWaker(root);

package/test/gc-bigint.js.txt

@@ -0,0 +1,44 @@
+// Native GC scanner regression: bit 0 is the stack root, bit 1 the untyped block.
+// Bit 2 is set if a value just outside the heap-BigInt encoding marks the allocation.
+function probe() {
+  let stackMarked = 0;
+  let blockMarked = 0;
+  let falseMarked = 0;
+  Porffor.c`
+    u32 bigint = porf_alloc(16, 4);
+    u32 holder = porf_alloc(32, 0);
+    for (i32 ci = 0; ci < PORF_GC_NCLASSES; ci++) porf_gc_publish_window(ci);
+    const u32 gran = porf_gc_gran(bigint);
+    volatile f64 encoded = 2251799813685248.0 + (f64)bigint;
+    volatile f64 outside[4] = {
+      2251799813685248.0 + (f64)bigint + 0.5,
+      2251804108652544.0 + (f64)bigint,
+      -(2251799813685248.0 + (f64)bigint),
+      2251799813685248.0
+    };
+    for (i32 i = 0; i < 4; i++) {
+      porf_gc_bit_clear(PORF_GC_B_MARK, gran);
+      f64 d = outside[i];
+      u64 bits;
+      memcpy(&bits, &d, 8);
+      // Only the f64 decoding is under test: skip values whose 32-bit halves alias the block.
+      if (porf_gc_gran((u32)bits) == gran || porf_gc_gran((u32)(bits >> 32)) == gran) continue;
+      porf_gc_cons_scan_range((const u64*)&outside[i], (const u64*)&outside[i] + 1);
+      if (porf_gc_bit(PORF_GC_B_MARK, gran) != 0u) falseMarked = 1;
+    }
+    porf_gc_bit_clear(PORF_GC_B_MARK, gran);
+    porf_gc_cons_scan_range((const u64*)&encoded, (const u64*)((const char*)&encoded + sizeof(encoded)));
+    stackMarked = porf_gc_bit(PORF_GC_B_MARK, gran) != 0u;
+    porf_gc_bit_clear(PORF_GC_B_MARK, gran);
+    *(u64*)(MEM + holder) = 0xffffffffffffffffull;
+    *(f64*)(MEM + holder + 8) = encoded;
+    porf_gc_bit_clear(PORF_GC_B_MARK, porf_gc_gran(holder));
+    porf_gc_kinds[porf_gc_gran(holder)] = 0;
+    porf_gc_cons_mark_block((i32)holder);
+    blockMarked = porf_gc_bit(PORF_GC_B_MARK, gran) != 0u;
+  `;
+  return stackMarked + blockMarked * 2 + falseMarked * 4;
+}
+const marked = probe();
+console.log(marked);
+if (marked !== 3) throw new Error("heap BigInt was not marked, or a value outside its encoding was");