@scriptc/compiler 0.2.6 → 0.2.8

package/dist/backend/llvm/checked-narrows.js

@@ -0,0 +1,108 @@
+import { isRefCounted, typeEquals, } from "../../ir/ir.js";
+import { mangleBorrowedFunction } from "../mangle.js";
+import { emitCallArrayRead } from "./local-array-reads.js";
+/** Recognize the complete checked-extraction body, not the helper's name:
+ * one test per arm of the parameter's union, where the target arm returns
+ * its payload and every other arm throws, followed by a final throw. A
+ * helper that returns a default for some arm is not a checked extraction. */
+function checkedNarrowShape(fn) {
+    if (fn.async ||
+        fn.generator ||
+        fn.captures ||
+        fn.classCaptures ||
+        fn.params.length !== 1 ||
+        fn.locals.length !== 1 ||
+        fn.locals.some((local) => local.boxed || local.tdz) ||
+        !isRefCounted(fn.returnType))
+        return null;
+    const param = fn.params[0];
+    if (param.type.kind !== "union")
+        return null;
+    const unionId = param.type.unionId;
+    const last = fn.body[fn.body.length - 1];
+    if (last?.kind !== "throw")
+        return null;
+    let tag = -1;
+    for (const [index, stmt] of fn.body.slice(0, -1).entries()) {
+        if (stmt.kind !== "if" ||
+            stmt.else_ !== null ||
+            stmt.cond.kind !== "unionIsTag" ||
+            stmt.cond.negated ||
+            stmt.cond.tag !== index ||
+            stmt.cond.unionId !== unionId ||
+            stmt.cond.value.kind !== "varRef" ||
+            stmt.cond.value.localId !== param.localId ||
+            stmt.then.length !== 1)
+            return null;
+        const branch = stmt.then[0];
+        if (branch.kind === "throw")
+            continue;
+        const value = branch.kind === "return" ? branch.value : null;
+        if (tag >= 0 ||
+            value?.kind !== "unionNarrow" ||
+            value.unionId !== unionId ||
+            value.tag !== index ||
+            value.value.kind !== "varRef" ||
+            value.value.localId !== param.localId ||
+            !typeEquals(value.type, fn.returnType))
+            return null;
+        tag = index;
+    }
+    return tag < 0 ? null : { unionId, tag, target: fn.returnType };
+}
+/** Checked extractions in finalized IR, indexed once per module. */
+export class CheckedNarrows {
+    shapes = new Map();
+    constructor(functions) {
+        for (const fn of functions.values()) {
+            const shape = checkedNarrowShape(fn);
+            if (shape)
+                this.shapes.set(fn.name, shape);
+        }
+    }
+    get(e) {
+        if (e.kind !== "call" || e.args.length !== 1)
+            return null;
+        const shape = this.shapes.get(e.callee);
+        const value = e.args[0];
+        if (!shape ||
+            !typeEquals(shape.target, e.type) ||
+            value.type.kind !== "union" ||
+            value.type.unionId !== shape.unionId)
+            return null;
+        return { call: e, value, tag: shape.tag };
+    }
+}
+/** A checked extraction consumed at once by a field or tag load. The
+ * successful arm borrows the payload from the union, which itself borrows
+ * from its source: a dense array read keeps the element in the array slot,
+ * and no user code runs before the consumer loads from it. Every other arm
+ * calls the helper with the same union, so the thrown error is unchanged.
+ * Returns null, having emitted nothing, when the helper would own its
+ * argument. */
+export function emitCheckedNarrowReceiver(host, narrow) {
+    const callee = narrow.call.callee;
+    if (!host.callLifetimes.borrowed.get(callee)?.has(0) || !host.mayThrow.has(callee))
+        return null;
+    const B = host.B;
+    const read = host.optionalArrayReads.get(narrow.value);
+    const union = read
+        ? emitCallArrayRead(host, { ...read, borrow: true }, true)
+        : host.emitUnionProjection(narrow.value);
+    // Nullable unions (nullable-unions.ts) are the payload pointer itself;
+    // the representation-aware tag and peek cover both forms.
+    const unionId = narrow.value.type.unionId;
+    const tag = host.unionTag(union.name, unionId);
+    const present = B.tmp();
+    B.line(`${present} = icmp eq i32 ${tag}, ${narrow.tag}`);
+    const yes = B.newLabel("narrow.present"), no = B.newLabel("narrow.other");
+    B.condBr(present, yes, no);
+    B.startBlock(no);
+    B.line(`call ptr @${mangleBorrowedFunction(callee)}(ptr ${union.name})`);
+    host.emitPendingCheck();
+    // Every arm but the target throws, so the helper never returns here.
+    B.terminate("unreachable");
+    B.startBlock(yes);
+    return { name: host.unionPeek(union.name, unionId), type: narrow.call.type };
+}
+//# sourceMappingURL=checked-narrows.js.map

