@scriptc/compiler 0.4.1 → 0.4.3

package/dist/backend/llvm/shapes.js

@@ -1,6 +1,6 @@
 import { isIdentityCollectionKey, isRefCounted, mapOf, POINTER_KINDS, runtimeRcStem, RUNTIME_EMITTER_CLASS, RUNTIME_EVENT_CLASS, RUNTIME_EVENT_TARGET_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, DYN, STRING, } from "../../ir/ir.js";
 import { mangleClassRelease, mangleClassRetain, mangleClassTrace, mangleRecordGcFree, mangleRecordClone, mangleRecordNew, mangleRecordRelease, mangleRecordRetain, mangleRecordStruct, mangleRecordTrace, } from "../mangle.js";
-import { CYC_HDR, cycTypeDescriptor, emitObjectAlloc, emitObjectFree, CYC_APPEND, cycleAppendDecls, cycleAppendHelper, inlineBufferingSupported, } from "./alloc.js";
+import { CYC_HDR, cycTypeDescriptor, emitObjectAlloc, emitObjectFree, emitSegmentFree, CYC_APPEND, cycleAppendDecls, cycleAppendHelper, inlineBufferingSupported, } from "./alloc.js";
 import { SCR_ARR_FIELD, llvmCommentText } from "./common.js";
 import { NULLABLE_NULL, SHAPE_WORD_INDEX, shapeReleaseFn, shapeTagFn, shapeTraceFn, shapeWordHeader, } from "./nullable-unions.js";
 import { INLINE_UNION_FIELD, loadInlineUnion, stackUnionBox, } from "./inline-unions.js";
@@ -210,6 +210,7 @@ function nullableRetainSym(host, arm) {
     const sym = `@sc_nretain_${arm.kind}`;
     if (!host.nullableUnions.retainWrappers.has(sym))
         host.nullableUnions.retainWrappers.set(sym, retainSym(host, arm));
+    host.journalEntry?.("retainWrapper", sym, host.nullableUnions.retainWrappers.get(sym));
     return sym;
 }
 /** Definitions of the requested NULL-skipping retain wrappers. */
