@scriptc/compiler 0.3.1 → 0.3.3

package/dist/backend/llvm/shapes.js

@@ -1,7 +1,8 @@
-import { isIdentityCollectionKey, isRefCounted, mapOf, POINTER_KINDS, runtimeRcStem, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, } from "../../ir/ir.js";
+import { isIdentityCollectionKey, isRefCounted, mapOf, POINTER_KINDS, runtimeRcStem, RUNTIME_EMITTER_CLASS, RUNTIME_EVENT_CLASS, RUNTIME_EVENT_TARGET_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, } from "../../ir/ir.js";
 import { mangleClassRelease, mangleClassRetain, mangleClassTrace, mangleRecordGcFree, mangleRecordClone, mangleRecordNew, mangleRecordRelease, mangleRecordRetain, mangleRecordStruct, mangleRecordTrace, } from "../mangle.js";
 import { cycTypeDescriptor, emitObjectAlloc, emitObjectFree } from "./alloc.js";
 import { SCR_ARR_FIELD, llvmCommentText } from "./common.js";
+import { INLINE_UNION_FIELD, loadInlineUnion, stackUnionBox, } from "./inline-unions.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 /** Every emitted function/helper carries #0 = { sanitize_address } — see
  * the emitter header. */
@@ -38,13 +39,29 @@ export function vAdapters(host, t) {
                 retain: `@${mangleRecordRetain(t.shapeId)}`,
                 release: `@${mangleRecordRelease(t.shapeId)}`,
             };
-        case "object":
+        case "object": {
+            // Subclasses of the runtime EventTarget and Event bases share the
+            // runtime's adapters (the same rc word and vtable dispatch as the
+            // emitted helpers): the engine recognizes their checked-dynamic
+            // capsules by the release adapter.
+            const root = host.classRootOf?.(t.className);
+            const runtime = root === RUNTIME_EVENT_TARGET_CLASS
+                ? { retain: "scr_event_target_obj_retain_v", release: "scr_event_target_obj_release_v" }
+                : root === RUNTIME_EVENT_CLASS
+                    ? { retain: "scr_event_obj_retain_v", release: "scr_event_obj_release_v" }
+                    : null;
+            if (runtime !== null) {
+                host.declare(`declare ptr @${runtime.retain}(ptr)`);
+                host.declare(`declare void @${runtime.release}(ptr)`);
+                return { retain: `@${runtime.retain}`, release: `@${runtime.release}` };
+            }
             // Emitted per-class helpers are already `_v`-shaped (ptr → ptr /
             // ptr → void), so the same symbols serve as container entry points.
             return {
                 retain: `@${mangleClassRetain(t.className)}`,
                 release: `@${mangleClassRelease(t.className)}`,
             };
+        }
         default:
             throw new LlvmUnsupportedError(`rc:${t.kind}`);
     }