package/dist/backend/llvm/checked-narrows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checked-narrows.js","sourceRoot":"","sources":["../../../src/backend/llvm/checked-narrows.ts"],"names":[],"mappings":"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"}

package/dist/backend/llvm/checked-narrows.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/backend/llvm/checked-narrows.test.js

@@ -0,0 +1,208 @@
+import { expect, test } from "vitest";
+import { BOOL, F64, STRING, VOID, UNDEFINED_T, arrayOf, } from "../../ir/ir.js";
+import { validateModule } from "../../ir/validate.js";
+import { CheckedNarrows } from "./checked-narrows.js";
+import { emitLlvmModule } from "./emitter.js";
+const loc = { file: "checked-narrow.ts", start: 0, end: 0 };
+const element = { kind: "record", shapeId: "cell" };
+const optional = { kind: "union", unionId: "optional" };
+const array = arrayOf(element);
+const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
+const params = [
+    { localId: "a", name: "a", type: array },
+    { localId: "i", name: "i", type: F64 },
+];
+const locals = params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false }));
+/** The optional array read the frontend emits for `a[i]`. */
+const read = {
+    name: "read",
+    params,
+    returnType: optional,
+    locals,
+    loc,
+    body: [
+        {
+            kind: "return",
+            loc,
+            value: {
+                kind: "ternary",
+                type: optional,
+                loc,
+                cond: {
+                    kind: "bin",
+                    op: "===",
+                    left: { kind: "arrayState", arr: ref("a", array), index: ref("i", F64), type: F64, loc },
+                    right: { kind: "numLit", value: 1, type: F64, loc },
+                    type: BOOL,
+                    loc,
+                },
+                then: {
+                    kind: "unionWrap",
+                    unionId: "optional",
+                    tag: 0,
+                    value: {
+                        kind: "arrayGet",
+                        arr: ref("a", array),
+                        index: ref("i", F64),
+                        type: element,
+                        loc,
+                    },
+                    type: optional,
+                    loc,
+                },
+                else_: {
+                    kind: "unionWrap",
+                    unionId: "optional",
+                    tag: 1,
+                    value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
+                    type: optional,
+                    loc,
+                },
+            },
+        },
+    ],
+};
+/** A checked extraction of the element arm; `undefinedArm` replaces the
+ * throwing undefined branch, as a defaulting helper would. */
+function check(name, undefinedArm) {
+    const u = ref("u.0", optional);
+    const thrown = {
+        kind: "throw",
+        value: {
+            kind: "libCall",
+            fn: "error.new",
+            args: [{ kind: "strLit", value: "undefined is not an element", type: STRING, loc }],
+            type: { kind: "object", className: "%TypeError" },
+            loc,
+        },
+        loc,
+    };
+    const arm = (tag, then) => ({
+        kind: "if",
+        cond: {
+            kind: "unionIsTag",
+            unionId: "optional",
+            tag,
+            negated: false,
+            value: u,
+            type: BOOL,
+            loc,
+        },
+        then: [then],
+        else_: null,
+        loc,
+    });
+    return {
+        name,
+        params: [{ localId: "u.0", name: "u", type: optional }],
+        returnType: element,
+        locals: [{ id: "u.0", name: "u", type: optional, mutable: false }],
+        loc,
+        body: [
+            arm(0, {
+                kind: "return",
+                value: { kind: "unionNarrow", unionId: "optional", tag: 0, value: u, type: element, loc },
+                loc,
+            }),
+            arm(1, undefinedArm ?? thrown),
+            { kind: "throw", value: { kind: "strLit", value: "invalid tag", type: STRING, loc }, loc },
+        ],
+    };
+}
+function fixture(helper) {
+    const narrowed = {
+        kind: "call",
+        callee: helper.name,
+        args: [
+            { kind: "call", callee: "read", args: [ref("a", array), ref("i", F64)], type: optional, loc },
+        ],
+        type: element,
+        loc,
+    };
+    const work = {
+        name: "work",
+        params,
+        returnType: F64,
+        locals,
+        loc,
+        body: [
+            {
+                kind: "return",
+                value: { kind: "recordGet", obj: narrowed, shapeId: "cell", field: "x", type: F64, loc },
+                loc,
+            },
+        ],
+    };
+    return {
+        irVersion: 15,
+        sourceFile: loc.file,
+        entry: "main",
+        records: [{ id: "cell", fields: [{ name: "x", type: F64 }] }],
+        unions: [{ id: "optional", arms: [element, UNDEFINED_T] }],
+        functions: [
+            { name: "main", params: [], returnType: VOID, locals: [], body: [], loc },
+            read,
+            helper,
+            work,
+        ],
+    };
+}
+function workBody(mod, pointerBits = 64) {
+    return /^define internal [^\n]*@sc_(?:b)?f_work\([^]*?^}/m.exec(emitLlvmModule(mod, { pointerBits }))[0];
+}
+test("recognizes checked extractions by their complete body", () => {
+    const defaulted = check("defaulted", {
+        kind: "return",
+        value: {
+            kind: "unionNarrow",
+            unionId: "optional",
+            tag: 0,
+            value: ref("u.0", optional),
+            type: element,
+            loc,
+        },
+        loc,
+    });
+    const narrows = new CheckedNarrows(new Map([check("check"), defaulted, read].map((fn) => [fn.name, fn])));
+    const call = (callee) => ({
+        kind: "call",
+        callee,
+        args: [ref("value", optional)],
+        type: element,
+        loc,
+    });
+    expect(narrows.get(call("check"))?.tag).toBe(0);
+    // Two successful arms, or any non-throwing arm, is not a checked extraction.
+    expect(narrows.get(call("defaulted"))).toBeNull();
+    expect(narrows.get(call("read"))).toBeNull();
+});
+test("a field read through a checked array element borrows the element on both ABIs", () => {
+    const mod = fixture(check("check"));
+    expect(validateModule(mod)).toEqual([]);
+    for (const pointerBits of [32, 64]) {
+        const body = workBody(mod, pointerBits);
+        expect(body).toContain("narrow.present");
+        expect(body).not.toContain("@sc_bf_read(");
+        expect(body).not.toContain("@sc_rretain_");
+        expect(body).not.toContain("@sc_rrelease_");
+        // The helper still runs, and throws, for every other arm.
+        expect(body).toMatch(/call ptr @\S*check\S*\(ptr /);
+    }
+});
+test("a helper that does not throw for every other arm keeps the ordinary call", () => {
+    const mod = fixture(check("fallback", {
+        kind: "return",
+        value: {
+            kind: "recordLit",
+            fields: [{ name: "x", value: { kind: "numLit", value: 0, type: F64, loc } }],
+            type: element,
+            loc,
+        },
+        loc,
+    }));
+    expect(validateModule(mod)).toEqual([]);
+    const body = workBody(mod);
+    expect(body).not.toContain("narrow.present");
+    expect(body).toContain("fallback");
+});
+//# sourceMappingURL=checked-narrows.test.js.map

package/dist/backend/llvm/checked-narrows.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checked-narrows.test.js","sourceRoot":"","sources":["../../../src/backend/llvm/checked-narrows.test.ts"],"names":[],"mappings":"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"}

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

@@ -3,6 +3,8 @@
  * implementations directly. Runtime EventEmitter and stream subclasses embed
  * their runtime prefixes ahead of user fields. */
 import type { IrClassDef, IrFunction, IrModule, IrType, IrUnionDef } from "../../ir/ir.js";
+import { NullableRefFields } from "./nullable-fields.js";
+import type { Int32Slots } from "../../ir/int32-slots.js";
 import { type ShapeHost } from "./shapes.js";
 /** One virtual method slot of a hierarchy: the ROOT-MOST declaring class
  * owns the slot; its declaration's IrFunction fixes the slot's ABI (the
@@ -27,6 +29,8 @@ export declare class LlClassMeta {
         pre: number;
         post: number;
     }[];
+    /** Type-only references retain layouts without retaining construction. */
+    constructorRetained: boolean;
     constructor(def: IrClassDef);
 }
 /** The class graph: link base/children, number the forest in preorder
@@ -45,6 +49,13 @@ export declare function classMembershipIntervals(classes: ReadonlyMap<string, Ll
 /** Runtime class-value tests normally use one interval. Only generic
  * families with disjoint storage subtrees require this shared dispatch. */
 export declare function emitClassMembershipHelper(classes: ReadonlyMap<string, LlClassMeta>, sizeType: string): string[];