@@ -354,6 +355,8 @@ export function inlineRcFamily(host, stem, op) {
 }
 const RELEASE_RC_OPS = new Set([
     "str:retain",
+    "str:release",
+    "map:retain",
     "dyn:retain",
     "dyn:release",
     "js:retain",
@@ -428,12 +431,25 @@ function inlineRcName(family, op) {
  * 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}(`;
+/** Inlined string releases one function body keeps in `release` emission,
+ * which inlines string releases (RELEASE_RC_OPS); the bodies with the most of them, such as
+ * builders of string-heavy records and module initializers, would grow the
+ * most for the least gain, so a body with more calls scr_str_release at
+ * every site. */
+export const INLINE_STR_RELEASES_PER_FUNCTION = 8;
+/** Apply {@link INLINE_DYN_RELEASES_PER_FUNCTION}, and in `release` emission
+ * {@link INLINE_STR_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 limitInlineReleases(parts, mode) {
+    const dyn = limitInlineReleaseFamily(parts, "dyn", INLINE_DYN_RELEASES_PER_FUNCTION);
+    return mode === "release"
+        ? limitInlineReleaseFamily(dyn, "str", INLINE_STR_RELEASES_PER_FUNCTION)
+        : dyn;
+}
+function limitInlineReleaseFamily(parts, family, max) {
+    const call = `call void @${inlineRcName(family, "release")}(`;
+    const runtime = `call void @${INLINE_RC_FAMILIES[family].release}(`;
     // The function each release site belongs to: the last `define` line
     // before it, counted over the joined text.
     const sites = (part, each, first) => {
@@ -456,7 +472,7 @@ export function limitInlineDynReleases(parts) {
     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));
+    const over = new Set([...counts].filter(([, n]) => n > max).map(([f]) => f));
     if (over.size === 0)
         return [...parts];
     fn = 0;
@@ -829,16 +845,35 @@ small = false) {
     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})`;
 }
-/** The constant %ScrArrOps descriptor (retain, release, trace) of a REF
- * element type, defined once per module and shared by all its arrays. */
+/** The %ScrArrOps descriptor (retain, release, trace, registry id) of a REF
+ * element type, defined once per module and shared by all its arrays. It is
+ * writable: the runtime stores its registry id on the first array. Its tail
+ * padding is the runtime's flags word (0); arrays of compact class
+ * references (ShapeHost.compactArrayElem) spell the word out as
+ * SCR_ARR_OPS_COMPACT, and on 64-bit targets arrays whose element release
+ * does nothing (ShapeHost.releasesNothing) as SCR_ARR_OPS_RELEASE_NOTHING,
+ * so that destroying them only frees their storage. */
 export function arrOps(host, elem) {
     const v = vAdapters(host, elem);
     const trace = traceArg(host, elem);
     const part = (sym) => sym.replace(/^@/, "").replace(/[^A-Za-z0-9_.]/g, "_");
     const name = `@sc_arrops.${part(v.retain)}.${part(v.release)}.${part(trace)}`;
-    host.declare(`${name} = internal constant %ScrArrOps { ptr ${v.retain}, ptr ${v.release}, ptr ${trace} }`);
+    if (host.compactArrayElem?.(elem) === true) {
+        host.declare(`${name}.c = internal global { ptr, ptr, ptr, i32, i32 } { ptr ${v.retain}, ptr ${v.release}, ptr ${trace}, i32 0, i32 ${SCR_ARR_OPS_COMPACT} }`);
+        return `${name}.c`;
+    }
+    const nullable = host.nullableUnions.of(elem);
+    const payload = nullable?.repr === "single" ? nullable.arm : elem;
+    if (host.sizeType === "i64" && host.releasesNothing?.(payload) === true) {
+        host.declare(`${name}.n = internal global { ptr, ptr, ptr, i32, i32 } { ptr ${v.retain}, ptr ${v.release}, ptr ${trace}, i32 0, i32 ${SCR_ARR_OPS_RELEASE_NOTHING} }`);
+        return `${name}.n`;
+    }
+    host.declare(`${name} = internal global %ScrArrOps { ptr ${v.retain}, ptr ${v.release}, ptr ${trace}, i32 0 }`);
     return name;
 }
+/** scr_array.h SCR_ARR_OPS_COMPACT and SCR_ARR_OPS_RELEASE_NOTHING. */
+const SCR_ARR_OPS_COMPACT = 1;
+const SCR_ARR_OPS_RELEASE_NOTHING = 2;
 /* ── capture boxes ────────────────────────────────────────────────────── */
 /** Box construction call text (boxNewC's dispatch): plain-kind boxes for
  * the runtime-known payloads, obj-kind boxes (RC entry points + trace as
@@ -1040,11 +1075,18 @@ export const DIRECT_DESTROY_CHAIN = 16;
 /** The release of child `value` (a loaded field, possibly NULL) inside a
  * teardown whose chain length is `%d`: the child's own release for a shared
  * or immortal reference, its teardown for the last one. Labels use `tag`;
- * the lines end in the open block `${tag}.next`. */
-export function directChildReleaseLines(host, tag, value, target, comment) {
+ * the lines end in the open block `${tag}.next`.
+ *
+ * With `segment` (the child has the teardown's own type, in a segmented
+ * teardown; segmentPrologueLines), the child's teardown appends its blocks
+ * to the teardown's segment. */
+export function directChildReleaseLines(host, tag, value, target, comment, segment = false) {
     const S = host.sizeType;
     const C = target.count ?? S;
-    host.declare(`declare void @scr_rc_destroy(ptr, ptr)`);
+    if (segment)
+        host.declare(`declare ptr @scr_rc_destroy_seg(ptr, ptr, ptr, ptr)`);
+    else
+        host.declare(`declare void @scr_rc_destroy(ptr, ptr)`);
     const lines = [
         `  %${tag}.nn = icmp ne ptr ${value}, null`,
         `  br i1 %${tag}.nn, label %${tag}.chk, label %${tag}.next`,
@@ -1060,11 +1102,87 @@ 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.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}.bufp = getelementptr i8, ptr ${value}, ${S} -${host.cycleBufOffset}`, `  %${tag}.buf = load i32, ptr %${tag}.bufp`, `  %${tag}.queued = icmp slt i32 %${tag}.buf, -1 ; buffered, not SCR_CYC_ACYCLIC`, `  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:`);
+    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`);
+    if (!segment) {
+        lines.push(`  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;
+    }
+    lines.push(`  %${tag}.t = load ptr, ptr %sg.t`, `  %${tag}.dt = call ptr @${target.destroy}_s(ptr ${value}, i32 %${tag}.d, ptr %${tag}.t)`, `  store ptr %${tag}.dt, ptr %sg.t`, `  br label %${tag}.next`, `${tag}.bounded:`, `  %${tag}.bt = load ptr, ptr %sg.t`, `  %${tag}.rt = call ptr @scr_rc_destroy_seg(ptr ${value}, ptr @${target.destroy}_sc, ptr @${target.destroy}, ptr %${tag}.bt)`, `  store ptr %${tag}.rt, ptr %sg.t`, `  br label %${tag}.next`, `${tag}.next:`);
     return lines;
 }
+/* Teardown segments. A typed teardown that frees each block onto its free
+ * list as it goes frees a tree in walk order, and the free lists, which are
+ * LIFO, hand the blocks to the next allocations in the reverse order: a tree
+ * built again in the same order as the last (each generation of a structure
+ * a loop rebuilds) is laid out mirrored, and every walk over it, the next
+ * teardown included, runs through memory backwards, which defeats the
+ * hardware prefetchers. The runtime frees large dead sets of the cycle
+ * collector in address order for the same reason (scr_mem_order_for_free).
+ *
+ * So the teardown of a type with children of its own type (the `_s` form,
+ * segmentedTeardown) keeps the blocks it frees in a segment, linked through
+ * their first words, which it builds in order through a tail pointer: the
+ * `_s` form takes the segment's last link (the first word of its last block,
+ * or the head slot of an empty segment) and returns the new one. A node
+ * first releases its own block (emitObjectFree, keeping it), then appends it
+ * ahead of its children's blocks when its address is the lower, behind them
+ * otherwise (segmentTeardownLines), and the children append theirs in field
+ * order, so a structure
+ * built parent first (object literals allocate before their fields) or
+ * children first (constructor arguments) comes back in ascending order. The
+ * chain's first teardown (`_d`) frees the whole segment onto the class's
+ * free list in one step (emitSegmentFree), and the walks over the next
+ * generation run forward. A teardown past DIRECT_DESTROY_CHAIN appends
+ * through scr_rc_destroy_seg, under the same depth budget as
+ * scr_rc_destroy. Blocks outside the calling thread's arena are freed as
+ * before; one type's blocks are all of one class. */
+/** Whether the teardown of a type whose reference fields have `fieldTypes`
+ * (with direct targets `targets`) and whose own teardown is `destroy` keeps
+ * a segment: a child field has its own type, and the inline allocation paths
+ * are in use. */
+export function segmentedTeardown(host, destroy, fieldTypes, targets) {
+    if (host.inlineAlloc !== true)
+        return false;
+    return fieldTypes.some((t) => directDestroyTarget(host, t, targets)?.destroy === destroy);
+}
+/** The first lines of a segmented teardown, in its entry block: the
+ * segment's last link (`%sg.t`, from the `%tail` argument) and the kept own
+ * block (`%sg.own`, for emitObjectFree). */
+export function segmentPrologueLines() {
+    return [
+        `  %sg.t = alloca ptr`,
+        `  %sg.own = alloca ptr`,
+        `  store ptr %tail, ptr %sg.t`,
+        `  store ptr null, ptr %sg.own`,
+    ];
+}
+/** The rest of a segmented teardown after emitObjectFree kept (or freed)
+ * its own block: the block goes ahead of its children's when its address is
+ * below the first non-NULL one of `children` (loaded fields of the
+ * teardown's own type, which stand for their blocks) or there is none, and
+ * behind them otherwise; then the children's releases (`releases`, given a
+ * label prefix), and the segment's last link is returned. Each order has its
+ * own copy of the releases, so neither keeps the decision, or the block once
+ * it is appended, across the children's teardowns. */
+export function segmentTeardownLines(children, releases) {
+    const lines = [`  %sg.o = load ptr, ptr %sg.own`, `  %sg.kept = icmp ne ptr %sg.o, null`];
+    let ref = "null";
+    [...children].reverse().forEach((child, i) => {
+        lines.push(`  %sg.nn${i} = icmp ne ptr ${child}, null`, `  %sg.r${i} = select i1 %sg.nn${i}, ptr ${child}, ptr ${ref}`);
+        ref = `%sg.r${i}`;
+    });
+    lines.push(`  %sg.leaf = icmp eq ptr ${ref}, null`, `  %sg.lower = icmp ult ptr %sg.o, ${ref}`, `  %sg.first = or i1 %sg.leaf, %sg.lower`, `  %sg.ahead = and i1 %sg.kept, %sg.first`, `  br i1 %sg.ahead, label %sg.front, label %sg.back`, `sg.front:`, ...segmentAppendLines("a"), ...releases("ta"), `  br label %sg.ret`, `sg.back:`, ...releases("tb"), `  %sg.keep = icmp ne ptr %sg.o, null`, `  br i1 %sg.keep, label %sg.last, label %sg.ret`, `sg.last:`, ...segmentAppendLines("l"), `  br label %sg.ret`, `sg.ret:`, `  %sg.tr = load ptr, ptr %sg.t`, `  ret ptr %sg.tr`);
+    return lines;
+}
+function segmentAppendLines(tag) {
+    return [
+        `  %sg.t${tag} = load ptr, ptr %sg.t`,
+        `  store ptr %sg.o, ptr %sg.t${tag}`,
+        `  store ptr %sg.o, ptr %sg.t`,
+    ];
+}
 /** The direct-teardown target of a reference of `type`, if `targets` (keyed
  * `record:<id>` / `object:<class>`) has one. Nullable unions hold the arm's
  * pointer, NULL or an immortal sentinel, which the child release handles. */
@@ -1099,8 +1217,37 @@ export function usedDirectTargets(host, candidates, fieldTypes) {
 }
 /** The teardown definitions for `destroy`: with `chained`, the body takes
  * the chain length `%d` (directChildReleaseLines) and the runtime's
- * one-argument entry starts a chain. */
-export function destroyDefinitions(destroy, body, chained) {
+ * one-argument entry starts a chain. With `segment` (the host, for a
+ * segmented teardown), the body is a segment teardown's
+ * (segmentPrologueLines to segmentTeardownLines), defined as `_s`, with
+ * `_sc` for scr_rc_destroy_seg, and `_d` starts a segment and frees it. */
+export function destroyDefinitions(destroy, body, chained, segment = null) {
+    if (segment !== null)
+        return [
+            `define internal ptr @${destroy}_s(ptr %o, i32 %d, ptr %tail) ${FN_ATTRS} {`,
+            `entry:`,
+            ...body,
+            `}`,
+            `define internal ptr @${destroy}_sc(ptr %o, ptr %tail) ${FN_ATTRS} {`,
+            `entry:`,
+            `  %t = call ptr @${destroy}_s(ptr %o, i32 0, ptr %tail)`,
+            `  ret ptr %t`,
+            `}`,
+            `define internal void @${destroy}_d(ptr %o, i32 %d) ${FN_ATTRS} {`,
+            `entry:`,
+            `  %head = alloca ptr`,
+            `  store ptr null, ptr %head`,
+            `  %last = call ptr @${destroy}_s(ptr %o, i32 %d, ptr %head)`,
+            `  %first = load ptr, ptr %head`,
+            ...emitSegmentFree(segment, "sgf", "%first", "%last"),
+            `  ret void`,
+            `}`,
+            `define internal void @${destroy}(ptr %o) ${FN_ATTRS} {`,
+            `entry:`,
+            `  call void @${destroy}_d(ptr %o, i32 0)`,
+            `  ret void`,
+            `}`,
+        ];
     if (!chained)
         return [
             `define internal void @${destroy}(ptr %o) ${FN_ATTRS} {`,
@@ -1122,6 +1269,15 @@ export function destroyDefinitions(destroy, body, chained) {
         `}`,
     ];
 }
+/** The frozen bit of a freezable record's rc word (scr_rc.h SCR_RC_FROZEN):
+ * bit 62 on 64-bit targets, bit 30 on 32-bit ones. */
+function recordFrozenBit(sizeType) {
+    return 1n << (sizeType === "i64" ? 62n : 30n);
+}
+/** `value` as a signed LLVM integer literal of `sizeType`. */
+function sizeLiteral(sizeType, value) {
+    return BigInt.asIntN(sizeType === "i64" ? 64 : 32, value).toString();
+}
 /** Common NULL/immortal/decrement 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.
@@ -1129,14 +1285,16 @@ export function destroyDefinitions(destroy, body, chained) {
  * `fnName` is only the inlinable fast path (releaseFastPath); the complete
  * release is `${fnName}_slow`, kept out of line so callers that inline the
  * release do not also inline its teardown. */
-export function releaseBody(host, fnName, traced, freeBody, comment = "", bounded = true, immortal = false, chained = false) {
+export function releaseBody(host, fnName, traced, freeBody, comment = "", bounded = true, immortal = false, chained = false, segmented = false, frozen = false) {
     const S = host.sizeType;
     if (bounded)
         host.declare(`declare void @scr_rc_destroy(ptr, ptr)`);
     const destroy = `${fnName}_destroy`;
+    // A freezable record's count is the word without its frozen bit.
+    const notFrozen = sizeLiteral(S, ~recordFrozenBit(S));
     const lines = [
-        ...(bounded ? destroyDefinitions(destroy, freeBody, chained) : []),
-        ...releaseFastPath(host, fnName, `${fnName}_slow`, traced, comment, immortal),
+        ...(bounded ? destroyDefinitions(destroy, freeBody, chained, segmented ? host : null) : []),
+        ...releaseFastPath(host, fnName, `${fnName}_slow`, traced, comment, immortal, S, frozen),
         `define internal void @${fnName}_slow(ptr %o) noinline ${FN_ATTRS} {${comment ? ` ; ${comment}` : ""}`,
         `entry:`,
         `  %isnull = icmp eq ptr %o, null`,
@@ -1148,7 +1306,9 @@ export function releaseBody(host, fnName, traced, freeBody, comment = "", bounde
         `dec:`,
         `  %n = sub ${S} %rc, 1`,
         `  store ${S} %n, ptr %o`,
-        `  %dead = icmp eq ${S} %n, 0`,
+        ...(frozen
+            ? [`  %refs = and ${S} %n, ${notFrozen}`, `  %dead = icmp eq ${S} %refs, 0`]
+            : [`  %dead = icmp eq ${S} %n, 0`]),
         `  br i1 %dead, label %free, label %${traced ? "root" : "done"}`,
         `free:`,
         ...(traced ? cycleDeadLines(host, "teardown") : []),
@@ -1169,10 +1329,14 @@ export function releaseBody(host, fnName, traced, freeBody, comment = "", bounde
  * call `slow`, which
  * holds the complete release: inlining it everywhere would copy teardowns
  * (and their destroy calls) into every caller. */
-export function releaseFastPath(host, fnName, slow, traced, comment = "", immortal = false, count = host.sizeType) {
+export function releaseFastPath(host, fnName, slow, traced, comment = "", immortal = false, count = host.sizeType, frozen = false) {
     const S = count;
     if (immortal)
         return immortalRcBody(host, fnName, "void", comment);
+    // A freezable record compares its count without the frozen bit: an
+    // immortal word's count is then ~FROZEN, which the same compare sends to
+    // `slow`.
+    const notFrozen = ~recordFrozenBit(S);
     return [
         `define internal void @${fnName}(ptr %o) ${FN_ATTRS} {${comment ? ` ; ${comment} (fast path)` : ""}`,
         `entry:`,
@@ -1180,8 +1344,13 @@ export function releaseFastPath(host, fnName, slow, traced, comment = "", immort
         `  br i1 %isnull, label %done, label %check`,
         `check:`,
         `  %rc = load ${S}, ptr %o`,
-        `  %rcm2 = sub ${S} %rc, 2`,
-        `  %shared = icmp ult ${S} %rcm2, -3`,
+        ...(frozen
+            ? [
+                `  %refs = and ${S} %rc, ${sizeLiteral(S, notFrozen)}`,
+                `  %rcm2 = sub ${S} %refs, 2`,
+                `  %shared = icmp ult ${S} %rcm2, ${sizeLiteral(S, notFrozen - 2n)}`,
+            ]
+            : [`  %rcm2 = sub ${S} %rc, 2`, `  %shared = icmp ult ${S} %rcm2, -3`]),
         `  br i1 %shared, label %dec, label %slow`,
         `dec:`,
         `  %n = sub ${S} %rc, 1`,
@@ -1233,8 +1402,9 @@ function requestCycleAppend(host) {
 }
 /** The possible-cycle-root step of a release that left a headered object
  * 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 buffer a new candidate: through the module's
+ * of `buf` (the i32 at obj-4; negative for a queued candidate, a young
+ * object, or an object that is never a candidate, SCR_CYC_ACYCLIC), and
+ * buffer a new candidate: through the module's
  * cycleAppendHelper in optimized builds that support it, through
  * scr_cyc_on_release otherwise. Every emitted release of a headered object
  * shares this sequence (scr_runtime.h asserts the offsets); it ends by
@@ -1256,16 +1426,16 @@ export function cycleRootLines(host, done) {
     ];
 }
 /** The death of a headered object: scr_cyc_on_dead with its early return
- * inlined. Only an object still in a candidate buffer
- * (`buffered` nonzero) has an entry to remove; the sequence continues at
- * the new block `next`. */
+ * inlined. Only an object still in a candidate buffer (`buf` negative and
+ * not SCR_CYC_ACYCLIC, which is -1) has an entry to remove; the sequence
+ * continues at the new block `next`. */
 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.cycleBufOffset}`,
         `  %dbuf = load i32, ptr %dbufp`,
-        `  %dqueued = icmp slt i32 %dbuf, 0`,
+        `  %dqueued = icmp slt i32 %dbuf, -1 ; buffered, not SCR_CYC_ACYCLIC`,
         `  br i1 %dqueued, label %unbuffer, label %${next}`,
         `unbuffer:`,
         `  call void @scr_cyc_on_dead(ptr %o)`,
@@ -1342,21 +1512,42 @@ export function emitRecordShapes(host, mod) {
         // direct children.
         const chained = directTargets.has(`record:${shape.id}`) ||
             refMembers.some((m) => directDestroyTarget(host, m.type, directTargets) !== null);
-        for (const m of refMembers) {
-            freeBody.push(`  %f${t} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${m.index}`, `  %v${t} = load ptr, ptr %f${t}`);
+        const destroy = `${mangleRecordRelease(shape.id)}_destroy`;
+        const bounded = refMembers.some((member) => needsBoundedRelease(member.type));
+        const segmented = bounded &&
+            segmentedTeardown(host, destroy, refMembers.map((m) => m.type), directTargets);
+        // Closed layouts can carry a kept record source (record-sources.ts).
+        const observers = recordMayKeepSource(shape) ? "weak-or-source" : "weak";
+        // A segmented teardown loads its fields, releases its own block, and
+        // then releases the fields (segmentTeardownLines).
+        const loads = [];
+        const ownType = [];
+        const release = (prefix, m, i) => {
             const direct = directDestroyTarget(host, m.type, directTargets);
-            if (direct) {
-                freeBody.push(...directChildReleaseLines(host, `td${t}`, `%v${t}`, direct, llvmCommentText(m.name)));
-            }
-            else {
-                freeBody.push(`  call void ${releaseSym(host, m.type)}(ptr %v${t}) ; ${llvmCommentText(m.name)}`);
+            if (direct === null)
+                return [`  call void ${releaseSym(host, m.type)}(ptr %v${i}) ; ${llvmCommentText(m.name)}`];
+            const own = segmented && direct.destroy === destroy;
+            return directChildReleaseLines(host, `${prefix}${i}`, `%v${i}`, direct, llvmCommentText(m.name), own);
+        };
+        for (const m of refMembers) {
+            const fieldLines = [
+                `  %f${t} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${m.index}`,
+                `  %v${t} = load ptr, ptr %f${t}`,
+            ];
+            if (segmented) {
+                loads.push(...fieldLines);
+                if (directDestroyTarget(host, m.type, directTargets)?.destroy === destroy)
+                    ownType.push(`%v${t}`);
             }
+            else
+                freeBody.push(...fieldLines, ...release("td", m, t));
             t++;
         }
-        // Closed layouts can carry a kept record source (record-sources.ts).
-        const observers = recordMayKeepSource(shape) ? "weak-or-source" : "weak";
-        freeBody.push(...emitObjectFree(host, traced, observers));
-        defs.push(...releaseBody(host, mangleRecordRelease(shape.id), traced, freeBody, "", refMembers.some((member) => needsBoundedRelease(member.type)), false, chained), ``);
+        if (segmented)
+            freeBody.push(...segmentPrologueLines(), ...loads, ...emitObjectFree(host, traced, observers, "%sg.own"), ...segmentTeardownLines(ownType, (prefix) => refMembers.flatMap((m, i) => release(prefix, m, i))));
+        else
+            freeBody.push(...emitObjectFree(host, traced, observers));
+        defs.push(...releaseBody(host, mangleRecordRelease(shape.id), traced, freeBody, "", bounded, false, chained, segmented, shape.freezable === true), ``);
         // new: zeroed allocation (+ the overflow map on index-signature
         // shapes), rc = 1. Traced shapes allocate with the collector header;
         // alloc.ts inlines the allocator fast paths and the alloc note.