@scriptc/compiler 0.4.1 → 0.4.3

package/dist/backend/llvm/classes.js

@@ -4,8 +4,9 @@ import { streamRooted, undefinedArmTag } from "../../ir/analysis.js";
 import { mangleClassGcFree, mangleClassNew, mangleClassObj, mangleClassRelease, mangleClassReleaseDirect, mangleClassRetain, mangleClassStruct, mangleClassTrace, mangleCtorThunk, mangleFunction, mangleGlobal, mangleVtArray, mangleVtInstance, mangleVtStruct, } from "../mangle.js";
 import { cycTypeDescriptor, emitObjectAlloc, emitObjectFree } from "./alloc.js";
 import { llvmCommentText } from "./common.js";
+import { INLINE_UNION_FIELD } from "./inline-unions.js";
 import { NullableRefFields } from "./nullable-fields.js";
-import { cycleRootLines, traceFieldVisitLines, FN_ATTRS, cycleDeadLines, destroyDefinitions, directChildReleaseLines, directDestroyTarget, usedDirectTargets, llFieldType, releaseBody, releaseFastPath, needsBoundedRelease, releaseSym, retainBody, traceAdapter, youngEntryLines, } from "./shapes.js";
+import { cycleRootLines, traceFieldVisitLines, FN_ATTRS, cycleDeadLines, destroyDefinitions, directChildReleaseLines, directDestroyTarget, segmentPrologueLines, segmentTeardownLines, segmentedTeardown, usedDirectTargets, llFieldType, releaseBody, releaseFastPath, needsBoundedRelease, releaseSym, retainBody, traceAdapter, youngEntryLines, } from "./shapes.js";
 /** Per-class node of the class graph. */
 export class LlClassMeta {
     def;
@@ -30,6 +31,19 @@ export class LlClassMeta {
      * bits, and the hierarchy's vtables are one array indexed by the id
      * (mangleVtArray). */
     idInRc = false;
+    /** A ProgramLifetime class with the 32-bit header (assignCompactLayouts):
+     * the i32 at offset 0 is compactHeaderWord, with the class id in place of
+     * the rc word's high half, and the fields are packed after it. */
+    compact = false;
+    /** Compact classes: the struct's elements by offset (the header, field
+     * -1, then the fields by their index in def.fields). */
+    compactElems = [];
+    /** Compact classes: each field's GEP index, by its index in def.fields. */
+    compactSlots = [];
+    /** Compact classes: whether each field (by its index in def.fields) holds
+     * a compact class instance as a 32-bit index (COMPACT_REF) rather than a
+     * pointer: compactRefLoadLines decodes it, compactRefStoreLines encodes it. */
+    compressed = [];
     constructor(def) {
         this.def = def;
         this.root = this;
@@ -276,6 +290,8 @@ export function classSlotWordIndex(meta) {
 /** The GEP index where a class's own fields start: after the header words
  * and the slot word. */
 export function classFieldBase(meta) {
+    if (meta.compact)
+        throw new InternalCompilerError(`llvm emitter bug: compact class ${meta.def.name} packs its fields`);
     return headerEnd(meta) + (meta.threadSlot ? 1 : 0);
 }
 /** Append the lexical environment after inherited fields to preserve base layouts. */
@@ -284,11 +300,20 @@ export function classEnvironmentIndex(meta) {
 }
 /** A field's GEP index inside its class struct: rc at 0, the vtable word
  * at 1 on hierarchy members, then the flattened field list. */
-export function classFieldIndex(meta, field) {
+export function classFieldIndex(meta, field, refs = "pointer") {
     const idx = meta.def.fields.findIndex((f) => f.name === field);
     if (idx < 0)
         throw new InternalCompilerError(`llvm emitter bug: unknown field ${field} on class ${meta.def.name}`);
-    return { index: classFieldBase(meta) + idx, type: meta.def.fields[idx].type };
+    const compressed = meta.compressed[idx] === true;
+    // Callers that read or write a field's storage as a pointer must not see
+    // a compressed one; callers that decode and encode pass "compressed".
+    if (compressed && refs === "pointer")
+        throw new InternalCompilerError(`llvm emitter bug: field ${field} of ${meta.def.name} holds a 32-bit reference`);
+    return { index: classFieldSlot(meta, idx), type: meta.def.fields[idx].type, compressed };
+}
+/** The GEP index of the field at `idx` in `meta.def.fields`. */
+export function classFieldSlot(meta, idx) {
+    return meta.compact ? meta.compactSlots[idx] : classFieldBase(meta) + idx;
 }
 /** Lines that release the ThreadSlots values of the object `%o` before it
  * is freed: its slot word is 0 unless a value was ever set for it. */
@@ -341,8 +366,7 @@ export function programLifetimeRc(sizeType) {
 export function classPreLines(meta, struct, obj, pre, sizeType) {
     if (meta.idInRc)
         return [
-            `  ${pre}.idp = getelementptr inbounds i8, ptr ${obj}, i64 ${CLASS_ID_OFFSET}`,
-            `  ${pre}.id = load i32, ptr ${pre}.idp`,
+            ...classIdLoadLines(meta, obj, `${pre}.id`, ""),
             `  ${pre}.n = add i32 ${pre}.id, -1 ; the class id is the preorder number + 1`,
             `  ${pre} = zext i32 ${pre}.n to ${sizeType}`,
         ];
@@ -362,13 +386,32 @@ export function classIdVtLines(meta, obj, vt, group) {
     const vtt = `%${mangleVtStruct(root.def.name)}`;
     const n = root.post - root.pre + 1;
     return [
-        `  ${t}idp = getelementptr inbounds i8, ptr ${obj}, i64 ${CLASS_ID_OFFSET}`,
-        `  ${t}id = load i32, ptr ${t}idp${group}`,
+        ...classIdLoadLines(meta, `${obj}`, `${t}id`, group),
         `  ${t}ix = sub i32 ${t}id, ${root.pre + 1}`,
         `  ${t}ix64 = zext i32 ${t}ix to i64`,
         `  ${vt} = getelementptr inbounds [${n} x ${vtt}], ptr @${mangleVtArray(root.def.name)}, i64 0, i64 ${t}ix64`,
     ];
 }
+/** Lines that load the class id of the LlClassMeta.idInRc instance `obj`
+ * into the i32 `id`: the high half of the rc word, or the low 28 bits of a
+ * compact instance's header word (compactHeaderWord). `group` is the
+ * metadata of the load (`, !invariant.group !{}` for a load LLVM may treat
+ * as invariant), and it only goes on bytes that never change: publication
+ * sets the top bit of a compact header word, so a compact instance's id is
+ * then read as the word's low 16 bits, which hold the whole id when the
+ * hierarchy's ids are below 2^16, and otherwise as the masked word without
+ * the metadata. */
+export function classIdLoadLines(meta, obj, id, group) {
+    if (meta.compact) {
+        if (group !== "" && meta.root.post + 1 <= 0xffff)
+            return [`  ${id}.h = load i16, ptr ${obj}${group}`, `  ${id} = zext i16 ${id}.h to i32`];
+        return [`  ${id}.w = load i32, ptr ${obj}`, `  ${id} = and i32 ${id}.w, ${COMPACT_ID_MASK}`];
+    }
+    return [
+        `  ${id}p = getelementptr inbounds i8, ptr ${obj}, i64 ${CLASS_ID_OFFSET}`,
+        `  ${id} = load i32, ptr ${id}p${group}`,
+    ];
+}
 /** The byte offset of the class id in the rc word of an instance that
  * keeps it there (LlClassMeta.idInRc): the high half of the little-endian
  * 64-bit word. The count is the i32 at offset 0. */
@@ -382,6 +425,205 @@ export const CLASS_ID_OFFSET = 4;
 export function classIdRcWord(meta, lifetime) {
     return (BigInt(meta.pre + 1) * 2n ** 32n + (lifetime ? 2n ** 31n : 1n)).toString();
 }
+/** The 32-bit header of a compact class instance (LlClassMeta.compact):
+ * COMPACT_HEADER_TAG, the class id (classIdRcWord's preorder number + 1, 0
+ * outside a hierarchy) in the low 28 bits, and COMPACT_PUBLISHED once
+ * publication marks the object. No other object's count reaches
+ * 0x70000000, so the runtime reads a word of 0xf0000000 and up as published
+ * for every object (scr_rc.h SCR_RC_PUBLISHED). */
+export const COMPACT_HEADER_TAG = 0x70000000;
+export const COMPACT_PUBLISHED = 0x80000000;
+export const COMPACT_ID_MASK = 0x0fffffff;
+/** The leading bytes of a new instance that its allocation function stores
+ * right after allocating it (emitObjectAlloc's `stored`), which a recycled
+ * block therefore need not clear: a compact instance's 4-byte header word
+ * (its fields start at offset 4), the 8-byte rc word, or the rc word and
+ * the vtable word of a hierarchy member that keeps its class in a vtable. */
+export function storedHeaderBytes(meta) {
+    if (meta.compact)
+        return 4;
+    return meta.hierarchy && !meta.idInRc ? 16 : 8;
+}
+/** The header word a compact instance is created with. */
+export function compactHeaderWord(meta) {
+    return COMPACT_HEADER_TAG | (meta.hierarchy ? meta.pre + 1 : 0);
+}
+/** Lines that decode the 32-bit reference `idx` (an i32) of a compressed
+ * field into the pointer `out`. The program-lifetime region lies below
+ * 32 GiB (LlvmTargetOptions.lowRegion), so a reference is the instance's
+ * address over 8 and 0 is NULL: one shift, which x86-64 folds into the
+ * address of the next load. `t` names the temporaries. */
+export function compactRefLoadLines(idx, out, t) {
+    return [
+        `  ${t}.z = zext i32 ${idx} to i64`,
+        `  ${t}.o = shl nuw nsw i64 ${t}.z, 3`,
+        `  ${out} = inttoptr i64 ${t}.o to ptr`,
+    ];
+}
+/** Lines that encode the pointer `ptr` (NULL or a compact class instance)
+ * as the 32-bit reference `out` (an i32) a compressed field stores. */
+export function compactRefStoreLines(ptr, out, t) {
+    return [
+        `  ${t}.pi = ptrtoint ptr ${ptr} to i64`,
+        `  ${t}.s = lshr i64 ${t}.pi, 3`,
+        `  ${out} = trunc i64 ${t}.s to i32`,
+    ];
+}
+/** The storage type of a compressed field (LlClassMeta.compressed): a
+ * 32-bit index into the program-lifetime region. */
+export const COMPACT_REF = "i32";
+/** Lines that allocate `%o`, `size` zeroed bytes in the program-lifetime
+ * region: a bump of the calling thread's chunk (scr_rc.h ScrPlrChunk,
+ * thread-local in worker programs), and scr_plr_alloc when the chunk is
+ * exhausted or the target has no inline allocation. The lines end in an
+ * open block. */
+function plrAllocLines(host, size) {
+    const S = host.sizeType;
+    host.declare(`declare ptr @scr_plr_alloc(${S})`);
+    host.declare(`declare i1 @llvm.expect.i1(i1, i1)`);
+    if (host.inlineAlloc !== true)
+        return [`  %o = call ptr @scr_plr_alloc(${S} ${size})`];
+    const chunk = [];
+    if (host.threadLocalAlloc === true) {
+        host.declare(`@scr_plr_chunk = external thread_local global { ptr, ptr }`);
+        host.declare(`declare nonnull ptr @llvm.threadlocal.address.p0(ptr nonnull)`);
+        chunk.push(`  %plr.c = call ptr @llvm.threadlocal.address.p0(ptr @scr_plr_chunk)`);
+    }
+    else {
+        host.declare(`@scr_plr_chunk = external dso_local global { ptr, ptr }`);
+        chunk.push(`  %plr.c = getelementptr inbounds i8, ptr @scr_plr_chunk, i64 0`);
+    }
+    // A thread without a chunk has NULL for both, so nothing fits.
+    return [
+        ...chunk,
+        `  %plr.lp = getelementptr inbounds i8, ptr %plr.c, i64 8`,
+        `  %plr.next = load ptr, ptr %plr.c`,
+        `  %plr.lim = load ptr, ptr %plr.lp`,
+        `  %plr.n7 = add ${S} ${size}, 7`,
+        `  %plr.n = and ${S} %plr.n7, -8`,
+        `  %plr.end = getelementptr i8, ptr %plr.next, ${S} %plr.n`,
+        `  %plr.fits = icmp ule ptr %plr.end, %plr.lim`,
+        `  %plr.fitsx = call i1 @llvm.expect.i1(i1 %plr.fits, i1 true)`,
+        `  br i1 %plr.fitsx, label %plr.bump, label %plr.slow`,
+        `plr.bump:`,
+        `  store ptr %plr.end, ptr %plr.c`,
+        `  br label %plr.done`,
+        `plr.slow:`,
+        `  %plr.o = call ptr @scr_plr_alloc(${S} ${size})`,
+        `  br label %plr.done`,
+        `plr.done:`,
+        `  %o = phi ptr [ %plr.next, %plr.bump ], [ %plr.o, %plr.slow ]`,
+    ];
+}
+/** Byte size and alignment of a class field's LLVM storage type. */
+function fieldStorage(type) {
+    switch (type) {
+        case "i8":
+            return { size: 1, align: 1 };
+        case "i32":
+            return { size: 4, align: 4 };
+        case "ptr":
+        case "double":
+            return { size: 8, align: 8 };
+        case INLINE_UNION_FIELD:
+            return { size: 16, align: 8 };
+        default:
+            throw new InternalCompilerError(`llvm emitter bug: class field storage ${type}`);
+    }
+}
+/** The LLVM storage type of each of a class's flattened fields. */
+export function classFieldTypes(host, cls, int32) {
+    // Whole-program int32 fields (int32-slots.ts) store the exact i32.
+    return cls.fields.map((f) => int32?.isField(cls.name, f.name)
+        ? "i32"
+        : llFieldType(f.type, host.inlineUnions.classField(cls.name, f.name)));
+}
+/** Gives the classes `compact` admits (whole hierarchies: the test is the
+ * root's) the 32-bit header and packed fields. A class keeps its base's
+ * field offsets, and places each of its own fields at the first offset
+ * after the header that fits it: in a hole another field's alignment left,
+ * in the base's tail padding, or at the end. Scalars narrower than 8 bytes
+ * (flags, ids, counts) go first, widest first, so they share the header's
+ * cache line; then the other fields, widest first. So 32-bit and smaller
+ * fields share 8-byte words. The struct lists the header and the fields by
+ * offset, which LLVM's layout of the type reproduces (checked). */
+export function assignCompactLayouts(metaMap, compact, fieldTypes, compressedRef) {
+    const isCompact = (className) => {
+        const target = metaMap.get(className);
+        return target !== undefined && target.def.runtime !== true && compact(target.root);
+    };
+    const byPre = [...metaMap.values()].sort((a, b) => a.pre - b.pre);
+    for (const meta of byPre) {
+        if (meta.def.runtime === true || !compact(meta.root))
+            continue;
+        const base = meta.base;
+        const inherited = base?.compactElems ?? [
+            { offset: 0, size: 4, align: 4, type: "i32", field: -1 },
+        ];
+        const baseCount = base?.def.fields.length ?? 0;
+        if (base !== null && (!base.compact || !sameFieldPrefix(base.def, meta.def)))
+            throw new InternalCompilerError(`llvm emitter bug: compact class ${meta.def.name} does not extend its base's layout`);
+        const elems = inherited.map((e) => ({ ...e }));
+        // A reference to a compact class instance is a 32-bit index into the
+        // program-lifetime region (compactRefLoadLines); inherited fields keep the
+        // base's choice.
+        const compressed = meta.def.fields.map((_, i) => i < baseCount
+            ? base.compressed[i]
+            : compressedRef !== undefined && compressedRef(meta.def, i, isCompact));
+        const types = fieldTypes(meta.def).map((t, i) => {
+            if (!compressed[i])
+                return t;
+            if (t !== "ptr")
+                throw new InternalCompilerError(`llvm emitter bug: compressed field ${meta.def.fields[i].name} of ${meta.def.name} is stored as ${t}`);
+            return COMPACT_REF;
+        });
+        const smallScalar = (f) => f.size < 8 && f.type !== "ptr" && !compressed[f.field] ? 0 : 1;
+        const own = types
+            .map((type, field) => ({ type, field, ...fieldStorage(type) }))
+            .slice(baseCount)
+            .sort((a, b) => smallScalar(a) - smallScalar(b) || b.size - a.size || a.field - b.field);
+        for (const f of own) {
+            const sorted = [...elems].sort((a, b) => a.offset - b.offset);
+            let at = -1;
+            let cursor = 0;
+            for (const e of sorted) {
+                const start = alignTo(cursor, f.align);
+                if (start + f.size <= e.offset) {
+                    at = start;
+                    break;
+                }
+                cursor = Math.max(cursor, e.offset + e.size);
+            }
+            if (at < 0)
+                at = alignTo(cursor, f.align);
+            elems.push({ offset: at, size: f.size, align: f.align, type: f.type, field: f.field });
+        }
+        elems.sort((a, b) => a.offset - b.offset);
+        // LLVM places each element at the next offset its alignment allows.
+        let end = 0;
+        for (const e of elems) {
+            if (alignTo(end, e.align) !== e.offset)
+                throw new InternalCompilerError(`llvm emitter bug: compact layout of ${meta.def.name} is not LLVM's`);
+            end = e.offset + e.size;
+        }
+        const slots = new Array(types.length).fill(-1);
+        elems.forEach((e, index) => {
+            if (e.field >= 0)
+                slots[e.field] = index;
+        });
+        meta.compact = true;
+        meta.compactElems = elems;
+        meta.compactSlots = slots;
+        meta.compressed = compressed;
+    }
+}
+function alignTo(n, align) {
+    return Math.ceil(n / align) * align;
+}
+function sameFieldPrefix(base, cls) {
+    return (base.fields.length <= cls.fields.length &&
+        base.fields.every((f, i) => cls.fields[i].name === f.name));
+}
 function undefFieldInits(host, meta, nullable) {
     const out = [];
     meta.def.fields.forEach((f, i) => {
@@ -392,7 +634,11 @@ function undefFieldInits(host, meta, nullable) {
         // A nullable-pointer field's zeroed slot already is its unit arm.
         if (nullable?.get(meta.def.name, f.name))
             return;
-        const { index } = classFieldIndex(meta, f.name);
+        // Only union and dyn fields get a store here; a compressed field is a
+        // class reference, which starts NULL.
+        const { index, compressed } = classFieldIndex(meta, f.name, "compressed");
+        if (compressed)
+            return;
         if (f.type.kind === "union" && host.inlineUnions.classField(meta.def.name, f.name)) {
             // An inline field starts at the undefined arm's tag with zero bits.
             const tag = undefinedArmTag(f.type, host.unionsById);
@@ -421,6 +667,9 @@ function undefFieldInits(host, meta, nullable) {
  * +trace/gcFree for cycle-capable shapes) definitions (`defs`). Mirrors
  * emitStructDefs + emitHierarchyClassHelpers. */
 export function emitClassShapes(host, mod, metaMap, nullable, int32) {
+    // Whether compact instances live in the program-lifetime region, where
+    // fields and arrays can refer to them in 32 bits (LlEmitter.compactRegion).
+    const regionRefs = host.compactRegion?.() === true;
     const typeDefs = [];
     const defs = [];
     const emitted = (mod.classes ?? []).filter((c) => !c.runtime);
@@ -433,10 +682,15 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
     }
     for (const cls of emitted) {
         const meta = metaMap.get(cls.name);
-        // Whole-program int32 fields (int32-slots.ts) store the exact i32.
-        const fieldTys = cls.fields.map((f) => int32?.isField(cls.name, f.name)
-            ? "i32"
-            : llFieldType(f.type, host.inlineUnions.classField(cls.name, f.name)));
+        if (meta.compact) {
+            typeDefs.push(`%${mangleClassStruct(cls.name)} = type { ${meta.compactElems.map((e) => e.type).join(", ")} } ` +
+                `; class ${cls.name} (32-bit header) { ${meta.compactElems
+                    .slice(1)
+                    .map((e) => llvmCommentText(cls.fields[e.field].name))
+                    .join("; ")} }`);
+            continue;
+        }
+        const fieldTys = classFieldTypes(host, cls, int32);
         // Subclasses of a runtime base embed its remaining prefix (the state
         // and display-name slots) between the vtable word and the field list;
         // stream subclasses add the stream-state pointer — upcasts to
@@ -542,18 +796,30 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
         const traced = host.tracedShapes.has(`object:${cls.name}`);
         const runtimePrefix = runtimePrefixOf(meta);
         const isStreamRooted = streamRooted(meta);
-        const fieldIndex = (i) => classFieldBase(meta) + i;
+        const fieldIndex = (i) => classFieldSlot(meta, i);
         // Teardown, trace and gcFree see each slot's storage type: a nullable
         // class field holds the instance pointer (NULL for the unit arm), and
-        // every class retain/release/visit entry point is NULL-tolerant.
+        // every class retain/release/visit entry point is NULL-tolerant. A
+        // compressed field refers to a compact instance, which nothing releases
+        // or traces, so they skip it.
         const indexedFields = [
-            ...ownedFields(cls).map(({ field, i }) => ({
+            ...ownedFields(cls)
+                .filter(({ i }) => meta.compressed[i] !== true)
+                .map(({ field, i }) => ({
                 name: field.name,
                 type: storedFieldType(cls, field),
                 index: fieldIndex(i),
             })),
         ];
         const refFields = indexedFields.filter((f) => isRefCounted(f.type));
+        const tracedFields = traced
+            ? indexedFields.filter((f) => traceAdapter(host, f.type) !== null)
+            : [];
+        // A traced class whose trace visits nothing carries the collector header
+        // only because its hierarchy is traced: it is never on a cycle. Its
+        // descriptor names scr_cyc_no_children and its objects start out
+        // SCR_CYC_ACYCLIC, so releases never buffer them.
+        const acyclic = traced && runtimePrefix === null && !isStreamRooted && tracedFields.length === 0;
         const bounded = runtimePrefix !== null ||
             isStreamRooted ||
             refFields.some((field) => needsBoundedRelease(field.type));
@@ -583,18 +849,40 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
         const chained = bounded &&
             (directTargets.has(`object:${cls.name}`) ||
                 refFields.some((f) => directDestroyTarget(host, f.type, directTargets) !== null));
+        // The teardown's own symbol, and whether it keeps a segment (shapes.ts
+        // segmentedTeardown).
+        const destroy = `${meta.hierarchy ? mangleClassReleaseDirect(cls.name) : mangleClassRelease(cls.name)}_destroy`;
+        const segmented = chained &&
+            !meta.compact &&
+            runtimePrefix === null &&
+            !isStreamRooted &&
+            !meta.threadSlot &&
+            segmentedTeardown(host, destroy, refFields.map((f) => f.type), directTargets);
         // The field-releasing teardown body shared by both release shapes
         // (the public one on standalone classes, the DIRECT one on hierarchy
         // members). Runs at rc == 0.
         const teardown = (lines) => {
-            refFields.forEach((f, t) => {
-                lines.push(`  %f${t} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${f.index}`, `  %v${t} = load ptr, ptr %f${t}`);
+            const release = (prefix, f, t) => {
                 const direct = bounded ? directDestroyTarget(host, f.type, directTargets) : null;
-                if (direct)
-                    lines.push(...directChildReleaseLines(host, `td${t}`, `%v${t}`, direct, llvmCommentText(f.name)));
-                else
-                    lines.push(`  call void ${releaseSym(host, f.type)}(ptr %v${t}) ; ${llvmCommentText(f.name)}`);
-            });
+                if (direct === null)
+                    return [
+                        `  call void ${releaseSym(host, f.type)}(ptr %v${t}) ; ${llvmCommentText(f.name)}`,
+                    ];
+                const own = segmented && direct.destroy === destroy;
+                return directChildReleaseLines(host, `${prefix}${t}`, `%v${t}`, direct, llvmCommentText(f.name), own);
+            };
+            const loads = refFields.map((f, t) => [
+                `  %f${t} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${f.index}`,
+                `  %v${t} = load ptr, ptr %f${t}`,
+            ]);
+            if (segmented) {
+                // A segmented teardown loads its fields, releases its own block, and
+                // then releases the fields (shapes.ts segmentTeardownLines).
+                const ownType = refFields.flatMap((f, t) => directDestroyTarget(host, f.type, directTargets)?.destroy === destroy ? [`%v${t}`] : []);
+                lines.push(...segmentPrologueLines(), ...loads.flat(), ...emitObjectFree(host, traced, "weak", "%sg.own"), ...segmentTeardownLines(ownType, (prefix) => refFields.flatMap((f, t) => release(prefix, f, t))));
+                return;
+            }
+            refFields.forEach((f, t) => lines.push(...loads[t], ...release("td", f, t)));
             if (runtimePrefix)
                 lines.push(...regCall("td", runtimePrefix.drop, ""));
             if (isStreamRooted)
@@ -625,39 +913,44 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
                     `  %vt = load ptr, ptr %vtp`,
                 ]), `  %relp = getelementptr inbounds %ScrVt, ptr %vt, i64 0, i32 2`, `  %rel = load ptr, ptr %relp`, `  call void %rel(ptr %o) ; the DYNAMIC class's teardown`, `  br label %done`, `done:`, `  ret void`, `}`, ``);
             // Direct release (the vtable entry): the class's own teardown. The
-            // caller already handled NULL/immortal.
-            const reld = [
-                `define internal void @${mangleClassReleaseDirect(cls.name)}(ptr %o) ${FN_ATTRS} { ; direct release ${cls.name}`,
-                `entry:`,
-                `  %rc = load ${count}, ptr %o`,
-                `  %n = sub ${count} %rc, 1`,
-                `  store ${count} %n, ptr %o`,
-                `  %dead = icmp eq ${count} %n, 0`,
-                `  br i1 %dead, label %free, label %${traced ? "root" : "done"}`,
-                `free:`,
-            ];
-            if (traced)
-                reld.push(...cycleDeadLines(host, "teardown"));
-            if (bounded) {
-                const destroy = `${mangleClassReleaseDirect(cls.name)}_destroy`;
-                const destroyBody = [];
-                teardown(destroyBody);
-                defs.push(...destroyDefinitions(destroy, destroyBody, chained), ``);
-                host.declare(`declare void @scr_rc_destroy(ptr, ptr)`);
-                reld.push(`  call void @scr_rc_destroy(ptr %o, ptr @${destroy})`);
+            // caller already handled NULL/immortal. A compact instance has no
+            // count: nothing releases it.
+            if (meta.compact) {
+                defs.push(`define internal void @${mangleClassReleaseDirect(cls.name)}(ptr %o) ${FN_ATTRS} { ; direct release ${cls.name} (immortal)`, `entry:`, `  ret void`, `}`, ``);
+            }
+            else {
+                const reld = [
+                    `define internal void @${mangleClassReleaseDirect(cls.name)}(ptr %o) ${FN_ATTRS} { ; direct release ${cls.name}`,
+                    `entry:`,
+                    `  %rc = load ${count}, ptr %o`,
+                    `  %n = sub ${count} %rc, 1`,
+                    `  store ${count} %n, ptr %o`,
+                    `  %dead = icmp eq ${count} %n, 0`,
+                    `  br i1 %dead, label %free, label %${traced ? "root" : "done"}`,
+                    `free:`,
+                ];
+                if (traced)
+                    reld.push(...cycleDeadLines(host, "teardown"));
+                if (bounded) {
+                    const destroyBody = [];
+                    teardown(destroyBody);
+                    defs.push(...destroyDefinitions(destroy, destroyBody, chained, segmented ? host : null), ``);
+                    host.declare(`declare void @scr_rc_destroy(ptr, ptr)`);
+                    reld.push(`  call void @scr_rc_destroy(ptr %o, ptr @${destroy})`);
+                }
+                else
+                    teardown(reld);
+                reld.push(`  br label %done`);
+                if (traced)
+                    reld.push(`root:`, ...cycleRootLines(host, "done"));
+                reld.push(`done:`, `  ret void`, `}`, ``);
+                defs.push(...reld);
             }
-            else
-                teardown(reld);
-            reld.push(`  br label %done`);
-            if (traced)
-                reld.push(`root:`, ...cycleRootLines(host, "done"));
-            reld.push(`done:`, `  ret void`, `}`, ``);
-            defs.push(...reld);
         }
         else {
             const freeBody = [];
             teardown(freeBody);
-            defs.push(...releaseBody(host, mangleClassRelease(cls.name), traced, freeBody, `release ${cls.name}`, bounded, lifetime, chained), ``);
+            defs.push(...releaseBody(host, mangleClassRelease(cls.name), traced, freeBody, `release ${cls.name}`, bounded, lifetime, chained, segmented), ``);
         }
         // new: zeroed allocation, rc = 1, the vtable word on hierarchy
         // members, undefined-admitting union fields at the interned unit
@@ -668,8 +961,10 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
             `entry:`,
         ];
         const cycType = `@${mangleClassTrace(cls.name)}.cyctype`;
+        if (acyclic)
+            host.declare(`declare void @scr_cyc_no_children(ptr, ptr, ptr)`);
         if (traced)
-            defs.push(cycTypeDescriptor(cycType, `@${mangleClassTrace(cls.name)}`, `@${mangleClassGcFree(cls.name)}`, host.nextCycKind?.() ?? 0), ``);
+            defs.push(cycTypeDescriptor(cycType, acyclic ? "@scr_cyc_no_children" : `@${mangleClassTrace(cls.name)}`, `@${mangleClassGcFree(cls.name)}`, host.nextCycKind?.() ?? 0), ``);
         // A program-lifetime instance is never freed: no collector header
         // (nothing walks or frees it) and the program-lifetime count, which
         // publication turns into SIZE_MAX (programLifetimeRc). Programs with
@@ -680,9 +975,25 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
             nw.push(...regions.newAlloc(cls.name, sizeOf));
             defs.push(...regions.classDefinitions(cls, sizeOf));
         }
+        else if (meta.compact && regionRefs) {
+            // Compressed fields refer to compact instances by their index in the
+            // program-lifetime region, so every compact instance lives there:
+            // zeroed, 8-byte aligned and never freed.
+            nw.push(...plrAllocLines(host, sizeOf));
+        }
         else
-            nw.push(...emitObjectAlloc(host, sizeOf, traced && !lifetime ? { type: cycType } : null, meta.hierarchy && !meta.idInRc ? 16 : 8));
-        if (meta.idInRc) {
+            nw.push(...emitObjectAlloc(host, sizeOf, traced && !lifetime ? { type: cycType, acyclic } : null, storedHeaderBytes(meta)));
+        if (meta.compact && !meta.hierarchy)
+            nw.push(`  store i32 ${compactHeaderWord(meta)}, ptr %o ; no count (compactHeaderWord)`);
+        else if (meta.compact) {
+            // The header word: the class id and no count (compactHeaderWord).
+            // Only publication writes it again, setting COMPACT_PUBLISHED in the
+            // top byte, so the class id reads that carry !invariant.group read
+            // the low 16 bits only (classIdLoadLines).
+            host.declare(`declare ptr @llvm.launder.invariant.group.p0(ptr)`);
+            nw.push(`  %o.vt = call ptr @llvm.launder.invariant.group.p0(ptr %o)`, `  store i32 ${compactHeaderWord(meta)}, ptr %o.vt ; class ${llvmCommentText(cls.name)} is ${meta.pre}`);
+        }
+        else if (meta.idInRc) {
             // The class id in the high half of the rc word, the count in the low
             // half (classIdRcWord). It never changes while the object lives:
             // retains, releases and the runtime write only the low half.
@@ -729,7 +1040,6 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
             // exactly the complement, then free (the trace/teardown complement
             // contract in scr_runtime.h).
             const indexed = indexedFields;
-            const tracedFields = indexed.filter((f) => traceAdapter(host, f.type) !== null);
             const untracedRefFields = indexed.filter((f) => isRefCounted(f.type) && traceAdapter(host, f.type) === null);
             const tr = [
                 `define internal void @${mangleClassTrace(cls.name)}(ptr %o, ptr %visit, ptr %ctx) ${FN_ATTRS} { ; trace ${cls.name}`,