+/** The root's slot list as seen by one class: the implementation the class
+ * dispatches to, or null outside the slot's declaring subtree / on a
+ * fully-abstract chain (vtEntriesFor, ported). */
+export declare function vtEntriesFor(meta: LlClassMeta): {
+    slot: LlVtSlot;
+    impl: LlClassMeta | null;
+}[];
 /** The LLVM struct type name a class's instances GEP through: the runtime
  * error classes share the runtime's ScrError layout (emitted subclasses
  * embed it as their prefix); every emitted class has its own %sc_o_*. */
@@ -65,13 +76,17 @@ export interface ClassHost extends ShapeHost {
     readonly unionsById: Map<string, IrUnionDef>;
     unitInstanceRef(unionId: string, tag: number): string;
     cstr(text: string): string;
+    /** The symbol a vtable stores for a method implementation (its owned
+     * entry point unless the slot's calling convention borrows; see
+     * LlEmitter.virtualEntry). */
+    virtualEntry?(implFn: string): string;
 }
 /** Per-class LLVM emission for every non-runtime class: the struct types
  * (`typeDefs`), the vtable struct types + per-class constant instances,
  * and the new/retain/release (+releaseDirect for hierarchy members,
  * +trace/gcFree for cycle-capable shapes) definitions (`defs`). Mirrors
  * emitStructDefs + emitHierarchyClassHelpers. */
