@scriptc/compiler 0.4.6 → 0.4.8

package/dist/backend/llvm/shapes.d.ts

@@ -3,7 +3,7 @@
  * their fields. Every allocation has a size_t reference count at offset zero
  * and participates in the runtime allocation audit. */
 import type { HeapCensus } from "./heap-census.js";
-import type { IrClassDef, IrModule, IrRecordShape, IrType } from "../../ir/ir.js";
+import type { IrClassDef, IrModule, IrRecordLink, IrRecordShape, IrType } from "../../ir/ir.js";
 import { type FreeObservers } from "./alloc.js";
 import { type BlockBuilder } from "./blocks.js";
 import { type NullableUnions } from "./nullable-unions.js";
@@ -12,6 +12,11 @@ import { type RecordViews } from "./record-views.js";
 /** What the tables need from the emitter: the extern-declaration ledger
  * and the module-wide cycle/shape indexes. */
 export interface ShapeHost {
+    /** The module's record links (IrModule.recordLinks); absent when none. */
+    readonly recordLinks?: readonly IrRecordLink[];
+    /** The gate a lookup of a checked record's kept source tests
+     * (alloc.ts RECORD_KEPT_GATE); RECORD_SOURCES_GATE when absent. */
+    readonly recordSourcesGate?: string;
     /** The counters of a build instrumented for the heap census (heap-census.ts). */
     readonly heapCensus?: HeapCensus | null;
     /** Chunk emitters only (emit-journal.ts): EmitJournal's allocated, built,
@@ -37,6 +42,9 @@ export interface ShapeHost {
     /** Byte offset from an object pointer back to ScrCycHdr.buf. */
     readonly cycleBufOffset: number;
     declare(decl: string): void;
+    /** The module constant for a string (LlEmitter.cstr), for a trap message
+     * an emitted accessor passes to the runtime. */
+    cstr(text: string): string;
     /** Inline the small-object allocator's fast paths (llvm/alloc.ts). */
     readonly inlineAlloc?: boolean;
     /** Record and class fields that store a scalar union's tag and bits
@@ -94,6 +102,8 @@ export interface ShapeHost {
     readonly sizeType: "i32" | "i64";
     /** Worker executables: the inline allocator state is thread-local. */
     readonly threadLocalAlloc?: boolean;
+    /** The inline frees read the chunk map (alloc.ts AllocHost.windowMap). */
+    readonly windowMap?: boolean;
     readonly tracedShapes: Set<string>;
     readonly tracedUnions: Set<string>;
     /** The zeroed `%ScrUnion` an inline store reads for a NULL dummy. */
@@ -411,9 +421,32 @@ export declare function destroyDefinitions(destroy: string, body: readonly strin
  * them, as segmentTeardownLines arranges for the recursive form. The loop
  * needs no depth budget. `_d` (the direct-chain entry other teardowns call)
  * and the plain entry both run it. A class that keeps its id in the count
- * word counts in the low half (`count`); a dead node's whole word is free. */
+ * word counts in the low half (`count`); a dead node's whole word is free.
+ *
+ * A tree class (tree-classes.ts) has no count word to hold the link, so it
+ * tears down through treeTeardownDefinitions instead. */
 export declare function iterativeTeardownDefinitions(host: ShapeHost, destroy: string, struct: string, fields: readonly number[], release: string, observers: FreeObservers, count?: RcCount): string[];
-/** Common NULL/immortal/decrement skeleton for ordinary object releases.
+/** The teardown of a tree class: instances of it carry no count word
+ * (tree-classes.ts), so a pending subtree cannot ride in the object header
+ * the way iterativeTeardownDefinitions threads it. This loop keeps its
+ * pending list in the blocks it has just freed instead. A pending entry is a
+ * freed block holding the next entry in its first word and a node in its
+ * second, so the freed block of the node being torn down becomes the entry
+ * for one child while the loop descends into the other: the list stays one
+ * entry deep per level of the tree, and every node costs one free, at most
+ * one entry store pair and one list step.
+ *
+ * The freed blocks that are not entries join a segment linked through their
+ * first word (emitObjectFree, emitSegmentFree), as the counting loop's do.
+ * `fields` holds the two child indices; `_one` is the per-node fallback a
+ * subtree takes when the freed block is not the arena's to reuse (a node the
+ * allocator compiled out of, or one outside the reservation), which the
+ * runtime's depth-bounded worklist drives instead.
+ *
+ * A tree class with a single child field needs no list at all: the loop
+ * follows the child. */
+export declare function treeTeardownDefinitions(host: ShapeHost, destroy: string, struct: string, fields: readonly number[], observers: FreeObservers): string[];
+/** Common NULL/immortal skeleton for ordinary object releases.
  * `freeBody` owns the zero-ref teardown and must leave the current block at
  * its end; traced objects also get the possible-cycle-root branch.
  *

package/dist/backend/llvm/shapes.js

@@ -7,12 +7,9 @@ import { NULLABLE_NULL, SHAPE_WORD_INDEX, classReleaseFn, classRetainFn, classTr
 import { INLINE_UNION_FIELD, loadInlineUnion, stackUnionBox, } from "./inline-unions.js";
 import { JS_BITS, JS_TAGS } from "./jsval-encoding.js";
 import { ARENA_RC, arenaDisposeLines, arenaDisposeSym, arenaNewLines, disposeFieldLines, plainRefType, } from "./arenas.js";
-import { recordViewTestLines } from "./record-views.js";
+import { PARTIAL_VIEW_ABSENT, recordViewTestLines } from "./record-views.js";
 import { recordMayKeepSource } from "./record-sources.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
-/** SCR_CYC_MAX_TYPES (scr_rc.h): the registry's size, and the length of
- * the young-in nursery's per-id skip countdown. */
-const CYC_MAX_TYPES = 32768;
 /** The nursery entry of a new traced instance in `%o`, after its count is
  * stored; nothing when the nursery is off. Where the allocator is inlined
  * (64-bit, process-global state) the entry is inline too: a type that is
@@ -31,13 +28,16 @@ export function youngEntryLines(host) {
         return [`  call void @scr_yin_enter(ptr %o) ; the young-in nursery`];
     }
     host.declare(`@scr_yin = external global { ptr, i64, i64, i64 }`);
-    host.declare(`@scr_yin_skip = external global [${CYC_MAX_TYPES} x i32]`);
+    // The per-id skip countdown has SCR_CYC_MAX_TYPES entries (scr_rc.h),
+    // which a runtime build may set; the declaration leaves the size to the
+    // definition, as C does for `extern uint32_t scr_yin_skip[];`.
+    host.declare(`@scr_yin_skip = external global [0 x i32]`);
     host.declare(`declare void @scr_yin_enter_slow(ptr)`);
     return [
         `  %ye.idp = getelementptr inbounds i8, ptr %o, i64 -${CYC_HDR} ; the young-in nursery`,
         `  %ye.id16 = load i16, ptr %ye.idp ; ScrCycHdr.id`,
         `  %ye.id = zext i16 %ye.id16 to i64`,
-        `  %ye.sp = getelementptr inbounds [${CYC_MAX_TYPES} x i32], ptr @scr_yin_skip, i64 0, i64 %ye.id`,
+        `  %ye.sp = getelementptr inbounds i32, ptr @scr_yin_skip, i64 %ye.id`,
         `  %ye.s = load i32, ptr %ye.sp`,
         `  %ye.skip = icmp ne i32 %ye.s, 0`,
         `  br i1 %ye.skip, label %ye.skipped, label %ye.enter`,
@@ -1126,8 +1126,13 @@ export function mapKeyKindNum(key, unionArms) {
         return 8;
     if (key.kind === "undefinedT")
         return 9;
+    // SCR_MAP_KEY_CLOSURE: function values compare their identity roots, so a
+    // signature adapter is the key of the function it adapts. A union with a
+    // function arm keys each arm by its own kind (SCR_MAP_KEY_UNION_VALUE).
+    if (key.kind === "func")
+        return 10;
     if (key.kind === "union")
-        return unionArms?.every(isIdentityCollectionKey) ? 3 : 7;
+        return unionArms?.every((arm) => isIdentityCollectionKey(arm) && arm.kind !== "func") ? 3 : 7;
     const acc = mapKeyAccess(key);
     return acc === "f64" ? 0 : acc === "str" ? 1 : 2;
 }
@@ -1429,7 +1434,10 @@ function sizeLiteral(sizeType, value) {
  * them, as segmentTeardownLines arranges for the recursive form. The loop
  * needs no depth budget. `_d` (the direct-chain entry other teardowns call)
  * and the plain entry both run it. A class that keeps its id in the count
- * word counts in the low half (`count`); a dead node's whole word is free. */
+ * word counts in the low half (`count`); a dead node's whole word is free.
+ *
+ * A tree class (tree-classes.ts) has no count word to hold the link, so it
+ * tears down through treeTeardownDefinitions instead. */
 export function iterativeTeardownDefinitions(host, destroy, struct, fields, release, observers, count = host.sizeType) {
     const S = host.sizeType;
     const lines = [
@@ -1447,7 +1455,7 @@ export function iterativeTeardownDefinitions(host, destroy, struct, fields, rele
             `  %it.v${i} = load ptr, ptr %it.f${i}`,
         ]),
         `  store ptr null, ptr %sg.own`,
-        ...emitObjectFree(host, false, observers, "%sg.own"),
+        ...emitObjectFree(host, false, observers, "%sg.own", `ptrtoint (ptr getelementptr (%${struct}, ptr null, i32 1) to ${S})`),
         `  br label %it.freed`,
         `it.freed:`,
         `  %it.k = load ptr, ptr %sg.own`,
@@ -1471,14 +1479,176 @@ export function iterativeTeardownDefinitions(host, destroy, struct, fields, rele
     let from = "it.kids";
     for (let i = fields.length - 1; i >= 0; i--) {
         const v = `%it.v${i}`;
-        lines.push(`  %it.nn${i} = icmp ne ptr ${v}, null`, `  br i1 %it.nn${i}, label %it.chk${i}, label %it.j${i}`, `it.chk${i}:`, `  %it.rc${i} = load ${count}, ptr ${v}`, `  %it.last${i} = icmp eq ${count} %it.rc${i}, 1`, `  br i1 %it.last${i}, label %it.push${i}, label %it.sh${i}`, `it.push${i}:`, `  %it.pl${i} = ptrtoint ptr ${pend} to ${S}`, `  store ${S} %it.pl${i}, ptr ${v}`, `  br label %it.j${i}`, `it.sh${i}:`, `  call void ${release}(ptr ${v}) ; a shared or immortal child`, `  br label %it.j${i}`, `it.j${i}:`, `  %it.p${i} = phi ptr [ ${pend}, %${from} ], [ ${v}, %it.push${i} ], [ ${pend}, %it.sh${i} ]`);
+        lines.push(`  %it.nn${i} = icmp ne ptr ${v}, null`, `  br i1 %it.nn${i}, label %it.chk${i}, label %it.j${i}`, `it.chk${i}:`);
+        lines.push(`  %it.rc${i} = load ${count}, ptr ${v}`, `  %it.last${i} = icmp eq ${count} %it.rc${i}, 1`, `  br i1 %it.last${i}, label %it.push${i}, label %it.sh${i}`, `it.push${i}:`, `  %it.pl${i} = ptrtoint ptr ${pend} to ${S}`, `  store ${S} %it.pl${i}, ptr ${v}`, `  br label %it.j${i}`, `it.sh${i}:`, `  call void ${release}(ptr ${v}) ; a shared or immortal child`, `  br label %it.j${i}`, `it.j${i}:`, `  %it.p${i} = phi ptr [ ${pend}, %${from} ], [ ${v}, %it.push${i} ], [ ${pend}, %it.sh${i} ]`);
         pend = `%it.p${i}`;
         from = `it.j${i}`;
     }
     lines.push(`  %it.empty = icmp eq ptr ${pend}, null`, `  br i1 %it.empty, label %it.done, label %it.next`, `it.next:`, `  %it.top = getelementptr i8, ptr ${pend}, i64 0`, `  %it.lw = load ${S}, ptr %it.top`, `  %it.rest = inttoptr ${S} %it.lw to ptr`, `  br label %it.node`, `it.done:`, ...emitSegmentFree(host, "sgf", "%it.fa", "%it.la"), `  ret void`, `}`, `define internal void @${destroy}_d(ptr %o, i32 %d) ${FN_ATTRS} {`, `entry:`, `  call void @${destroy}_it(ptr %o)`, `  ret void`, `}`, `define internal void @${destroy}(ptr %o) ${FN_ATTRS} {`, `entry:`, `  call void @${destroy}_it(ptr %o)`, `  ret void`, `}`);
     return lines;
 }
-/** Common NULL/immortal/decrement skeleton for ordinary object releases.
+/** The teardown of a tree class: instances of it carry no count word
+ * (tree-classes.ts), so a pending subtree cannot ride in the object header
+ * the way iterativeTeardownDefinitions threads it. This loop keeps its
+ * pending list in the blocks it has just freed instead. A pending entry is a
+ * freed block holding the next entry in its first word and a node in its
+ * second, so the freed block of the node being torn down becomes the entry
+ * for one child while the loop descends into the other: the list stays one
+ * entry deep per level of the tree, and every node costs one free, at most
+ * one entry store pair and one list step.
+ *
+ * The freed blocks that are not entries join a segment linked through their
+ * first word (emitObjectFree, emitSegmentFree), as the counting loop's do.
+ * `fields` holds the two child indices; `_one` is the per-node fallback a
+ * subtree takes when the freed block is not the arena's to reuse (a node the
+ * allocator compiled out of, or one outside the reservation), which the
+ * runtime's depth-bounded worklist drives instead.
+ *
+ * A tree class with a single child field needs no list at all: the loop
+ * follows the child. */
+export function treeTeardownDefinitions(host, destroy, struct, fields, observers) {
+    host.declare(`declare void @scr_rc_destroy(ptr, ptr)`);
+    const load = (i, index) => [
+        `  %it.f${i} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${index}`,
+        `  %it.v${i} = load ptr, ptr %it.f${i}`,
+    ];
+    const free = [
+        `  store ptr null, ptr %sg.own`,
+        ...emitObjectFree(host, false, observers, "%sg.own"),
+        `  br label %it.freed`,
+        `it.freed:`,
+        `  %it.k = load ptr, ptr %sg.own`,
+    ];
+    /** `block` joins the segment: the tail's first word points at it, and an
+     * empty segment takes it for both ends. The lines start in block `from`
+     * and end in block `${name}.out`, which defines `%<name>.h` and
+     * `%<name>.t`. */
+    const chain = (name, block, from, head = "%it.ha", tail = "%it.ta") => [
+        `  %${name}.nul = icmp eq ptr ${block}, null`,
+        `  br i1 %${name}.nul, label %${name}.out, label %${name}.app`,
+        `${name}.app:`,
+        `  %${name}.emp = icmp eq ptr ${tail}, null`,
+        `  br i1 %${name}.emp, label %${name}.out, label %${name}.link`,
+        `${name}.link:`,
+        `  store ptr ${block}, ptr ${tail}`,
+        `  br label %${name}.out`,
+        `${name}.out:`,
+        `  %${name}.h = phi ptr [ ${head}, %${from} ], [ ${block}, %${name}.app ], [ ${head}, %${name}.link ]`,
+        `  %${name}.t = phi ptr [ ${tail}, %${from} ], [ ${block}, %${name}.app ], [ ${block}, %${name}.link ]`,
+    ];
+    const wrappers = [
+        `define internal void @${destroy}_d(ptr %o, i32 %d) ${FN_ATTRS} {`,
+        `entry:`,
+        `  call void @${destroy}_it(ptr %o)`,
+        `  ret void`,
+        `}`,
+        `define internal void @${destroy}(ptr %o) ${FN_ATTRS} {`,
+        `entry:`,
+        `  call void @${destroy}_it(ptr %o)`,
+        `  ret void`,
+        `}`,
+    ];
+    const done = (first, last) => [
+        `it.done:`,
+        ...emitSegmentFree(host, "sgf", first, last),
+        `  ret void`,
+        `}`,
+    ];
+    if (fields.length === 1)
+        return [
+            `define internal void @${destroy}_it(ptr %root) ${FN_ATTRS} {`,
+            `entry:`,
+            `  %sg.own = alloca ptr`,
+            `  br label %it.node`,
+            `it.node:`,
+            `  %o = phi ptr [ %root, %entry ], [ %it.v0, %it.ch.out ]`,
+            `  %it.ha = phi ptr [ null, %entry ], [ %it.ch.h, %it.ch.out ]`,
+            `  %it.ta = phi ptr [ null, %entry ], [ %it.ch.t, %it.ch.out ]`,
+            ...load(0, fields[0]),
+            ...free,
+            ...chain("it.ch", "%it.k", "it.freed"),
+            `  %it.nn = icmp ne ptr %it.v0, null`,
+            `  br i1 %it.nn, label %it.node, label %it.done`,
+            ...done("%it.ch.h", "%it.ch.t"),
+            ...wrappers,
+        ];
+    const [f0, f1] = fields;
+    return [
+        `define internal void @${destroy}_it(ptr %root) ${FN_ATTRS} {`,
+        `entry:`,
+        `  %sg.own = alloca ptr`,
+        `  br label %it.node`,
+        `it.node:`,
+        `  %o = phi ptr [ %root, %entry ], [ %it.v0, %it.push ], [ %it.v0, %it.slow ], [ %it.v0, %it.one.out ], [ %it.v1, %it.only.out ], [ %it.en, %it.popk.out ]`,
+        `  %it.st = phi ptr [ null, %entry ], [ %it.k, %it.push ], [ %it.st, %it.slow ], [ %it.st, %it.one.out ], [ %it.st, %it.only.out ], [ %it.pn, %it.popk.out ]`,
+        `  %it.ha = phi ptr [ null, %entry ], [ %it.ha, %it.push ], [ %it.ha, %it.slow ], [ %it.one.h, %it.one.out ], [ %it.only.h, %it.only.out ], [ %it.popk.h, %it.popk.out ]`,
+        `  %it.ta = phi ptr [ null, %entry ], [ %it.ta, %it.push ], [ %it.ta, %it.slow ], [ %it.one.t, %it.one.out ], [ %it.only.t, %it.only.out ], [ %it.popk.t, %it.popk.out ]`,
+        ...load(0, f0),
+        ...load(1, f1),
+        ...free,
+        `  %it.v0n = icmp ne ptr %it.v0, null`,
+        `  br i1 %it.v0n, label %it.left, label %it.noleft`,
+        `it.left:`,
+        `  %it.v1n = icmp ne ptr %it.v1, null`,
+        `  br i1 %it.v1n, label %it.two, label %it.one`,
+        `it.two: ; the freed block becomes the entry for the second child`,
+        `  %it.kn = icmp ne ptr %it.k, null`,
+        `  br i1 %it.kn, label %it.push, label %it.slow`,
+        `it.push:`,
+        `  store ptr %it.st, ptr %it.k`,
+        `  %it.g1 = getelementptr i8, ptr %it.k, i64 8`,
+        `  store ptr %it.v1, ptr %it.g1`,
+        `  br label %it.node`,
+        `it.slow: ; the block is not the arena's: the runtime worklist takes the second child`,
+        `  call void @scr_rc_destroy(ptr %it.v1, ptr @${destroy}_one)`,
+        `  br label %it.node`,
+        `it.one: ; one child: the freed block joins the segment`,
+        ...chain("it.one", "%it.k", "it.one"),
+        `  br label %it.node`,
+        `it.noleft:`,
+        `  %it.v1n2 = icmp ne ptr %it.v1, null`,
+        `  br i1 %it.v1n2, label %it.only, label %it.leaf`,
+        `it.only: ; the first child is empty: follow the second`,
+        ...chain("it.only", "%it.k", "it.only"),
+        `  br label %it.node`,
+        `it.leaf: ; no children: the freed block joins the segment, then the list`,
+        ...chain("it.leaf", "%it.k", "it.leaf"),
+        `  br label %it.pop`,
+        `it.pop:`,
+        `  %it.none = icmp eq ptr %it.st, null`,
+        `  br i1 %it.none, label %it.done, label %it.popk`,
+        `it.popk: ; the entry's block joins the segment`,
+        `  %it.pn = load ptr, ptr %it.st`,
+        `  %it.pe = getelementptr i8, ptr %it.st, i64 8`,
+        `  %it.en = load ptr, ptr %it.pe`,
+        ...chain("it.popk", "%it.st", "it.popk", "%it.leaf.h", "%it.leaf.t"),
+        `  br label %it.node`,
+        ...done("%it.leaf.h", "%it.leaf.t"),
+        `define internal void @${destroy}_one(ptr %o) ${FN_ATTRS} {`,
+        `entry:`,
+        `  %one.f0 = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${f0}`,
+        `  %one.v0 = load ptr, ptr %one.f0`,
+        `  %one.f1 = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${f1}`,
+        `  %one.v1 = load ptr, ptr %one.f1`,
+        ...emitObjectFree(host, false, observers),
+        `  %one.v0n = icmp ne ptr %one.v0, null`,
+        `  br i1 %one.v0n, label %one.r0, label %one.j0`,
+        `one.r0:`,
+        `  call void @scr_rc_destroy(ptr %one.v0, ptr @${destroy}_one)`,
+        `  br label %one.j0`,
+        `one.j0:`,
+        `  %one.v1n = icmp ne ptr %one.v1, null`,
+        `  br i1 %one.v1n, label %one.r1, label %one.j1`,
+        `one.r1:`,
+        `  call void @scr_rc_destroy(ptr %one.v1, ptr @${destroy}_one)`,
+        `  br label %one.j1`,
+        `one.j1:`,
+        `  ret void`,
+        `}`,
+        ...wrappers,
+    ];
+}
+/** Common NULL/immortal skeleton for ordinary object releases.
  * `freeBody` owns the zero-ref teardown and must leave the current block at
  * its end; traced objects also get the possible-cycle-root branch.
  *
@@ -1746,9 +1916,9 @@ export function emitRecordShapes(host, mod) {
             t++;
         }
         if (segmented)
-            freeBody.push(...segmentPrologueLines(), ...loads, ...emitObjectFree(host, traced, observers, "%sg.own"), ...segmentTeardownLines(ownType, (prefix) => refMembers.flatMap((m, i) => release(prefix, m, i))));
+            freeBody.push(...segmentPrologueLines(), ...loads, ...emitObjectFree(host, traced, observers, "%sg.own", sizeOf), ...segmentTeardownLines(ownType, (prefix) => refMembers.flatMap((m, i) => release(prefix, m, i))));
         else
-            freeBody.push(...emitObjectFree(host, traced, observers));
+            freeBody.push(...emitObjectFree(host, traced, observers, null, sizeOf));
         // A segmented shape whose every reference field holds its own type, with
         // no collector header and no frozen bit in its count, tears down in one
         // loop (iterativeTeardownDefinitions).
@@ -1813,9 +1983,24 @@ export function emitRecordShapes(host, mod) {
                 const inline = host.inlineUnions.record(field.type);
                 const fieldTy = llFieldType(field.type, inline);
                 if (host.recordViews?.targets.has(shape.id) === true) {
-                    // A view's fields live in the viewed record (record-views.ts).
+                    // A view's fields live in the viewed record (record-views.ts); a
+                    // shape a partial view may present answers NULL for a field the
+                    // viewed record lacks, so the copy stops with the program's own
+                    // message (a source-level read threw first).
+                    const partial = host.recordViews.partialTargets.has(shape.id);
                     host.declare(`declare ptr @scr_record_view_slot(ptr, ${host.sizeType})`);
-                    clone.push(`  %so${i} = getelementptr inbounds %${struct}, ptr %src, i64 0, i32 ${index}`, ...recordViewTestLines(host.sizeType, "%src", `%sr${i}v`), `  br i1 %sr${i}v, label %sv${i}.view, label %sv${i}.join`, `sv${i}.view:`, `  %sw${i} = call ptr @scr_record_view_slot(ptr %src, ${host.sizeType} ${i})`, `  br label %sv${i}.join`, `sv${i}.join:`, `  %sp${i} = phi ptr [ %so${i}, %${i === 0 ? "entry" : `sv${i - 1}.join`} ], [ %sw${i}, %sv${i}.view ]`, `  %sv${i} = load ${fieldTy}, ptr %sp${i}`);
+                    const fromView = partial
+                        ? [
+                            `  %sn${i} = icmp eq ptr %sw${i}, null`,
+                            `  br i1 %sn${i}, label %sv${i}.absent, label %sv${i}.join`,
+                            `sv${i}.absent:`,
+                            `  call void @scr_trap(ptr ${host.cstr(PARTIAL_VIEW_ABSENT)})`,
+                            `  unreachable`,
+                        ]
+                        : [`  br label %sv${i}.join`];
+                    if (partial)
+                        host.declare(`declare void @scr_trap(ptr)`);
+                    clone.push(`  %so${i} = getelementptr inbounds %${struct}, ptr %src, i64 0, i32 ${index}`, ...recordViewTestLines(host.sizeType, "%src", `%sr${i}v`), `  br i1 %sr${i}v, label %sv${i}.view, label %sv${i}.join`, `sv${i}.view:`, `  %sw${i} = call ptr @scr_record_view_slot(ptr %src, ${host.sizeType} ${i})`, ...fromView, `sv${i}.join:`, `  %sp${i} = phi ptr [ %so${i}, %${i === 0 ? "entry" : `sv${i - 1}.join`} ], [ %sw${i}, %sv${i}.view ]`, `  %sv${i} = load ${fieldTy}, ptr %sp${i}`);
                 }
                 else
                     clone.push(`  %sp${i} = getelementptr inbounds %${struct}, ptr %src, i64 0, i32 ${index}`, `  %sv${i} = load ${fieldTy}, ptr %sp${i}`);
@@ -1852,7 +2037,7 @@ export function emitRecordShapes(host, mod) {
             untracedRefMembers.forEach((m, i) => {
                 gf.push(`  %f${i} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${m.index}`, `  %v${i} = load ptr, ptr %f${i}`, `  call void ${releaseSym(host, m.type)}(ptr %v${i}) ; ${llvmCommentText(m.name)} (acyclic)`);
             });
-            gf.push(...emitObjectFree(host, true, observers), `  ret void`, `}`, ``);
+            gf.push(...emitObjectFree(host, true, observers, null, sizeOf), `  ret void`, `}`, ``);
             defs.push(...gf);
         }
     }