@scriptc/compiler 0.4.6 → 0.4.8

package/dist/backend/llvm/dyn.js

@@ -10,9 +10,11 @@ import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { llvmCommentText } from "./common.js";
+import { JS_BITS } from "./jsval-encoding.js";
 import { arrNewCall, elemAccess, llFieldType, mapFlagsOffset, releaseSym, traceAdapter, traceArg, vAdapters, } from "./shapes.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { recordMayKeepSource, recordSourceFieldOrder } from "./record-sources.js";
+import { emitLinkedRecordBranches } from "./walkers.js";
 /** typeKey with `?` after every `(T | undefined)[]` (optionalElements),
  * at any depth of arrays, Maps, Sets and promises: checked conversions to
  * `number[][]` and `(number | undefined)[][]` need separate helpers, though
@@ -41,6 +43,23 @@ export function recordDynKeepsIdentity(shape) {
     return ((shape.fields.length === 0 && !shape.indexValue) ||
         shape.fields.some((f) => f.name === "handleEvent" && f.type.kind === "func"));
 }
+/** Whether a promise's fulfillment payload crosses to a checked-dynamic
+ * value as a LIVE capsule of the same record or array (the `dynFrom
+ * liveRef` spelling, lowerer.ts's `liveReference`), so `(await p) ===
+ * shared` holds as it does in Node. Arrays always do; records do when
+ * they declare fields or an index signature (an empty record keeps its
+ * identity through `recordDynKeepsIdentity`'s source access instead). */
+function promisePayloadIsLive(host, t) {
+    if (t.kind === "array")
+        return true;
+    if (t.kind === "record") {
+        const shape = host.recordsById.get(t.shapeId);
+        return shape !== undefined && (shape.fields.length > 0 || shape.indexValue !== undefined);
+    }
+    if (t.kind === "union")
+        return (host.unionsById.get(t.unionId)?.arms ?? []).some((arm) => promisePayloadIsLive(host, arm));
+    return false;
+}
 /** ScrDynKind values (scr_runtime.h). */
 /** ScrDynHandleTag values (scr_dyn.h's explicit values; dyn-handle-tags.test.ts checks them). */
 export const DYN_HANDLE_TAG_NUM = {
@@ -144,6 +163,7 @@ export class LlDyn {
     toDynFns = new Map();
     dynFuncThunks = new Map();
     dynFuncBoxes = new Map();
+    jsEntryThunks = new Map();
     dynFuncAdapters = new Map();
     messageListeners = new Map();
     messageReaders = new Map();
@@ -186,6 +206,10 @@ export class LlDyn {
                 return this.dynFuncThunkHelper(args[0]);
             case "dyn.dynFuncBoxHelper":
                 return this.dynFuncBoxHelper(args[0]);
+            case "dyn.jsEntryThunk":
+                return this.jsEntryThunk(args[0], args[1], args[2]);
+            case "dyn.unnamedFuncBoxHelper":
+                return this.unnamedFuncBoxHelper(args[0]) ?? "";
             case "dyn.dynFuncAdapterHelper":
                 return this.dynFuncAdapterHelper(args[0]);
             case "dyn.dynToStrHelper":
@@ -923,15 +947,22 @@ export class LlDyn {
                 const struct = mangleRecordStruct(sourceId);
                 const base = host.nullableUnions.fieldBase(sourceId);
                 const offsets = target.fields.map((field) => {
-                    const index = source.fields.findIndex((f) => f.name === field.name) + base;
-                    return `${S} ptrtoint (ptr getelementptr (%${struct}, ptr null, i32 0, i32 ${index}) to ${S})`;
+                    const index = source.fields.findIndex((f) => f.name === field.name);
+                    // A partial view's target field the source does not declare has
+                    // no slot: all ones (SIZE_MAX) marks it absent (record-views.ts).
+                    if (index < 0)
+                        return `${S} -1`;
+                    return `${S} ptrtoint (ptr getelementptr (%${struct}, ptr null, i32 0, i32 ${index + base}) to ${S})`;
                 });
                 const offsetTable = `${table}_${k}`;
                 this.defs.push(`${offsetTable} = internal constant [${offsets.length} x ${S}] [${offsets.join(", ")}]`);
                 const key = typeKey({ kind: "record", shapeId: sourceId });
-                return `{ ptr, ${S}, ptr } { ptr ${host.cstr(key)}, ${S} ${Buffer.byteLength(key, "utf8")}, ptr ${offsetTable} }`;
+                // The source's declared names describe the record a partial view's
+                // writes add properties to (scr_record_view_extra).
+                const names = this.recordNameTable(sourceId, source);
+                return `{ ptr, ${S}, ptr, ptr, ptr, ${S}, ${S}, ${S} } { ptr ${host.cstr(key)}, ${S} ${Buffer.byteLength(key, "utf8")}, ptr ${offsetTable}, ptr ${names.names}, ptr ${names.lens}, ${S} ${S === "i64" ? 8 : 4}, ${S} ${S === "i64" ? 8 : 4}, ${S} ${source.fields.length} }`;
             });
-            this.defs.push(`${table} = internal constant [${entries.length} x { ptr, ${S}, ptr }] [${entries.join(", ")}]`, ``);
+            this.defs.push(`${table} = internal constant [${entries.length} x { ptr, ${S}, ptr, ptr, ptr, ${S}, ${S}, ${S} }] [${entries.join(", ")}]`, ``);
         }
         const key = typeKey({ kind: "record", shapeId: targetId });
         host.declare(`declare ptr @scr_dyn_record_view(ptr, ptr, ${this.S}, ptr, ${this.S}, ptr)`);
@@ -1601,6 +1632,16 @@ export class LlDyn {
         host.declare(`declare void @scr_record_source_spread(ptr, ptr, ptr, ptr, ${host.sizeType})`);
         B.line(`call void @scr_record_source_spread(ptr ${built}, ptr ${value}, ptr ${names.names}, ptr ${names.lens}, ${host.sizeType} ${shape.fields.length})`);
     }
+    /** `record.sourceNote(built, keys)`: the built record keeps `keys` as
+     * its source when they hold an undeclared key or another order. */
+    emitRecordSourceNote(B, built, keys, shapeId) {
+        const host = this.host;
+        const shape = host.recordsById.get(shapeId);
+        this.keepsRecordSources = true;
+        const names = this.recordNameTable(shapeId, shape);
+        host.declare(`declare void @scr_record_source_note(ptr, ptr, ptr, ptr, ${host.sizeType})`);
+        B.line(`call void @scr_record_source_note(ptr ${built}, ptr ${keys}, ptr ${names.names}, ptr ${names.lens}, ${host.sizeType} ${shape.fields.length})`);
+    }
     /** The declared-name tables scr_record_source_note scans: parallel
      * constant arrays of field-name bytes and byte lengths in declaration
      * order (the order the record serializes), interned per shape. Internal
@@ -2986,7 +3027,7 @@ export class LlDyn {
             }
             case "func": {
                 const r = B.tmp();
-                B.line(`${r} = call ptr @${this.dynFuncBoxHelper(t)}(ptr %v, ptr null)`);
+                B.line(`${r} = ${this.unnamedFuncBoxCall(t, "%v")}`);
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
@@ -3006,6 +3047,12 @@ export class LlDyn {
                     this.textCodecToDyn(B, t, shape, codec);
                     break;
                 }
+                // A copy linked to its source converts as its composed record.
+                emitLinkedRecordBranches(host, B, t.shapeId, "%v", (sourceT, composed) => {
+                    const r = B.tmp();
+                    B.line(`${r} = call ptr @${this.toDynHelper(sourceT)}(ptr ${composed})`);
+                    return `ret ptr ${r}`;
+                });
                 const struct = mangleRecordStruct(t.shapeId);
                 const base = host.nullableUnions.fieldBase(t.shapeId);
                 const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + base]));
@@ -3378,7 +3425,7 @@ export class LlDyn {
                         // function boundary (the dynFrom func special case, sans name).
                         const p = emitUnionPeek(B, nullable, "%v");
                         const r = B.tmp();
-                        B.line(`${r} = call ptr @${this.dynFuncBoxHelper(arm)}(ptr ${p}, ptr null)`);
+                        B.line(`${r} = ${this.unnamedFuncBoxCall(arm, p)}`);
                         B.terminate(`ret ptr ${r}`);
                     }
                     else {
@@ -3517,10 +3564,18 @@ export class LlDyn {
                 // Ref-payload inners (records, arrays, bytes, %Error, unions,
                 // nested promises, handles): extract (+1 via the stored retain),
                 // convert through the shared to-dyn spelling, release the extract.
+                // A record or array payload crosses the way `dynFrom liveRef` boxes
+                // one — a LIVE capsule of the settled record — so the settled
+                // payload and the record the producer holds stay one object
+                // (`(await p) === shared`). Everything else keeps the to-dyn
+                // spelling: maps, sets, class instances and bytes box by reference
+                // there already.
                 host.declare(`declare ptr @scr_promise_payload_ref(ptr)`);
                 const pv = B.tmp();
                 B.line(`${pv} = call ptr @scr_promise_payload_ref(ptr %src) ; +1`);
-                const dv = this.toDynExpr(B, inner, pv);
+                const dv = promisePayloadIsLive(host, inner)
+                    ? (this.liveToDyn(B, inner, pv) ?? this.toDynExpr(B, inner, pv))
+                    : this.toDynExpr(B, inner, pv);
                 if (isRefCounted(inner))
                     B.line(`call void ${releaseSym(host, inner)}(ptr ${pv})`);
                 fulfill(dv);
@@ -4653,10 +4708,16 @@ export class LlDyn {
      * BORROWED in every arm. Emits into the given builder. */
     /** A live capsule of a record or array value (+1; the value is
      * borrowed), as `dynFrom` with `liveRef` builds it; null for other
-     * types. Closures boxed in a declaration-typed boundary program return
-     * their records and arrays this way. */
+     * types. Every typed value crossing into the dynamic tier this way keeps
+     * its identity — a boxed closure's result and a settled promise payload
+     * included, so `f()`/`await p` hand out the object the producer holds,
+     * as Node does, not a snapshot. A TextEncoder, TextDecoder or
+     * StringDecoder record is null too: it boxes as its own handle, which
+     * holds the record by reference (toDynHelper). */
     liveToDyn(B, t, expr) {
         const host = this.host;
+        if (textCodecRecordClass(t, (id) => host.recordsById.get(id)) !== null)
+            return null;
         if (t.kind === "union") {
             const arms = host.unionsById.get(t.unionId)?.arms ?? [];
             if (!arms.some((arm) => arm.kind === "record" || arm.kind === "array"))
@@ -4676,13 +4737,21 @@ export class LlDyn {
             B.line(line);
         return boxed;
     }
+    /** A static value handed OUT by a container read (a record field a runtime
+     * key selects) as a checked-dynamic value (+1; the value is BORROWED): a
+     * record, an array or a union holding one boxes as a LIVE capsule of the
+     * value itself, the way `dynFrom` with `liveRef` boxes it, so a write
+     * through the result reaches the field; every other type converts by
+     * value. Reading a keyed field is one object either way in JavaScript. */
+    liveReadToDyn(B, t, expr) {
+        return this.liveToDyn(B, t, expr) ?? this.toDynExpr(B, t, expr);
+    }
     toDynExpr(B, t, expr) {
         if (t.kind === "dyn")
             return this.retainDyn(B, expr);
         if (t.kind === "func") {
-            const box = this.dynFuncBoxHelper(t);
             const r = B.tmp();
-            B.line(`${r} = call ptr @${box}(ptr ${expr}, ptr null)`);
+            B.line(`${r} = ${this.unnamedFuncBoxCall(t, expr)}`);
             return r;
         }
         const r = B.tmp();
@@ -4848,9 +4917,12 @@ export class LlDyn {
             const r = B.tmp();
             B.line(`${r} = call ${retTy} ${fn}(${callArgs})`);
             this.pendingBail(B, "dfkr", () => { }, "ptr null");
-            const out = this.host.declBoundary?.() === true
-                ? (this.liveToDyn(B, t.ret, r) ?? this.toDynExpr(B, t.ret, r))
-                : this.toDynExpr(B, t.ret, r);
+            // A record or array result crosses the way `dynFrom liveRef` boxes
+            // one — a LIVE capsule of the closure's own object — so the caller's
+            // `() => shared` through an untyped slot still answers `shared`
+            // (`(r as Row) === shared`), as Node does. Everything else keeps the
+            // to-dyn spelling (handles box by reference there already).
+            const out = this.liveToDyn(B, t.ret, r) ?? this.toDynExpr(B, t.ret, r);
             if (isRefCounted(t.ret))
                 B.line(`call void ${releaseSym(host, t.ret)}(ptr ${r})`);
             B.terminate(`ret ptr ${out}`);
@@ -4859,6 +4931,153 @@ export class LlDyn {
         this.host.journalBuilt?.();
         return name;
     }
+    /** `sc_jt_<n>(ptr c, ptr args, size argc) -> ptr`, a function value's
+     * jsval entry (ScrDynJsEntry) into a closure's jsval body `target`
+     * (IrFunction.jsEntry, 64-bit targets): passes each argument word to the
+     * body, a missing one as undefined and a dyn parameter's boxed, and
+     * returns the body's result as an owned word. Like the closure's own
+     * entry, the body consumes its arguments. With an exception pending the
+     * result is undefined. */
+    jsEntryThunk(target, params, ret) {
+        const existing = this.jsEntryThunks.get(target);
+        if (existing)
+            return existing;
+        const name = `sc_jt_${this.jsEntryThunks.size}`;
+        this.jsEntryThunks.set(target, name);
+        this.host.journalAllocated?.(name, "dyn.jsEntryThunk", [target, params, ret]);
+        const host = this.host;
+        const B = new BlockBuilder();
+        const undefinedWord = `inttoptr (i64 ${JS_BITS.undefined} to ptr)`;
+        const args = params.map((p, i) => {
+            const slot = B.slot();
+            B.entryAllocas.push(`${slot} = alloca ptr`);
+            B.line(`store ptr ${undefinedWord}, ptr ${slot}`);
+            const has = B.tmp();
+            B.line(`${has} = icmp ult ${host.sizeType} ${i}, %argc`);
+            const lHas = B.newLabel("jt.h");
+            const lj = B.newLabel("jt.j");
+            B.condBr(has, lHas, lj);
+            B.startBlock(lHas);
+            const ap = B.tmp();
+            const av = B.tmp();
+            B.line(`${ap} = getelementptr inbounds ptr, ptr %args, ${host.sizeType} ${i}`);
+            B.line(`${av} = load ptr, ptr ${ap}`);
+            B.line(`store ptr ${av}, ptr ${slot}`);
+            B.br(lj);
+            B.startBlock(lj);
+            const word = B.tmp();
+            B.line(`${word} = load ptr, ptr ${slot}`);
+            const owned = B.tmp();
+            if (p.kind === "jsval") {
+                host.declare(`declare ptr @scr_js_retain(ptr)`);
+                B.line(`${owned} = call ptr @scr_js_retain(ptr ${word})`);
+            }
+            else if (p.kind === "dyn") {
+                host.declare(`declare ptr @scr_js_to_dyn_borrow(ptr)`);
+                B.line(`${owned} = call ptr @scr_js_to_dyn_borrow(ptr ${word})`);
+            }
+            else {
+                throw new InternalCompilerError(`llvm emitter bug: jsval entry parameter ${p.kind}`);
+            }
+            return `ptr ${owned}`;
+        });
+        const callArgs = [`ptr %c`, ...args].join(", ");
+        if (ret.kind === "void") {
+            B.line(`call void @${target}(${callArgs})`);
+            this.pendingBail(B, "jtr", () => { }, `ptr ${undefinedWord}`);
+            B.terminate(`ret ptr ${undefinedWord}`);
+        }
+        else {
+            const r = B.tmp();
+            B.line(`${r} = call ${this.valTy(ret)} @${target}(${callArgs})`);
+            this.pendingBail(B, "jtr", () => { }, `ptr ${undefinedWord}`);
+            if (ret.kind === "jsval") {
+                B.terminate(`ret ptr ${r}`);
+            }
+            else if (ret.kind === "f64") {
+                const raw = B.tmp();
+                const nan = B.tmp();
+                const bits = B.tmp();
+                const word = B.tmp();
+                B.line(`${raw} = bitcast double ${r} to i64`);
+                B.line(`${nan} = fcmp uno double ${r}, ${r}`);
+                B.line(`${bits} = select i1 ${nan}, i64 ${JS_BITS.canonicalNan}, i64 ${raw}`);
+                B.line(`${word} = inttoptr i64 ${bits} to ptr`);
+                B.terminate(`ret ptr ${word}`);
+            }
+            else if (ret.kind === "bool") {
+                const bits = B.tmp();
+                const word = B.tmp();
+                B.line(`${bits} = select i1 ${r}, i64 ${JS_BITS.true}, i64 ${JS_BITS.false}`);
+                B.line(`${word} = inttoptr i64 ${bits} to ptr`);
+                B.terminate(`ret ptr ${word}`);
+            }
+            else {
+                // dyn, or a typed result boxed as the closure's own entry would.
+                const d = ret.kind === "dyn" ? r : this.toDynExpr(B, ret, r);
+                if (ret.kind !== "dyn" && isRefCounted(ret))
+                    B.line(`call void ${releaseSym(host, ret)}(ptr ${r})`);
+                host.declare(`declare ptr @scr_js_from_dyn(ptr)`);
+                const word = B.tmp();
+                B.line(`${word} = call ptr @scr_js_from_dyn(ptr ${d})`);
+                B.terminate(`ret ptr ${word}`);
+            }
+        }
+        this.defs.push(`define internal ptr @${name}(ptr %c, ptr %args, ${host.sizeType} %argc) ${FN_ATTRS} { ; jsval entry into ${llvmCommentText(target)}`, B.render(), `}`, ``);
+        this.host.journalBuilt?.();
+        return name;
+    }
+    closureNames;
+    /** The module's closure-name lookup (`sc_closure_name(closure)`, over a
+     * table of `{ ptr entry, ptr name }` pairs), defined on first use; null
+     * when no named function becomes a closure. */
+    closureNameTable() {
+        if (this.closureNames !== undefined)
+            return this.closureNames;
+        const entries = this.host.closureNames?.() ?? [];
+        if (entries.length === 0)
+            return (this.closureNames = null);
+        const host = this.host;
+        const S = host.sizeType;
+        const table = "sc_closure_names";
+        const symbol = "sc_closure_name";
+        // The closure's entry point (an adapter's root's, ScrClosure.identity)
+        // compared with each entry; null when none matches.
+        this.defs.push(`@${table} = internal constant [${entries.length} x { ptr, ptr }] [${entries
+            .map((e) => `{ ptr, ptr } { ptr @${e.entry}, ptr ${host.cstr(e.name)} }`)
+            .join(", ")}]`, ``, `define internal ptr @${symbol}(ptr %v) ${FN_ATTRS} { ; the JavaScript name of a closure's function`, `entry:`, `  %idp = getelementptr inbounds %ScrClosure, ptr %v, i64 0, i32 6`, `  %id = load ptr, ptr %idp`, `  %own = icmp eq ptr %id, null`, `  %root = select i1 %own, ptr %v, ptr %id`, `  %fnp = getelementptr inbounds %ScrClosure, ptr %root, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`, `  br label %loop`, `loop:`, `  %i = phi ${S} [ 0, %entry ], [ %next, %step ]`, `  %done = icmp eq ${S} %i, ${entries.length}`, `  br i1 %done, label %none, label %test`, `test:`, `  %ep = getelementptr inbounds [${entries.length} x { ptr, ptr }], ptr @${table}, i64 0, ${S} %i, i32 0`, `  %e = load ptr, ptr %ep`, `  %hit = icmp eq ptr %e, %fn`, `  br i1 %hit, label %found, label %step`, `step:`, `  %next = add ${S} %i, 1`, `  br label %loop`, `found:`, `  %np = getelementptr inbounds [${entries.length} x { ptr, ptr }], ptr @${table}, i64 0, ${S} %i, i32 1`, `  %name = load ptr, ptr %np`, `  ret ptr %name`, `none:`, `  ret ptr null`, `}`, ``);
+        return (this.closureNames = { symbol, count: entries.length });
+    }
+    unnamedFuncBoxes = new Map();
+    /** `sc_dfu_<n>(ptr closure) -> ptr`: the box of a function value with no
+     * static name (one inside a record, array or other value being
+     * converted), named from the module's closure-name table. The plain box
+     * when no named function becomes a closure. */
+    unnamedFuncBoxHelper(t) {
+        if ((this.host.closureNames?.() ?? []).length === 0)
+            return null;
+        const box = this.dynFuncBoxHelper(t);
+        const key = typeKey(t);
+        const existing = this.unnamedFuncBoxes.get(key);
+        if (existing)
+            return existing;
+        const name = `sc_dfu_${this.unnamedFuncBoxes.size}`;
+        this.unnamedFuncBoxes.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.unnamedFuncBoxHelper", [t]);
+        // The first box defines the table and its lookup.
+        const table = this.closureNameTable();
+        this.defs.push(`define internal ptr @${name}(ptr %v) ${FN_ATTRS} { ; box ${key} into dyn with its own name`, `entry:`, `  %n = call ptr @${table.symbol}(ptr %v)`, `  %r = call ptr @${box}(ptr %v, ptr %n)`, `  ret ptr %r`, `}`, ``);
+        this.host.journalBuilt?.();
+        return name;
+    }
+    /** The call that boxes the function value `value` of type `t` without a
+     * static name (unnamedFuncBoxHelper). */
+    unnamedFuncBoxCall(t, value) {
+        const named = this.unnamedFuncBoxHelper(t);
+        return named === null
+            ? `call ptr @${this.dynFuncBoxHelper(t)}(ptr ${value}, ptr null)`
+            : `call ptr @${named}(ptr ${value})`;
+    }
     /** The box builder dynFrom emits for one closure signature. */
     dynFuncBoxHelper(t) {
         const key = typeKey(t);
@@ -4873,7 +5092,24 @@ export class LlDyn {
         host.declare(`declare ptr @scr_closure_retain_v(ptr)`);
         host.declare(`declare ptr @scr_dyn_new_func(ptr, ptr, i32, ptr, ptr)`);
         const sigLit = host.cstr(key);
-        this.defs.push(`define internal ptr @${name}(ptr %v, ptr %fname) ${FN_ATTRS} { ; box ${key} into dyn`, `entry:`, `  %c = call ptr @scr_closure_retain_v(ptr %v)`, `  %r = call ptr @scr_dyn_new_func(ptr %c, ptr @${thunk}, i32 ${t.params.length - (t.restAbi === "typed" ? 1 : 0)}, ptr ${sigLit}, ptr %fname)`, `  ret ptr %r`, `}`, ``);
+        // A closure of this signature with a jsval body gets the function
+        // value's jsval entry, however the value is boxed: the closure's
+        // entry pointer names it.
+        const entries = t.rest === true
+            ? []
+            : (host.jsEntryClosures?.() ?? []).filter((c) => c.params.length === t.params.length &&
+                c.params.every((p, i) => typeKey(p) === typeKey(t.params[i])) &&
+                typeKey(c.ret) === typeKey(t.ret));
+        const register = [];
+        if (entries.length > 0) {
+            host.declare(`declare void @scr_dyn_func_set_js(ptr, ptr, ptr)`);
+            register.push(`  %fnp = getelementptr inbounds %ScrClosure, ptr %c, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`);
+            entries.forEach((c, i) => {
+                const jsEntry = this.jsEntryThunk(c.body, c.bodyParams, c.bodyRet);
+                register.push(`  %is${i} = icmp eq ptr %fn, @${c.closure}`, `  br i1 %is${i}, label %set${i}, label %next${i}`, `set${i}:`, `  call void @scr_dyn_func_set_js(ptr %r, ptr @${thunk}, ptr @${jsEntry})`, `  ret ptr %r`, `next${i}:`);
+            });
+        }
+        this.defs.push(`define internal ptr @${name}(ptr %v, ptr %fname) ${FN_ATTRS} { ; box ${key} into dyn`, `entry:`, `  %c = call ptr @scr_closure_retain_v(ptr %v)`, `  %r = call ptr @scr_dyn_new_func(ptr %c, ptr @${thunk}, i32 ${t.params.length - (t.restAbi === "typed" ? 1 : 0)}, ptr ${sigLit}, ptr %fname)`, ...register, `  ret ptr %r`, `}`, ``);
         this.host.journalBuilt?.();
         return name;
     }