@scriptc/compiler 0.4.0 → 0.4.2

package/dist/backend/llvm/classes.js

@@ -1,9 +1,10 @@
 import { InternalCompilerError } from "../../errors.js";
 import { isRefCounted, RUNTIME_EMITTER_CLASS, RUNTIME_EVENT_CLASS, RUNTIME_EVENT_TARGET_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, classValueConstructor, } from "../../ir/ir.js";
 import { streamRooted, undefinedArmTag } from "../../ir/analysis.js";
-import { mangleClassGcFree, mangleClassNew, mangleClassObj, mangleClassRelease, mangleClassReleaseDirect, mangleClassRetain, mangleClassStruct, mangleClassTrace, mangleCtorThunk, mangleFunction, mangleGlobal, mangleVtInstance, mangleVtStruct, } from "../mangle.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";
 /** Per-class node of the class graph. */
@@ -24,6 +25,25 @@ export class LlClassMeta {
      * member's struct carries the i32 slot word before its fields
      * (classSlotWordIndex). */
     threadSlot = false;
+    /** A member of a program-rooted hierarchy on a 64-bit target: instead of
+     * a vtable word, the rc word holds the class id (classIdRcWord) in its
+     * high 32 bits (CLASS_ID_OFFSET) and the reference count in its low 32
+     * 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;
@@ -35,7 +55,7 @@ export class LlClassMeta {
  * slots — a class's method gets a slot iff no ancestor declares it AND some
  * strict descendant redeclares it (whole-program devirtualization).
  * The preorder intervals also identify runtime class membership. */
-export function buildClassGraph(mod, fnByName) {
+export function buildClassGraph(mod, fnByName, sizeType = "i64") {
     const metaMap = new Map();
     for (const cls of mod.classes ?? []) {
         const meta = new LlClassMeta(cls);
@@ -64,6 +84,11 @@ export function buildClassGraph(mod, fnByName) {
             number(meta, meta);
         meta.hierarchy = meta.base !== null || meta.children.length > 0;
     }
+    // The runtime reads the vtable word of runtime-rooted hierarchies (Error,
+    // EventEmitter, EventTarget, Event and the streams) and 32-bit targets
+    // have no spare half in the rc word: those keep the vtable word.
+    for (const meta of metaMap.values())
+        meta.idInRc = sizeType === "i64" && meta.hierarchy && meta.root.def.runtime !== true;
     const slotRoots = new Set();
     for (const key of mod.threadSlotKeys ?? []) {
         const meta = metaMap.get(key);
@@ -243,11 +268,12 @@ function runtimePrefixOf(meta) {
     return RUNTIME_PREFIXES.get(meta.root.def.name) ?? null;
 }
 /** The GEP index after a class's header words: rc at 0, the vtable word
- * at 1 on hierarchy members, then a runtime prefix (state + display name)
+ * at 1 on hierarchy members that do not keep their class id in the rc
+ * word (LlClassMeta.idInRc), then a runtime prefix (state + display name)
  * on classes rooted at a runtime base, then the stream-state slot on
  * stream-rooted ones. */
 function headerEnd(meta) {
-    if (!meta.hierarchy)
+    if (!meta.hierarchy || meta.idInRc)
         return 1;
     if (streamRooted(meta))
         return 5;
@@ -264,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. */
@@ -272,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. */
@@ -322,6 +359,268 @@ export function programLifetimeClass(host, meta) {
 export function programLifetimeRc(sizeType) {
     return sizeType === "i32" ? "-2147483648" : "-9223372036854775808";
 }
+/** Lines that load the preorder number of the dynamic class of `obj`, an
+ * instance of `meta`'s hierarchy whose struct is `struct`, into `pre` (a
+ * `sizeType`): from the high half of the rc word (LlClassMeta.idInRc), or
+ * from the vtable its vtable word points at. */
+export function classPreLines(meta, struct, obj, pre, sizeType) {
+    if (meta.idInRc)
+        return [
+            ...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}`,
+        ];
+    return [
+        `  ${pre}.vtp = getelementptr inbounds %${struct}, ptr ${obj}, i64 0, i32 1`,
+        `  ${pre}.vt = load ptr, ptr ${pre}.vtp`,
+        `  ${pre}.prep = getelementptr inbounds %ScrVt, ptr ${pre}.vt, i64 0, i32 0`,
+        `  ${pre} = load ${sizeType}, ptr ${pre}.prep`,
+    ];
+}
+/** Lines that load the class id of the LlClassMeta.idInRc instance `obj`
+ * (`group` adds !invariant.group to the load) and point `vt` at its class's
+ * element of the hierarchy's vtable array. */
+export function classIdVtLines(meta, obj, vt, group) {
+    const t = `${vt}.`;
+    const root = meta.root;
+    const vtt = `%${mangleVtStruct(root.def.name)}`;
+    const n = root.post - root.pre + 1;
+    return [
+        ...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. */
+export const CLASS_ID_OFFSET = 4;
+/** The rc word an LlClassMeta.idInRc instance is created with: the class
+ * id, its preorder number plus 1, in the high 32 bits, and in the low 32 bits
+ * a count of 1, or for a program-lifetime instance the midpoint of the 32-bit
+ * count (as programLifetimeRc is of the 32-bit word). The id is never 0,
+ * 0x80000000 or 0xffffffff, the high halves of other objects' rc words, so
+ * the runtime can tell an object with a class id (scr_rc.h scr_rc_class_id). */
+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, widest first, 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. 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 own = types
+            .map((type, field) => ({ type, field, ...fieldStorage(type) }))
+            .slice(baseCount)
+            .sort((a, 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) => {
@@ -332,7 +631,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);
@@ -361,6 +664,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 (any
+    // field holds a 32-bit reference to one; emitter.ts assignCompactLayouts).
+    const regionRefs = [...metaMap.values()].some((m) => m.compressed.some(Boolean));
     const typeDefs = [];
     const defs = [];
     const emitted = (mod.classes ?? []).filter((c) => !c.runtime);
@@ -373,17 +679,22 @@ 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
         // ScrEmitter* / ScrStream* / ScrEventTargetObj* / ScrEventObj* are the
         // usual pointer reinterprets.
         const runtimePrefix = runtimePrefixOf(meta);
-        const prefix = meta.hierarchy
+        const prefix = meta.hierarchy && !meta.idInRc
             ? streamRooted(meta)
                 ? ["ptr", "ptr", "ptr", "ptr"]
                 : runtimePrefix
@@ -392,7 +703,7 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
             : [];
         const members = [...prefix, ...(meta.threadSlot ? ["i32"] : []), ...fieldTys];
         typeDefs.push(`%${mangleClassStruct(cls.name)} = type { ${host.sizeType}${members.length ? ", " + members.join(", ") : ""} } ` +
-            `; class ${cls.name}${meta.hierarchy ? " (vt at 1)" : ""}${streamRooted(meta) ? " (ScrStream prefix at 2)" : runtimePrefix ? ` (${runtimePrefix.struct} prefix at 2)` : ""} { ${cls.fields.map((f) => llvmCommentText(f.name)).join("; ")} }`);
+            `; class ${cls.name}${meta.idInRc ? " (class id in rc)" : meta.hierarchy ? " (vt at 1)" : ""}${streamRooted(meta) ? " (ScrStream prefix at 2)" : runtimePrefix ? ` (${runtimePrefix.struct} prefix at 2)` : ""} { ${cls.fields.map((f) => llvmCommentText(f.name)).join("; ")} }`);
     }
     // Vtable struct types, one per ROOT of the emitted hierarchy classes (a
     // runtime root — %Error — counts exactly when an emitted subclass needs
@@ -413,16 +724,32 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
     // One constant vtable instance per emitted hierarchy class: interval,
     // direct release, and the class's dispatch entry for every slot — the
     // method functions THEMSELVES (no adapters; see the header comment).
-    for (const cls of emitted) {
-        const meta = metaMap.get(cls.name);
-        if (!meta.hierarchy)
-            continue;
+    const vtInit = (meta) => {
         const entries = vtEntriesFor(meta).map(({ slot, impl }) => impl === null
             ? `ptr null` // outside the declaring subtree / fully-abstract chain
             : `ptr @${host.virtualEntry?.(`%${impl.def.name}.${slot.method}`) ?? mangleFunction(`%${impl.def.name}.${slot.method}`)}`);
-        const head = `%ScrVt { ${host.sizeType} ${meta.pre}, ${host.sizeType} ${meta.post}, ptr @${mangleClassReleaseDirect(cls.name)} }`;
+        const head = `%ScrVt { ${host.sizeType} ${meta.pre}, ${host.sizeType} ${meta.post}, ptr @${mangleClassReleaseDirect(meta.def.name)} }`;
+        return `{ ${[head, ...entries].join(", ")} }`;
+    };
+    for (const cls of emitted) {
+        const meta = metaMap.get(cls.name);
+        if (!meta.hierarchy || meta.idInRc)
+            continue;
         defs.push(`@${mangleVtInstance(cls.name)} = internal constant %${mangleVtStruct(meta.root.def.name)} ` +
-            `{ ${[head, ...entries].join(", ")} } ; class ${cls.name}`, ``);
+            `${vtInit(meta)} ; class ${cls.name}`, ``);
+    }
+    // A hierarchy whose instances keep their class id in the rc word has
+    // one array of its classes' vtables, in preorder: the vtable of an
+    // instance is the element at its number minus the root's.
+    for (const name of roots) {
+        const root = metaMap.get(name);
+        if (!root.idInRc)
+            continue;
+        const members = [...metaMap.values()]
+            .filter((m) => m.root === root)
+            .sort((a, b) => a.pre - b.pre);
+        const vtt = `%${mangleVtStruct(root.def.name)}`;
+        defs.push(`@${mangleVtArray(root.def.name)} = internal constant [${members.length} x ${vtt}] [`, ...members.map((m, i) => `  ${vtt} ${vtInit(m)}${i + 1 < members.length ? "," : ""} ; class ${m.def.name}`), `]`, ``);
     }
     // Classes with an out-of-line teardown (a bounded release) whose instances
     // are all of that exact class can be torn down directly by a parent's
@@ -454,6 +781,7 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
                 release: `@${release}`,
                 destroy: `${teardown}_destroy`,
                 traced: host.tracedShapes.has(`object:${cls.name}`),
+                ...(meta.idInRc ? { count: "i32" } : {}),
             },
         ]);
     }
@@ -465,18 +793,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));
@@ -496,7 +836,10 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
         const stCall = (tag, entry, tail) => prefixCall(tag, 4, entry, tail, "stream state (ScrStream prefix)");
         // retain: NULL-tolerant, immortal-skip — layout-generic (rc at 0), so
         // hierarchy members need no dispatch.
-        defs.push(...retainBody(host, mangleClassRetain(cls.name), `retain ${cls.name}`, lifetime), ``);
+        // An instance that keeps its class id in the rc word counts in the
+        // low half (CLASS_ID_OFFSET).
+        const count = meta.idInRc ? "i32" : host.sizeType;
+        defs.push(...retainBody(host, mangleClassRetain(cls.name), `retain ${cls.name}`, lifetime, count), ``);
         // An out-of-line teardown tears typed children down directly
         // (directChildReleaseLines). It takes the chain length when it has such
         // children or is itself a direct target.
@@ -537,37 +880,48 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
                 ? `${mangleClassRelease(cls.name)}_slow`
                 : mangleClassRelease(cls.name);
             if (userRooted)
-                defs.push(...releaseFastPath(host, mangleClassRelease(cls.name), dispatchName, traced, `release ${cls.name}`, lifetime), ``);
-            defs.push(`define internal void @${dispatchName}(ptr %o) ${userRooted ? "noinline " : ""}${FN_ATTRS} { ; release ${cls.name} (dispatches)`, `entry:`, `  %isnull = icmp eq ptr %o, null`, `  br i1 %isnull, label %done, label %check`, `check:`, `  %rc = load ${host.sizeType}, ptr %o`, `  %imm = icmp eq ${host.sizeType} %rc, -1`, `  br i1 %imm, label %done, label %disp`, `disp:`, `  %vtp = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 1`, `  %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`, `}`, ``);
+                defs.push(...releaseFastPath(host, mangleClassRelease(cls.name), dispatchName, traced, `release ${cls.name}`, lifetime, count), ``);
+            defs.push(`define internal void @${dispatchName}(ptr %o) ${userRooted ? "noinline " : ""}${FN_ATTRS} { ; release ${cls.name} (dispatches)`, `entry:`, `  %isnull = icmp eq ptr %o, null`, `  br i1 %isnull, label %done, label %check`, `check:`, `  %rc = load ${count}, ptr %o`, `  %imm = icmp eq ${count} %rc, -1`, `  br i1 %imm, label %done, label %disp`, `disp:`, ...(meta.idInRc
+                ? classIdVtLines(meta, "%o", "%vt", "")
+                : [
+                    `  %vtp = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 1`,
+                    `  %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 ${host.sizeType}, ptr %o`,
-                `  %n = sub ${host.sizeType} %rc, 1`,
-                `  store ${host.sizeType} %n, ptr %o`,
-                `  %dead = icmp eq ${host.sizeType} %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 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})`);
+                }
+                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 = [];
@@ -583,8 +937,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
@@ -595,9 +951,33 @@ 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 ? 16 : 8));
-        nw.push(`  store ${host.sizeType} ${lifetime ? programLifetimeRc(host.sizeType) : 1}, ptr %o`);
+            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.
+            host.declare(`declare ptr @llvm.launder.invariant.group.p0(ptr)`);
+            nw.push(`  %o.vt = call ptr @llvm.launder.invariant.group.p0(ptr %o)`, `  store i64 ${classIdRcWord(meta, lifetime)}, ptr %o.vt ; class ${llvmCommentText(cls.name)} is ${meta.pre}`);
+        }
+        else
+            nw.push(`  store ${host.sizeType} ${lifetime ? programLifetimeRc(host.sizeType) : 1}, ptr %o`);
         if (lifetime && audit) {
             // --sanitize builds: the RC audit skips its leak report when the
             // program keeps program-lifetime objects (scr_console.c), and
@@ -605,7 +985,7 @@ export function emitClassShapes(host, mod, metaMap, nullable, int32) {
             host.declare(`declare void @scr_obj_lifetime_note(ptr)`);
             nw.push(`  call void @scr_obj_lifetime_note(ptr %o)`);
         }
-        if (meta.hierarchy) {
+        if (meta.hierarchy && !meta.idInRc) {
             // The vtable word is written once, here, and never changes while the
             // object lives: its store and the virtual-call loads carry
             // !invariant.group. A recycled block may have held an object of
@@ -636,7 +1016,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}`,