-export declare function emitClassShapes(host: ClassHost, mod: IrModule, metaMap: Map<string, LlClassMeta>): {
+export declare function emitClassShapes(host: ClassHost, mod: IrModule, metaMap: Map<string, LlClassMeta>, nullable?: NullableRefFields, int32?: Int32Slots): {
     typeDefs: string[];
     defs: string[];
 };

package/dist/backend/llvm/classes.js

@@ -2,8 +2,10 @@ import { InternalCompilerError } from "../../errors.js";
 import { isRefCounted, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, } 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 { emitObjectAlloc, emitObjectFree } from "./alloc.js";
 import { llvmCommentText } from "./common.js";
-import { FN_ATTRS, llFieldType, releaseBody, needsBoundedRelease, releaseSym, retainBody, traceAdapter, } from "./shapes.js";
+import { NullableRefFields } from "./nullable-fields.js";
+import { cycleRootLines, FN_ATTRS, cycleDeadLines, llFieldType, releaseBody, releaseFastPath, needsBoundedRelease, releaseSym, retainBody, traceAdapter, } from "./shapes.js";
 /** Per-class node of the class graph. */
 export class LlClassMeta {
     def;
@@ -16,6 +18,8 @@ export class LlClassMeta {
     /** Root classes: the hierarchy's slots in DFS-declaration order. */
     slots = [];
     membership = [];
+    /** Type-only references retain layouts without retaining construction. */
+    constructorRetained = false;
     constructor(def) {
         this.def = def;
         this.root = this;
@@ -30,7 +34,9 @@ export class LlClassMeta {
 export function buildClassGraph(mod, fnByName) {
     const metaMap = new Map();
     for (const cls of mod.classes ?? []) {
-        metaMap.set(cls.name, new LlClassMeta(cls));
+        const meta = new LlClassMeta(cls);
+        meta.constructorRetained = fnByName.has(`%${cls.name}.constructor`);
+        metaMap.set(cls.name, meta);
     }
     for (const meta of metaMap.values()) {
         if (meta.def.base === undefined)
@@ -153,7 +159,7 @@ export function emitClassMembershipHelper(classes, sizeType) {
 /** The root's slot list as seen by one class: the implementation the class
  * dispatches to, or null outside the slot's declaring subtree / on a
  * fully-abstract chain (vtEntriesFor, ported). */
-function vtEntriesFor(meta) {
+export function vtEntriesFor(meta) {
     return meta.root.slots.map((slot) => {
         if (!(slot.declarer.pre <= meta.pre && meta.pre <= slot.declarer.post)) {
             return { slot, impl: null };
@@ -163,7 +169,7 @@ function vtEntriesFor(meta) {
                 return { slot, impl: c };
             }
         }
-        if (meta.def.abstract === true)
+        if (meta.def.abstract === true || !meta.constructorRetained)
             return { slot, impl: null };
         throw new InternalCompilerError(`llvm emitter bug: no implementation of ${slot.method} for ${meta.def.name}`);
     });
@@ -215,13 +221,16 @@ export function classFieldIndex(meta, field) {
  * at the interned unit instance; dyn fields start at native undefined;
  * jsval fields (an `any` class field under --dynamic) start at the engine's
  * undefined cell. */
-function undefFieldInits(host, meta) {
+function undefFieldInits(host, meta, nullable) {
     const out = [];
     meta.def.fields.forEach((f, i) => {
         // Error.cause uses NULL for absence; an options constructor installs
         // a value only when the cause property is present.
         if (f.name === "%cause")
             return;
+        // 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);
         if (f.type.kind === "jsval" || f.type.kind === "dyn") {
             const undefinedFn = f.type.kind === "dyn" ? "scr_dyn_undefined" : "scr_jsval_undefined";
@@ -243,17 +252,21 @@ function undefFieldInits(host, meta) {
  * and the new/retain/release (+releaseDirect for hierarchy members,
  * +trace/gcFree for cycle-capable shapes) definitions (`defs`). Mirrors
  * emitStructDefs + emitHierarchyClassHelpers. */
-export function emitClassShapes(host, mod, metaMap) {
+export function emitClassShapes(host, mod, metaMap, nullable, int32) {
     const typeDefs = [];
     const defs = [];
     const emitted = (mod.classes ?? []).filter((c) => !c.runtime);
     if (emitted.length === 0)
         return { typeDefs, defs };
-    host.declare(`declare void @scr_obj_alloc_note()`);
-    host.declare(`declare void @scr_obj_free_note()`);
+    const audit = host.objectAudit !== false;
+    if (audit) {
+        host.declare(`declare void @scr_obj_alloc_note()`);
+        host.declare(`declare void @scr_obj_free_note()`);
+    }
     for (const cls of emitted) {
         const meta = metaMap.get(cls.name);
-        const fieldTys = cls.fields.map((f) => llFieldType(f.type));
+        // 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));
         // Emitter subclasses embed ScrEmitter's remaining prefix (the registry
         // and display-name slots) between the vtable word and the field list;
         // stream subclasses add the state pointer — upcasts to ScrEmitter* /
@@ -294,7 +307,7 @@ export function emitClassShapes(host, mod, metaMap) {
             continue;
         const entries = vtEntriesFor(meta).map(({ slot, impl }) => impl === null
             ? `ptr null` // outside the declaring subtree / fully-abstract chain
-            : `ptr @${mangleFunction(`%${impl.def.name}.${slot.method}`)}`);
+            : `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)} }`;
         defs.push(`@${mangleVtInstance(cls.name)} = internal constant %${mangleVtStruct(meta.root.def.name)} ` +
             `{ ${[head, ...entries].join(", ")} } ; class ${cls.name}`, ``);
@@ -306,8 +319,15 @@ export function emitClassShapes(host, mod, metaMap) {
         const isEmitterRooted = emitterRooted(meta);
         const isStreamRooted = streamRooted(meta);
         const fieldIndex = (i) => fieldBase(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.
         const indexedFields = [
-            ...cls.fields.map((f, i) => ({ name: f.name, type: f.type, index: fieldIndex(i) })),
+            ...cls.fields.map((f, i) => ({
+                name: f.name,
+                type: nullable?.storageType(cls.name, f.name, f.type) ?? f.type,
+                index: fieldIndex(i),
+            })),
         ];
         const refFields = indexedFields.filter((f) => isRefCounted(f.type));
         const bounded = isEmitterRooted ||
@@ -327,9 +347,9 @@ export function emitClassShapes(host, mod, metaMap) {
         };
         const regCall = (tag, entry, tail) => prefixCall(tag, 2, entry, tail, "EventEmitter prefix");
         const stCall = (tag, entry, tail) => prefixCall(tag, 4, entry, tail, "stream state (ScrStream prefix)");
-        // retain: NULL-tolerant, immortal-skip, mark-live on traced shapes —
-        // layout-generic (rc at 0), so hierarchy members need no dispatch.
-        defs.push(...retainBody(host, mangleClassRetain(cls.name), traced, `retain ${cls.name}`), ``);
+        // 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}`), ``);
         // 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.
@@ -341,22 +361,24 @@ export function emitClassShapes(host, mod, metaMap) {
                 lines.push(...regCall("td", "scr_emitter_reg_drop", ""));
             if (isStreamRooted)
                 lines.push(...stCall("tds", "scr_stream_st_release", ""));
-            lines.push(`  call void @scr_obj_free_note()`);
-            if (traced) {
-                host.declare(`declare void @scr_cyc_free(ptr)`);
-                lines.push(`  call void @scr_cyc_free(ptr %o)`);
-            }
-            else {
-                host.declare(`declare void @free(ptr)`);
-                host.declare(`declare void @scr_weak_dispose(ptr)`);
-                lines.push(`  call void @scr_weak_dispose(ptr %o)`, `  call void @free(ptr %o)`);
-            }
+            lines.push(...emitObjectFree(host, traced));
         };
         if (meta.hierarchy) {
             // Public release: NULL/immortal checks, then dispatch through the
             // object's vtable so a base-typed release tears down the DERIVED
-            // object (scr_error_release's contract exactly).
-            defs.push(`define internal void @${mangleClassRelease(cls.name)}(ptr %o) ${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`, `}`, ``);
+            // object (scr_error_release's contract exactly). In a hierarchy the
+            // program owns end to end (no runtime root), every member shares the
+            // rc word and the header decision (cycle-analysis groups hierarchies),
+            // so a release that leaves the object alive is the same for every
+            // class: the inlinable fast path decrements without the indirect call,
+            // and only the last reference reaches the dispatching release.
+            const userRooted = meta.root.def.runtime !== true;
+            const dispatchName = userRooted
+                ? `${mangleClassRelease(cls.name)}_slow`
+                : mangleClassRelease(cls.name);
+            if (userRooted)
+                defs.push(...releaseFastPath(host, mangleClassRelease(cls.name), dispatchName, traced, `release ${cls.name}`), ``);
+            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`, `}`, ``);
             // Direct release (the vtable entry): the class's own teardown. The
             // caller already handled NULL/immortal.
             const reld = [
@@ -369,10 +391,8 @@ export function emitClassShapes(host, mod, metaMap) {
                 `  br i1 %dead, label %free, label %${traced ? "root" : "done"}`,
                 `free:`,
             ];
-            if (traced) {
-                host.declare(`declare void @scr_cyc_on_dead(ptr)`);
-                reld.push(`  call void @scr_cyc_on_dead(ptr %o)`);
-            }
+            if (traced)
+                reld.push(...cycleDeadLines(host, "teardown"));
             if (bounded) {
                 const destroy = `${mangleClassReleaseDirect(cls.name)}_destroy`;
                 const destroyBody = [
@@ -388,10 +408,8 @@ export function emitClassShapes(host, mod, metaMap) {
             else
                 teardown(reld);
             reld.push(`  br label %done`);
-            if (traced) {
-                host.declare(`declare void @scr_cyc_on_release(ptr)`);
-                reld.push(`root:`, `  call void @scr_cyc_on_release(ptr %o) ; possible cycle root; may collect`, `  br label %done`);
-            }
+            if (traced)
+                reld.push(`root:`, ...cycleRootLines(host, "done"));
             reld.push(`done:`, `  ret void`, `}`, ``);
             defs.push(...reld);
         }
@@ -402,21 +420,15 @@ export function emitClassShapes(host, mod, metaMap) {
         }
         // new: zeroed allocation, rc = 1, the vtable word on hierarchy
         // members, undefined-admitting union fields at the interned unit
-        // instance, alloc note. Traced shapes allocate with the collector
-        // header (scr_cyc_alloc zeroes and aborts on OOM itself).
+        // instance. Traced shapes allocate with the collector header; alloc.ts
+        // inlines the allocator fast paths and the alloc note.
         const nw = [
             `define internal ptr @${mangleClassNew(cls.name)}() ${FN_ATTRS} { ; new ${cls.name}`,
             `entry:`,
         ];
-        if (traced) {
-            host.declare(`declare ptr @scr_cyc_alloc(${host.sizeType}, ptr, ptr)`);
-            nw.push(`  %o = call ptr @scr_cyc_alloc(${host.sizeType} ${sizeOf}, ptr @${mangleClassTrace(cls.name)}, ptr @${mangleClassGcFree(cls.name)})`);
-        }
-        else {
-            host.declare(`declare ptr @calloc(${host.sizeType}, ${host.sizeType})`);
-            host.needOom();
-            nw.push(`  %o = call ptr @calloc(${host.sizeType} 1, ${host.sizeType} ${sizeOf})`, `  %isnull = icmp eq ptr %o, null`, `  br i1 %isnull, label %oom, label %ok`, `oom:`, `  call void @sc_oom()`, `  unreachable`, `ok:`);
-        }
+        nw.push(...emitObjectAlloc(host, sizeOf, traced
+            ? { trace: `@${mangleClassTrace(cls.name)}`, free: `@${mangleClassGcFree(cls.name)}` }
+            : null, meta.hierarchy ? 16 : 8));
         nw.push(`  store ${host.sizeType} 1, ptr %o`);
         if (meta.hierarchy) {
             nw.push(`  %vtp = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 1`, `  store ptr @${mangleVtInstance(cls.name)}, ptr %vtp`);
@@ -430,8 +442,8 @@ export function emitClassShapes(host, mod, metaMap) {
                 : cls.name;
             nw.push(`  %clsp = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 3`, `  store ptr ${host.cstr(displayName)}, ptr %clsp ; EventEmitter prefix display name`);
         }
-        nw.push(...undefFieldInits(host, meta));
-        nw.push(`  call void @scr_obj_alloc_note()`, `  ret ptr %o`, `}`, ``);
+        nw.push(...undefFieldInits(host, meta, nullable));
+        nw.push(`  ret ptr %o`, `}`, ``);
         defs.push(...nw);
         if (traced) {
             // trace: visit exactly the cycle-capable fields; gcFree: release
@@ -464,8 +476,7 @@ export function emitClassShapes(host, mod, metaMap) {
             untracedRefFields.forEach((f, i) => {
                 gf.push(`  %f${i} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${f.index}`, `  %v${i} = load ptr, ptr %f${i}`, `  call void ${releaseSym(host, f.type)}(ptr %v${i}) ; ${llvmCommentText(f.name)} (acyclic)`);
             });
-            host.declare(`declare void @scr_cyc_free(ptr)`);
-            gf.push(`  call void @scr_obj_free_note()`, `  call void @scr_cyc_free(ptr %o)`, `  ret void`, `}`, ``);
+            gf.push(...emitObjectFree(host, true), `  ret void`, `}`, ``);
             defs.push(...gf);
         }
     }