@@ -57,9 +74,13 @@ export function retainSym(host, t) {
     if (nullable)
         return nullableRetainSym(host, nullable.arm);
     const stem = runtimeRcStem(t);
-    if (host.rcHelpers !== null && stem !== null && inlineRcFamily(stem, "retain") !== null) {
+    if (host.rcHelpers !== null && stem !== null && inlineRcFamily(host, stem, "retain") !== null) {
         return inlineRcSym(host, stem, "retain");
     }
+    // Direct retains keep the emitted helper (vAdapters' runtime adapters
+    // are for capsule and container entry points).
+    if (t.kind === "object" && stem === null)
+        return `@${mangleClassRetain(t.className)}`;
     return vAdapters(host, t).retain;
 }
 /** The retain entry point of a nullable union's value: the arm's own when
@@ -90,7 +111,7 @@ export function releaseSym(host, t) {
     if (nullable)
         return releaseSym(host, nullable.arm);
     const stem = runtimeRcStem(t);
-    if (host.rcHelpers !== null && stem !== null && inlineRcFamily(stem, "release") !== null) {
+    if (host.rcHelpers !== null && stem !== null && inlineRcFamily(host, stem, "release") !== null) {
         return inlineRcSym(host, stem, "release");
     }
     if (stem !== null) {
@@ -117,8 +138,11 @@ export function releaseSym(host, t) {
  * collector's on_dead bookkeeping) stays in the runtime release, which
  * repeats its own checks, so the fast path never duplicates it.
  *
+ * The dyn release buffers a surviving value by kind (scr_dyn_release):
+ * the fast path decides the always and never cases and calls
+ * scr_dyn_release_survivor for kinds whose candidacy is per value.
+ *
  * Releases stay plain calls for:
- * - dyn: scr_dyn_release buffers a surviving object only for some kinds.
  * - arr: array releases are the most numerous release sites and the
  *   least hot (at most 1% self time across the benchmark suite), and
  *   inlining them roughly doubled the code growth for no measured speedup.
@@ -135,16 +159,31 @@ export const INLINE_RC_FAMILIES = {
     promise: { cycle: "always", retainNull: true, release: "scr_promise_release" },
     classobj: { cycle: "always", retainNull: true, release: "scr_classobj_release" },
     box: { cycle: "always", retainNull: false, release: "scr_box_release" },
-    dyn: { cycle: "always", retainNull: false, release: null },
+    dyn: { cycle: "always", retainNull: false, release: "scr_dyn_release" },
 };
 /** The mirrored family for an RC operation on a runtime stem (`scr_str`),
  * or null when it stays a call. */
-export function inlineRcFamily(stem, op) {
-    return mirroredFamily(stem.replace(/^scr_/, ""), op);
+export function inlineRcFamily(host, stem, op) {
+    return mirroredFamily(host, stem.replace(/^scr_/, ""), op);
+}
+const RELEASE_RC_OPS = new Set(["str:retain", "dyn:retain", "dyn:release"]);
+/** The emitter's inline RC option for a native optimization posture: none
+ * at `dev`, the `release` subset by default. Sanitized builds compile the
+ * whole program in one AddressSanitizer pass, whose time grows with every
+ * inlined fast path, so they call the same helpers out of line. */
+export function inlineRcOption(optimization, sanitize = false) {
+    if (optimization === "dev")
+        return {};
+    return {
+        inlineRc: optimization === "speed" ? "speed" : "release",
+        ...(sanitize ? { rcHelpersNoinline: true } : {}),
+    };
 }
-function mirroredFamily(family, op) {
+function mirroredFamily(host, family, op) {
     if (!Object.hasOwn(INLINE_RC_FAMILIES, family))
         return null;
+    if (host.rcMode !== "speed" && !RELEASE_RC_OPS.has(`${family}:${op}`))
+        return null;
     const row = INLINE_RC_FAMILIES[family];
     return op === "retain" || row.release !== null ? row : null;
 }
@@ -156,7 +195,7 @@ function inlineRcSym(host, stem, op) {
 /** The release call target for a capture box: scr_box_release's fast path,
  * or scr_box_release itself without inline RC. */
 export function boxReleaseSym(host) {
-    if (host.rcHelpers === null) {
+    if (host.rcHelpers === null || mirroredFamily(host, "box", "release") === null) {
         host.declare(`declare void @scr_box_release(ptr)`);
         return "@scr_box_release";
     }
@@ -165,7 +204,7 @@ export function boxReleaseSym(host) {
 /** Record the helper and declare the runtime symbols it calls now, so they
  * land in the extern block. */
 function requestRcHelper(host, family, op) {
-    if (host.rcHelpers === null || mirroredFamily(family, op) === null) {
+    if (host.rcHelpers === null || mirroredFamily(host, family, op) === null) {
         throw new LlvmUnsupportedError(`inline rc:${family}:${op}`);
     }
     host.rcHelpers.add(`${family}:${op}`);
@@ -173,9 +212,67 @@ function requestRcHelper(host, family, op) {
         host.declare(decl);
     return `@${inlineRcName(family, op)}`;
 }
+function rcHelperAttrs(host) {
+    return host.rcHelpersNoinline === true ? `noinline ${FN_ATTRS}` : FN_ATTRS;
+}
 function inlineRcName(family, op) {
     return `sc_rc_${op}_${family}`;
 }
+/** Inlined dyn releases one function body keeps. LLVM's optimization time
+ * grows faster than the number of inlined releases in one function, and
+ * generated dispatch tables and module initializers of large packages have
+ * thousands of release sites; a body with more calls scr_dyn_release, which
+ * the inline helper mirrors, at every site. */
+export const INLINE_DYN_RELEASES_PER_FUNCTION = 256;
+/** Apply {@link INLINE_DYN_RELEASES_PER_FUNCTION} to each function of an
+ * emitted module, given as parts joined by newlines. A function can span
+ * parts (main's lines) and a part can hold several functions. */
+export function limitInlineDynReleases(parts) {
+    const call = `call void @${inlineRcName("dyn", "release")}(`;
+    const runtime = `call void @${INLINE_RC_FAMILIES["dyn"].release}(`;
+    // The function each release site belongs to: the last `define` line
+    // before it, counted over the joined text.
+    const sites = (part, each, first) => {
+        let fn = first;
+        let define = part.startsWith("define ") ? 0 : part.indexOf("\ndefine ");
+        for (let at = part.indexOf(call); at >= 0; at = part.indexOf(call, at + call.length)) {
+            while (define >= 0 && define < at) {
+                fn++;
+                define = part.indexOf("\ndefine ", define + 1);
+            }
+            each(at, fn);
+        }
+        while (define >= 0) {
+            fn++;
+            define = part.indexOf("\ndefine ", define + 1);
+        }
+        return fn;
+    };
+    const counts = new Map();
+    let fn = 0;
+    for (const part of parts)
+        fn = sites(part, (_, f) => counts.set(f, (counts.get(f) ?? 0) + 1), fn);
+    const over = new Set([...counts].filter(([, n]) => n > INLINE_DYN_RELEASES_PER_FUNCTION).map(([f]) => f));
+    if (over.size === 0)
+        return [...parts];
+    fn = 0;
+    return parts.map((part) => {
+        const cuts = [];
+        fn = sites(part, (at, f) => {
+            if (over.has(f))
+                cuts.push(at);
+        }, fn);
+        if (cuts.length === 0)
+            return part;
+        let out = "";
+        let from = 0;
+        for (const at of cuts) {
+            out += part.slice(from, at) + runtime;
+            from = at + call.length;
+        }
+        return out + part.slice(from);
+    });
+}
 function rcHelperDecls(family, op) {
     const row = INLINE_RC_FAMILIES[family];
     if (op === "retain" || row.release === null)
@@ -183,6 +280,7 @@ function rcHelperDecls(family, op) {
     return [
         `declare void @${row.release}(ptr)`,
         ...(row.cycle === "always" ? [`declare void @scr_cyc_on_release(ptr)`] : []),
+        ...(family === "dyn" ? [`declare void @scr_dyn_release_survivor(ptr)`] : []),
     ];
 }
 /** The runtime declarations the requested helpers call (deduplicated). */
@@ -230,7 +328,7 @@ function rcHeaderTest(cycle, yes, no) {
 function retainHelper(host, family, row) {
     const S = host.sizeType;
     return [
-        `define internal ptr @${inlineRcName(family, "retain")}(ptr %o) ${FN_ATTRS} { ; scr_${family}_retain fast path`,
+        `define internal ptr @${inlineRcName(family, "retain")}(ptr %o) ${rcHelperAttrs(host)} { ; scr_${family}_retain fast path`,
         `entry:`,
         ...(row.retainNull
             ? [`  %isnull = icmp eq ptr %o, null`, `  br i1 %isnull, label %done, label %check`, `check:`]
@@ -252,7 +350,7 @@ function releaseHelper(host, family, row) {
     const S = host.sizeType;
     const cycle = row.cycle;
     return [
-        `define internal void @${inlineRcName(family, "release")}(ptr %o) ${FN_ATTRS} { ; ${row.release} fast path`,
+        `define internal void @${inlineRcName(family, "release")}(ptr %o) ${rcHelperAttrs(host)} { ; ${row.release} fast path`,
         `entry:`,
         `  %isnull = icmp eq ptr %o, null`,
         `  br i1 %isnull, label %done, label %check`,
@@ -285,23 +383,37 @@ function releaseHelper(host, family, row) {
                 `  br i1 %untraced, label %done, label %root`,
                 `root:`,
             ]
-            : family === "box"
+            : family === "dyn"
                 ? [
-                    // scr_box_release buffers a surviving box only when its trace
-                    // visits the payload (scr_box_traced): a closure (kind 4), or a
-                    // class instance whose obj_trace is set.
-                    `  %kp = getelementptr i8, ptr %o, ${S} ${S === "i64" ? 8 : 4} ; ScrBox.kind`,
+                    // scr_dyn_release buffers a surviving value by kind: always for
+                    // arrays, objects, functions and proxies, per value for capsules
+                    // and handles (scr_dyn_release_survivor), never for scalars.
+                    `  %kp = getelementptr i8, ptr %o, ${S} ${S === "i64" ? 8 : 4} ; ScrDyn.kind`,
                     `  %kind = load i32, ptr %kp`,
-                    `  %func = icmp eq i32 %kind, 4`,
-                    `  br i1 %func, label %root, label %objbox`,
-                    `objbox:`,
-                    `  %otp = getelementptr i8, ptr %o, ${S} ${S === "i64" ? 32 : 16} ; ScrBox.obj_trace`,
-                    `  %ot = load ptr, ptr %otp`,
-                    `  %untraced = icmp eq ptr %ot, null`,
-                    `  br i1 %untraced, label %done, label %root`,
+                    // SCR_DYN_ARR 4, OBJ 5, FUNC 8, PROXY 13; HANDLE 9, TYPED_REF 12.
+                    `  switch i32 %kind, label %done [ i32 4, label %root i32 5, label %root i32 8, label %root i32 13, label %root i32 9, label %survivor i32 12, label %survivor ]`,
+                    `survivor:`,
+                    `  call void @scr_dyn_release_survivor(ptr %o)`,
+                    `  br label %done`,
                     `root:`,
                 ]
-                : []),
+                : family === "box"
+                    ? [
+                        // scr_box_release buffers a surviving box only when its trace
+                        // visits the payload (scr_box_traced): a closure (kind 4), or a
+                        // class instance whose obj_trace is set.
+                        `  %kp = getelementptr i8, ptr %o, ${S} ${S === "i64" ? 8 : 4} ; ScrBox.kind`,
+                        `  %kind = load i32, ptr %kp`,
+                        `  %func = icmp eq i32 %kind, 4`,
+                        `  br i1 %func, label %root, label %objbox`,
+                        `objbox:`,
+                        `  %otp = getelementptr i8, ptr %o, ${S} ${S === "i64" ? 32 : 16} ; ScrBox.obj_trace`,
+                        `  %ot = load ptr, ptr %otp`,
+                        `  %untraced = icmp eq ptr %ot, null`,
+                        `  br i1 %untraced, label %done, label %root`,
+                        `root:`,
+                    ]
+                    : []),
         ...(cycle === "always" ? cycleRootLines(host, "done") : [`  br label %done`]),
         `done:`,
         `  ret void`,
@@ -382,6 +494,10 @@ export function traceAdapter(host, t) {
                 host.declare(`declare void @scr_stream_trace(ptr, ptr, ptr)`);
                 return "@scr_stream_trace";
             }
+            // The EventTarget and Event bases have no instances of their own:
+            // values of subclasses trace through their own classes' entries.
+            if (t.className === RUNTIME_EVENT_TARGET_CLASS || t.className === RUNTIME_EVENT_CLASS)
+                return null;
             return `@${mangleClassTrace(t.className)}`;
         case "map":
             if (traceAdapter(host, t.key) === null && traceAdapter(host, t.value) === null)
@@ -452,7 +568,10 @@ function elemKindNum(elem) {
  * SCR_ELEM_ARR spelling would hide them from the outer array's trace)
  * construct through scr_arr_new_ops with the element type's `_v` RC entry
  * points; every other element kind keeps the plain scr_arr_new call. */
-export function arrNewCall(host, elem, capText) {
+export function arrNewCall(host, elem, capText, 
+/** An empty array expected to receive a few elements (its first slots
+ * live in its own block): capText must be "0". */
+small = false) {
     const useRef = elem.kind === "record" ||
         elem.kind === "object" ||
         elem.kind === "union" ||
@@ -469,9 +588,17 @@ export function arrNewCall(host, elem, capText) {
         elem.kind === "regex" || // RegExp values: scr_regex_* adapters, no trace (no refs inside)
         (elem.kind === "array" && traceAdapter(host, elem) !== null);
     if (!useRef) {
+        if (small) {
+            host.declare(`declare ptr @scr_arr_new_small(i32)`);
+            return `call ptr @scr_arr_new_small(i32 ${elemKindNum(elem)})`;
+        }
         host.declare(`declare ptr @scr_arr_new(i32, ${host.sizeType})`);
         return `call ptr @scr_arr_new(i32 ${elemKindNum(elem)}, ${host.sizeType} ${capText})`;
     }
+    if (small) {
+        host.declare(`declare ptr @scr_arr_new_ops_small(ptr)`);
+        return `call ptr @scr_arr_new_ops_small(ptr ${arrOps(host, elem)})`;
+    }
     host.declare(`declare ptr @scr_arr_new_ops(ptr, ${host.sizeType})`);
     return `call ptr @scr_arr_new_ops(ptr ${arrOps(host, elem)}, ${host.sizeType} ${capText})`;
 }
@@ -525,8 +652,11 @@ export function boxAccess(t) {
 }
 /* ── record shapes ────────────────────────────────────────────────────── */
 /** A record field's in-struct LLVM type. bool fields store as i8 (the C
- * _Bool layout); loads/stores convert at the access site. */
-export function llFieldType(t) {
+ * _Bool layout); loads/stores convert at the access site. An `inline`
+ * scalar-union field stores its tag and bits (inline-unions.ts). */
+export function llFieldType(t, inline) {
+    if (inline)
+        return INLINE_UNION_FIELD;
     if (POINTER_KINDS.has(t.kind))
         return "ptr";
     switch (t.kind) {
@@ -540,6 +670,23 @@ export function llFieldType(t) {
             throw new LlvmUnsupportedError(`type:${t.kind}`);
     }
 }
+/** Loads a struct field slot for helper code: i8 bools truncate to i1, and
+ * an inline union field lends a private stack box with the slot's own
+ * bits (ABSENT included). */
+export function loadStructField(B, sizeType, ptr, t, inline) {
+    if (inline) {
+        const { tag, bits } = loadInlineUnion(B, ptr);
+        return stackUnionBox(B, sizeType, tag, bits);
+    }
+    const fieldTy = llFieldType(t, false);
+    const raw = B.tmp();
+    B.line(`${raw} = load ${fieldTy}, ptr ${ptr}`);
+    if (fieldTy !== "i8")
+        return raw;
+    const b = B.tmp();
+    B.line(`${b} = trunc i8 ${raw} to i1`);
+    return b;
+}
 /** The key's calling convention is independent of equality: bigint and
  * union payloads travel by reference but compare by JavaScript value. */
 export function mapKeyAccess(key) {
@@ -582,12 +729,13 @@ export function mapKeyKindNum(key, unionArms) {
 export function mapValKindNum(value) {
     return value.kind === "f64" ? 0 : value.kind === "bool" ? 1 : 2;
 }
-/** The RC-relevant members of a shape: every field, plus the overflow map
- * on index-signature shapes (one more map-typed member). `index` is the
- * member's field position in the emitted struct type (rc header at 0). */
-function rcMembers(shape) {
+/** The RC-relevant members of a shape: every field except inline scalar
+ * unions, plus the overflow map on index-signature shapes (one more
+ * map-typed member). `index` is the member's field position in the
+ * emitted struct type (rc header at 0). */
+export function rcMembers(shape, inline) {
     return [
-        ...shape.fields.map((f, i) => ({ index: i + 1, type: f.type, name: f.name })),
+        ...shape.fields.flatMap((f, i) => inline.record(f.type) ? [] : [{ index: i + 1, type: f.type, name: f.name }]),
         ...(shape.indexValue
             ? [
                 {
@@ -605,7 +753,7 @@ function rcMembers(shape) {
 export function retainBody(host, fnName, comment = "", immortal = false) {
     const S = host.sizeType;
     if (immortal)
-        return immortalRcBody(fnName, "ptr", comment);
+        return immortalRcBody(host, fnName, "ptr", comment);
     return [
         `define internal ptr @${fnName}(ptr %o) ${FN_ATTRS} {${comment ? ` ; ${comment}` : ""}`,
         `entry:`,
@@ -627,8 +775,12 @@ export function retainBody(host, fnName, comment = "", immortal = false) {
 /** The retain or release entry point of a class whose every instance lives
  * until the process exits (no collector header; see classes.ts
  * programLifetimeClass and programLifetimeRc): nothing to count, so every
- * inlined call site folds away. */
-function immortalRcBody(fnName, ret, comment) {
+ * inlined call site folds away. Programs with lifetime regions count the
+ * references in the instance's region chunk instead (llvm/regions.ts). */
+function immortalRcBody(host, fnName, ret, comment) {
+    const regions = host.regions ?? null;
+    if (regions !== null)
+        return regions.rcBody(fnName, ret, comment);
     return [
         `define internal ${ret} @${fnName}(ptr %o) ${FN_ATTRS} {${comment ? ` ; ${comment} (immortal)` : ""}`,
         `entry:`,
@@ -673,7 +825,7 @@ export function directChildReleaseLines(host, tag, value, target, comment) {
     ];
     if (target.traced) {
         host.declare(`declare void @scr_cyc_on_dead(ptr)`);
-        lines.push(`  %${tag}.bufp = getelementptr i8, ptr ${value}, ${S} -${host.cycleBufferedOffset}`, `  %${tag}.buf = load i16, ptr %${tag}.bufp`, `  %${tag}.queued = icmp ne i16 %${tag}.buf, 0`, `  br i1 %${tag}.queued, label %${tag}.unbuffer, label %${tag}.teardown`, `${tag}.unbuffer:`, `  call void @scr_cyc_on_dead(ptr ${value})`, `  br label %${tag}.teardown`, `${tag}.teardown:`);
+        lines.push(`  %${tag}.bufp = getelementptr i8, ptr ${value}, ${S} -${host.cycleBufOffset}`, `  %${tag}.buf = load i32, ptr %${tag}.bufp`, `  %${tag}.queued = icmp slt i32 %${tag}.buf, 0`, `  br i1 %${tag}.queued, label %${tag}.unbuffer, label %${tag}.teardown`, `${tag}.unbuffer:`, `  call void @scr_cyc_on_dead(ptr ${value})`, `  br label %${tag}.teardown`, `${tag}.teardown:`);
     }
     lines.push(`  %${tag}.short = icmp ult i32 %d, ${DIRECT_DESTROY_CHAIN}`, `  br i1 %${tag}.short, label %${tag}.direct, label %${tag}.bounded`, `${tag}.direct:`, `  %${tag}.d = add i32 %d, 1`, `  call void @${target.destroy}_d(ptr ${value}, i32 %${tag}.d)`, `  br label %${tag}.next`, `${tag}.bounded:`, `  call void @scr_rc_destroy(ptr ${value}, ptr @${target.destroy})`, `  br label %${tag}.next`, `${tag}.next:`);
     return lines;
@@ -779,7 +931,7 @@ export function releaseBody(host, fnName, traced, freeBody, comment = "", bounde
 export function releaseFastPath(host, fnName, slow, traced, comment = "", immortal = false) {
     const S = host.sizeType;
     if (immortal)
-        return immortalRcBody(fnName, "void", comment);
+        return immortalRcBody(host, fnName, "void", comment);
     return [
         `define internal void @${fnName}(ptr %o) ${FN_ATTRS} {${comment ? ` ; ${comment} (fast path)` : ""}`,
         `entry:`,
@@ -809,9 +961,9 @@ export function releaseFastPath(host, fnName, slow, traced, comment = "", immort
     ];
 }
 /** The possible-cycle-root step of a release that left a headered object
- * alive: scr_cyc_on_release with its early return inlined. Read `buffered`
- * (the i16 at obj-6; nonzero for a queued candidate or a
- * tenured object) and call the runtime only to enqueue a new candidate.
+ * alive: scr_cyc_on_release with its early return inlined. Test the sign
+ * of `buf` (the i32 at obj-4; negative for a queued candidate or a tenured
+ * object) and call the runtime only to enqueue a new candidate.
  * Every emitted release of a headered object shares this sequence
  * (scr_runtime.h asserts the offset); it ends by branching to `done`. */
 /** One traced field of an emitted trace function: load the slot and visit
@@ -835,9 +987,9 @@ export function cycleRootLines(host, done) {
     const S = host.sizeType;
     host.declare(`declare void @scr_cyc_on_release(ptr)`);
     return [
-        `  %bufp = getelementptr i8, ptr %o, ${S} -${host.cycleBufferedOffset}`,
-        `  %buf = load i16, ptr %bufp`,
-        `  %queued = icmp ne i16 %buf, 0`,
+        `  %bufp = getelementptr i8, ptr %o, ${S} -${host.cycleBufOffset}`,
+        `  %buf = load i32, ptr %bufp`,
+        `  %queued = icmp slt i32 %buf, 0`,
         `  br i1 %queued, label %${done}, label %enqueue`,
         `enqueue:`,
         `  call void @scr_cyc_on_release(ptr %o) ; buffer the candidate; may collect`,
@@ -852,9 +1004,9 @@ export function cycleDeadLines(host, next) {
     const S = host.sizeType;
     host.declare(`declare void @scr_cyc_on_dead(ptr)`);
     return [
-        `  %dbufp = getelementptr i8, ptr %o, ${S} -${host.cycleBufferedOffset}`,
-        `  %dbuf = load i16, ptr %dbufp`,
-        `  %dqueued = icmp ne i16 %dbuf, 0`,
+        `  %dbufp = getelementptr i8, ptr %o, ${S} -${host.cycleBufOffset}`,
+        `  %dbuf = load i32, ptr %dbufp`,
+        `  %dqueued = icmp slt i32 %dbuf, 0`,
         `  br i1 %dqueued, label %unbuffer, label %${next}`,
         `unbuffer:`,
         `  call void @scr_cyc_on_dead(ptr %o)`,
@@ -881,7 +1033,7 @@ export function emitRecordShapes(host, mod) {
     }
     for (const shape of records) {
         const struct = mangleRecordStruct(shape.id);
-        const fieldTys = shape.fields.map((f) => llFieldType(f.type));
+        const fieldTys = shape.fields.map((f) => llFieldType(f.type, host.inlineUnions.record(f.type)));
         if (shape.indexValue)
             fieldTys.push("ptr"); // the overflow ScrMap *
         typeDefs.push(`%${struct} = type { ${host.sizeType}${fieldTys.length ? ", " + fieldTys.join(", ") : ""} } ` +
@@ -893,7 +1045,7 @@ export function emitRecordShapes(host, mod) {
     const candidates = [];
     const memberTypes = [];
     for (const shape of records) {
-        const members = rcMembers(shape);
+        const members = rcMembers(shape, host.inlineUnions);
         for (const m of members)
             memberTypes.push(m.type);
         if (!members.some((m) => isRefCounted(m.type) && needsBoundedRelease(m.type)))
@@ -912,7 +1064,7 @@ export function emitRecordShapes(host, mod) {
     for (const shape of records) {
         const struct = mangleRecordStruct(shape.id);
         const traced = host.tracedShapes.has(`record:${shape.id}`);
-        const members = rcMembers(shape);
+        const members = rcMembers(shape, host.inlineUnions);
         const refMembers = members.filter((m) => isRefCounted(m.type));
         const sizeOf = `ptrtoint (ptr getelementptr (%${struct}, ptr null, i32 1) to ${host.sizeType})`;
         defs.push(...retainBody(host, mangleRecordRetain(shape.id)), ``);
@@ -973,10 +1125,12 @@ export function emitRecordShapes(host, mod) {
             let i = 0;
             for (const field of shape.fields) {
                 const index = i + 1;
-                const fieldTy = llFieldType(field.type);
+                const inline = host.inlineUnions.record(field.type);
+                const fieldTy = llFieldType(field.type, inline);
                 clone.push(`  %sp${i} = getelementptr inbounds %${struct}, ptr %src, i64 0, i32 ${index}`, `  %sv${i} = load ${fieldTy}, ptr %sp${i}`);
-                const stored = isRefCounted(field.type) ? `%sr${i}` : `%sv${i}`;
-                if (isRefCounted(field.type)) {
+                const owned = isRefCounted(field.type) && !inline;
+                const stored = owned ? `%sr${i}` : `%sv${i}`;
+                if (owned) {
                     clone.push(`  ${stored} = call ptr ${retainSym(host, field.type)}(ptr %sv${i})`);
                 }
                 clone.push(`  %dp${i} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${index}`, `  store ${fieldTy} ${stored}, ptr %dp${i} ; ${llvmCommentText(field.name)}`);