@scriptc/compiler 0.4.1 → 0.4.2

package/dist/backend/llvm/emitter.js

@@ -1,3 +1,4 @@
+import { relieveHeapPressure } from "../../heap-pressure.js";
 import { wasmBoundsChecks } from "./wasm-modules.js";
 import { jsTruthy } from "./jsval.js";
 import { JsIcSites } from "../../ir/js-ic.js";
@@ -12,7 +13,7 @@ import { createHash } from "node:crypto";
 import { endsWithJump, matchFieldSelfConcat, readsArraySlot, streamTypedRefEligible, undefinedArmTag, } from "../../ir/analysis.js";
 import { loopTestsEveryIteration } from "../loop-polls.js";
 import { isDynTypedRefType, isRefCounted, isUnitType, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_EVENT_CLASS, RUNTIME_EVENT_TARGET_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeEquals, typeKey, VOID, classJsName, } from "../../ir/ir.js";
-import { moduleRuntimeFeatures, moduleUsesDynBuiltinStream, moduleUsesMockTimers, } from "../../ir/runtime-features.js";
+import { moduleRuntimeFeatures } from "../../ir/runtime-features.js";
 import { captureFreeFunctions, observesStacks } from "../stack-observations.js";
 import {} from "./dense-array-loops.js";
 import { findInitializedByteLoopBindings } from "./byte-windows.js";
@@ -90,7 +91,7 @@ import { emitChildProcessLibCall, emitAsyncContextLibCall, emitProcessLibCall, e
 import { emitStreamLibCall } from "./lib-stream.js";
 import { emitNetworkHttpLibCall } from "./lib-network.js";
 import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall, } from "./lib-dispatch.js";
-import { buildClassGraph, classMembershipIntervals, classFieldIndex, classPreLines, classStructSym, programLifetimeClass, } from "./classes.js";
+import { assignCompactLayouts, buildClassGraph, classFieldTypes, classMembershipIntervals, classFieldIndex, compactRefLoadLines, compactRefStoreLines, classPreLines, classStructSym, programLifetimeClass, } from "./classes.js";
 import { LifetimeRegions, REGION_TYPES } from "./regions.js";
 import { LlDyn, recordDynKeepsIdentity } from "./dyn.js";
 import { VirtualBorrows } from "./virtual-borrows.js";
@@ -99,7 +100,7 @@ import { LlWalkers } from "./walkers.js";
 import { isObjectArm, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions } from "./nullable-unions.js";
 import { emitNullablePresent, emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { emitConcatInputs, emitMixedConcat, numberPart, stringParts, } from "./string-construction.js";
-import { arrNewCall, boxAccess, boxNewCall, boxReleaseSym, computeTraced, emitInlineRcHelpers, emitNullableRetainWrappers, emitShapeUnionHelpers, FN_ATTRS, inlineRcDecls, llFieldType, mapFlagsOffset, releaseSym, retainSym, traceArg, vAdapters, } from "./shapes.js";
+import { arrNewCall, boxAccess, elemAccess, boxNewCall, boxReleaseSym, computeTraced, emitInlineRcHelpers, emitNullableRetainWrappers, emitShapeUnionHelpers, FN_ATTRS, inlineRcDecls, llFieldType, mapFlagsOffset, releaseSym, retainSym, traceArg, vAdapters, } from "./shapes.js";
 import { INLINE_LITERAL_BYTES } from "./string-literal-equality.js";
 import { emitFfiCallbackDefs, emitLibDefs, emitModuleParts, emitParts, helperDefs, } from "./emit-module.js";
 import { emitLoopCopies, emitSpeculativeWrite, emitStmtBody, emitStringSelfConcatAssign, emitSwitch, emitTryCatch, } from "./emit-statements.js";
@@ -131,6 +132,14 @@ export function ffiCallbackDummyLl(callback) {
             return "i32 0";
     }
 }
+/** LlvmTargetOptions.lowRegion for an executable: Linux targets without
+ * sanitizers, whose address space below 32 GiB is free (ASan keeps its
+ * shadow memory there; other systems map their own images and libraries
+ * there). `platform` is a target platform (`linux`, `darwin`, `win32`,
+ * `wasi`). */
+export function lowRegionTarget(platform, sanitize) {
+    return platform === "linux" && !sanitize;
+}
 export function emitLlvmModule(input, options = {}) {
     // Facts are keyed by node identity: emit the same module whether it was
     // lowered in memory or read back from its serialized form.
@@ -142,6 +151,8 @@ export function emitLlvmModule(input, options = {}) {
 }
 /** Keep large translation units below the host's single-string limit. */
 export function emitLlvmModuleSource(input, options = {}) {
+    // IR validation, contracts and the frontend's disposal run after lowering without checks.
+    relieveHeapPressure(true);
     const mod = unshareNodes(input);
     const parts = new LlEmitter(options.debugSources === undefined
         ? addRecordResultEntries(scalarizeNumericRecords(specializeCallbackCalls(specializeNumericCalls(foldConstantGlobals(copyStableCaptures(resolveSelfCaptures(hoistFinalFieldReads(freezeInitOnlyGlobals(dropUnwrittenPropertyBags(mod)))))), mangleFunction), mangleFunction)))
@@ -231,6 +242,34 @@ function mentionsLocal(e, localId) {
     expr(e);
     return found;
 }
+/** The IR nodes in `body` that name local `id`: its declaration, reads,
+ * writes and closure captures. */
+function countLocalMentions(body, id) {
+    let count = 0;
+    const visit = (node) => {
+        if (node === null || typeof node !== "object")
+            return;
+        if (Array.isArray(node)) {
+            for (const item of node)
+                visit(item);
+            return;
+        }
+        const record = node;
+        if (record["localId"] === id)
+            count++;
+        const captures = record["captures"];
+        if (Array.isArray(captures))
+            for (const c of captures)
+                if (c === id ||
+                    (typeof c === "object" && c !== null && c.localId === id))
+                    count++;
+        for (const [key, value] of Object.entries(record))
+            if (key !== "type" && key !== "loc" && key !== "captures")
+                visit(value);
+    };
+    visit(body);
+    return count;
+}
 export class LlEmitter {
     mod;
     localArrayReads = new Map();
@@ -254,6 +293,13 @@ export class LlEmitter {
     integerArrayBindings = new Set();
     fieldAliasTags = new Map();
     fieldPointerTags = new Map();
+    /** The field pointers (classFieldPtr) of this function whose fields hold
+     * 32-bit references to compact class instances (LlClassMeta.compressed):
+     * loadField/loadRef decode them and storeField/storeRef encode them. */
+    compressedFieldPtrs = new Set();
+    /** Whether a class has compressed fields: main reserves the region before
+     * compiled code runs (scr_plr_init). */
+    usesCompactRefs = false;
     /** Native class fields with different property names cannot occupy the
      * same slot of one object. Inherited views of the same property share a
      * tag. Array storage has its own disjoint categories; untagged runtime
@@ -432,6 +478,12 @@ export class LlEmitter {
     callLifetimes;
     constantCallbacks;
     currentConstantCallbacks = new Map();
+    /** Callback bindings whose closures an enclosing callback loop version
+     * proved to hold their known function: calls take the direct entry with
+     * no fallback (emitCallbackVersionedLoop). */
+    knownCallbacks = new Set();
+    callbackVersioning = new Set();
+    callbackVersionsEnabled = false;
     stackCallbacks;
     receiverReaders;
     stackCaptures;
@@ -513,9 +565,15 @@ export class LlEmitter {
     /** Fiberless async functions a stackless coroutine body awaits directly;
      * each gets an inline await entry (emitCoroInlineAwait). */
     inlineAwaitCallees = new Set();
+    /** Stackless async functions some coroutine body awaits directly: each
+     * gets a direct spawn entry (emitCoroDirectAwait). */
+    directAwaitCallees = new Set();
     /** The async functions whose bodies never suspend and that a direct
      * await may enter in place (selectStacklessAsync). */
     inlineAwaitable = new Set();
+    /** Locals whose array literal emitStmts left for the `await Promise.all`
+     * that reads them (deferredPromiseAllLocal). */
+    deferredPromiseAllEntries = new Map();
     /** The promise a `return` emitted past its finally regions already
      * produced for its adopting await (borrowed from the return's parked
      * slot); that await takes it instead of evaluating its operand. */
@@ -531,13 +589,16 @@ export class LlEmitter {
     /** The program calls mock.timers members (moduleUsesMockTimers): timer
      * calls emit scr_test.c's mock-aware entry points. */
     mockTimers;
-    schedulesInContextValue = undefined;
+    runtimeFeaturesValue;
+    /** The module's runtime features (moduleRuntimeFeatures), found with one
+     * walk of the module the first time any of them is read. */
+    get runtimeFeatures() {
+        return (this.runtimeFeaturesValue ??= moduleRuntimeFeatures(this.mod));
+    }
     /** Whether timer and tick scheduling goes through the *_als entry
      * points (RuntimeFeatures asyncContext). */
     get schedulesInContext() {
-        if (this.schedulesInContextValue === undefined)
-            this.schedulesInContextValue = moduleRuntimeFeatures(this.mod).asyncContext;
-        return this.schedulesInContextValue;
+        return this.runtimeFeatures.asyncContext;
     }
     /** Emitted ref-kind resolve thunks for new Promise, interned per inner
      * typeKey → thunk symbol. */
@@ -553,10 +614,9 @@ export class LlEmitter {
     /** Identity-preserving static→dyn capsules for program classes and Web
      * APIs whose values remain directly observable. */
     liveDynRefAdapters = new Map();
-    dynBuiltinStreamUse;
     /** See moduleUsesDynBuiltinStream. */
     get usesDynBuiltinStream() {
-        return (this.dynBuiltinStreamUse ??= moduleUsesDynBuiltinStream(this.mod));
+        return this.runtimeFeatures.dynBuiltinStream;
     }
     /** Runtime-arm dispatchers for live union values. */
     liveDynUnionRefAdapters = new Map();
@@ -657,14 +717,28 @@ export class LlEmitter {
     captureIds = new Set();
     /** Active induction bindings retain their width independently of size_t. */
     integerLoopBindings = new Map();
+    /** Constant number locals whose latest emitted declaration stored an
+     * exact integer beside the double, such as `const j = i * 4` in a
+     * typed-array loop version: an i64 slot and the integer's range. */
+    integerTemps = new Map();
+    /** Integer temps are kept only in optimized synchronous functions: an
+     * async or generator body resumes with its locals in its frame, which
+     * an entry alloca is not part of. */
+    integerTempsEnabled = false;
     countedLoopsEnabled = false;
     /** Speculative integer loops (speculative-integers.ts) run in this function. */
     speculativeLoopsEnabled = false;
     /** The fast copy of a speculative integer loop being emitted: its
      * integer-computed writes and where each resumes in the ordinary copy. */
     speculation = null;
+    /** Speculative loop sites numbered so far in the module. */
+    speculativeLoopSites = 0;
     /** The ordinary copy being emitted: resume labels still to place. */
     speculationResume = null;
+    /** Run once at the top of the next loop copy's header
+     * (`enterLoopHeader`): records the ordinary copy's header, or sends the
+     * third copy's header there. */
+    speculationHeader = null;
     /** The function being emitted, for speculative globals. */
     speculativeFunction = "";
     /** Every function that writes each number global (computed on demand). */
@@ -696,6 +770,9 @@ export class LlEmitter {
      * guard already passed. */
     provenCountedGuards = new Set();
     bytesBounds = new Set();
+    /** Worker programs: typed-array accesses whose views an enclosing version
+     * guard proved thread-owned. */
+    bytesOwned = new Set();
     integerViews = new Map();
     /** Module globals the current function owns outright (initializer
      * bindings): their function-local slot, which stands in for the global. */
@@ -752,21 +829,25 @@ export class LlEmitter {
         this.mod = mod;
         this.stackTraces = observesStacks(mod);
         this.nullableUnions = new NullableUnions(mod, options.debugSources === undefined);
-        this.mockTimers = moduleUsesMockTimers(mod);
+        this.mockTimers = this.runtimeFeatures.mockTimers;
         this.debug =
             options.debugSources === undefined
                 ? null
                 : new LlvmDebugInfo(mod.sourceFile, options.debugSources, options.pointerBits, mod.unions, this.nullableUnions.armTypes());
         this.constantNumericTables = findConstantNumericTables(mod);
         this.initializerBindings = findInitializerBindings(mod);
-        this.int32Slots = analyzeInt32Slots(mod);
+        // One walk finds the dynamic field stores every analysis below consults.
         const dynamicStores = dynamicFieldStores(mod);
+        this.int32Slots = analyzeInt32Slots(mod, {
+            dynamicStores,
+            initializerBindings: this.initializerBindings,
+        });
         this.liveViewsReadOnly =
             mod.lib === undefined && !dynamicStores.all && dynamicStores.names.size === 0;
         this.int32Abis = this.debug === null ? findInt32Abis(mod, this.int32Slots) : new Map();
         this.immortalGlobals = new Set(mod.contracts?.immortalGlobals ?? []);
         this.programLifetime = new Set(mod.contracts?.programLifetime ?? []);
-        this.finalFields = analyzeFinalFields(mod);
+        this.finalFields = analyzeFinalFields(mod, false, dynamicStores);
         this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
         this.ffiExtendNarrowIntegers =
             options.wasi === true || ffiExtendsNarrowIntegers(options.targetTriple);
@@ -837,7 +918,7 @@ export class LlEmitter {
         this.unframedFunctions = this.stackTraces
             ? captureFreeFunctions(mod, this.stackChecks, this.publishedTypes)
             : new Set();
-        this.immutableFields = computeImmutableFields(mod);
+        this.immutableFields = computeImmutableFields(mod, dynamicStores);
         this.constructorFunctions = new Set((mod.classes ?? []).map((c) => `%${c.name}.constructor`));
         this.indirectMayThrow = mt.indirect || mod.workers === true;
         for (const cls of mod.classes ?? []) {
@@ -941,7 +1022,7 @@ export class LlEmitter {
         this.receiverReaders = new AmbientReceiverReaders(this.fnByName);
         this.stackCaptures = new StackCaptures(this.fnByName, this.callLifetimes, this.stackCallbacks);
         this.lazyCaptures = new LazyCaptures(this.fnByName);
-        const traced = computeTraced(mod);
+        const traced = computeTraced(mod, dynamicStores);
         this.tracedShapes = traced.shapes;
         this.tracedUnions = traced.unions;
         // A shape union's value is whichever record it holds, and the collector
@@ -1068,6 +1149,37 @@ export class LlEmitter {
                 classDefinitions: (cls, sizeOf) => regions.classDefs(cls, sizeOf),
             };
         }
+        // ProgramLifetime hierarchies count nothing: their instances get the
+        // 32-bit header and packed fields (classes.ts LlClassMeta.compact),
+        // except where regions count them or a slot word follows the header.
+        if (this.sizeType === "i64" && mod.lifetimeRegions !== true)
+            assignCompactLayouts(this.classMeta, (root) => programLifetimeClass(this.shapeHost, root) && !root.threadSlot, (cls) => classFieldTypes(this.shapeHost, cls, this.int32Slots), 
+            // Executables whose region lies below 32 GiB hold compact class
+            // instances there (scr_plr_alloc), so fields referring to one store
+            // a 32-bit reference: the field's type, the class of a
+            // `C | undefined` or `C | null` pointer, or the reference arm of a
+            // nullable pointer field, is a compact class. `C | null | undefined`
+            // keeps the pointer: its null is a sentinel outside the region.
+            mod.lib === undefined && options.lowRegion === true
+                ? (cls, i, isCompact) => {
+                    const f = cls.fields[i];
+                    if (this.inlineUnions.classField(cls.name, f.name))
+                        return false;
+                    const t = f.type;
+                    if (t.kind === "object")
+                        return isCompact(t.className);
+                    if (t.kind !== "union")
+                        return false;
+                    const single = this.nullableUnions.single(t.unionId);
+                    if (single !== null)
+                        return (single.nullTag < 0 &&
+                            single.arm.kind === "object" &&
+                            isCompact(single.arm.className));
+                    const nullable = this.nullableFields.get(cls.name, f.name);
+                    return nullable !== null && isCompact(nullable.arm.className);
+                }
+                : undefined);
+        this.usesCompactRefs = [...this.classMeta.values()].some((m) => m.compressed.some(Boolean));
         for (const [name, rec] of RUNTIME_ERROR_CLASSES) {
             const meta = this.classMeta.get(name);
             if (!meta)
@@ -1330,16 +1442,33 @@ export class LlEmitter {
             this.fnDefText.set(fn.name, coroText);
         });
     }
+    /** Whether a fiberless body running on its caller's stack needs the
+     * frame scr_async_inline_enter/exit keep: it isolates the Error.stack
+     * frame chain, which only stack-observing programs push, as a fresh fiber
+     * would. Other programs run the body with a plain call. The body runs in
+     * its caller's AsyncLocalStorage context either way, as Node runs an async
+     * body up to its first await. The frame also counts the bodies running on
+     * a fiber's stack for the runtime's trap on a fiberless body that
+     * suspends. */
+    get fiberlessFrames() {
+        return this.stackTraces;
+    }
     /** The spawn wrapper of a fiberless async function: runs the body on the
-     * caller's stack between scr_async_inline_enter/leave and settles the
-     * fresh promise from its outcome — the fiber trampoline's epilogue,
-     * without the fiber. */
+     * caller's stack (between scr_async_inline_enter/leave when
+     * fiberlessFrames) and settles a fresh promise from its outcome — the
+     * fiber trampoline's epilogue, without the fiber. */
     emitFiberlessAsyncSpawn(fn, spawnParams) {
         const ret = fn.returnType;
         const retTy = this.llType(ret);
         const lifted = fn.captures !== undefined;
-        this.declare(`declare void @scr_async_inline_enter(ptr)`);
-        this.declare(`declare ptr @scr_async_inline_leave(ptr)`);
+        const framed = this.fiberlessFrames;
+        if (framed) {
+            this.declare(`declare void @scr_async_inline_enter(ptr)`);
+            this.declare(`declare ptr @scr_async_inline_leave(ptr)`);
+        }
+        else {
+            this.declare(`declare ptr @scr_promise_new()`);
+        }
         this.declare(`declare void @scr_promise_reject_pending(ptr)`);
         if (lifted) {
             this.declare(`declare ptr @scr_closure_retain_v(ptr)`);
@@ -1349,15 +1478,17 @@ export class LlEmitter {
         const out = [
             `define internal ptr @${mangleAsyncSpawn(fn.name)}(${spawnParams.join(", ")}) ${FN_ATTRS} { ; fiberless ${fn.name}`,
             `entry:`,
-            `  %frame = alloca { ptr, ptr }`,
+            ...(framed ? [`  %frame = alloca { ptr, ptr }`] : []),
             // The fiber path holds +1 on a lifted environment for the body's
             // duration (packed, released by the trampoline); keep that lifetime.
             ...(lifted ? [`  %env = call ptr @scr_closure_retain_v(ptr %a0)`] : []),
-            `  call void @scr_async_inline_enter(ptr %frame)`,
+            ...(framed ? [`  call void @scr_async_inline_enter(ptr %frame)`] : []),
             retTy === "void" ? `  ${bodyCall}` : `  %r = ${bodyCall}`,
             ...(lifted ? [`  call void @scr_closure_release(ptr %a0)`] : []),
             ...this.pendingTestLines("%pend"),
-            `  %p = call ptr @scr_async_inline_leave(ptr %frame)`,
+            framed
+                ? `  %p = call ptr @scr_async_inline_leave(ptr %frame)`
+                : `  %p = call ptr @scr_promise_new()`,
             `  br i1 %pend, label %thrown, label %clean`,
             `clean:`,
             ...this.asyncFulfillLines(ret, "%p"),
@@ -1397,24 +1528,94 @@ export class LlEmitter {
             return false;
         return fn.captures === undefined;
     }
+    /** Whether a stackless coroutine body's `await f(...)` may await f's
+     * fiber record instead of its promise (emitCoroDirectAwait): f is a
+     * stackless async function whose direct call an await-call entry could
+     * take. The await consumes the promise, so nothing else can observe it.
+     * Worker programs keep the promise for their stop checkpoint. */
+    directAwaitEligible(fnName) {
+        if (this.wasi || this.mod.workers === true || this.currentCoro?.kind !== "async")
+            return false;
+        const fn = this.fnByName.get(fnName);
+        if (fn === undefined || fn.async !== true || fn.generator !== undefined)
+            return false;
+        if (!this.stacklessAsync.has(fnName) || fn.captures !== undefined)
+            return false;
+        if (fn.returnType.kind === "dyn")
+            return false;
+        return fn.asyncCacheGlobal === undefined && fn.asyncCycleCacheGlobal === undefined;
+    }
+    /** A stackless coroutine body's `await f(...)` of a stackless f, without
+     * f's promise object: f's prefix runs as the spawn of a fiber record that
+     * keeps the promise inside. A body still running wakes this coroutine
+     * when it finishes, where its promise's settlement would wake its one
+     * waiter; a finished one takes the settled await's turn. The result (or
+     * the rejection, re-thrown) comes out of the record, which goes. */
+    emitCoroDirectAwait(call, type) {
+        const coro = this.currentCoro;
+        if (coro === null)
+            throw new InternalCompilerError("llvm emitter bug: direct await outside a coroutine");
+        const B = this.B;
+        const record = emitCallExpr(this, call, "direct").name;
+        this.declare(`declare zeroext i1 @scr_coro_direct_prepare(ptr, ptr)`);
+        const suspend = B.tmp();
+        B.line(`${suspend} = call zeroext i1 @scr_coro_direct_prepare(ptr ${coro.self}, ptr ${record})`);
+        const park = B.newLabel("await.suspend");
+        const ready = B.newLabel("await.ready");
+        B.condBr(suspend, park, ready);
+        B.startBlock(park);
+        this.emitCoroSuspendPrepared();
+        B.br(ready);
+        B.startBlock(ready);
+        if (type.kind === "void") {
+            this.declare(`declare void @scr_coro_direct_void(ptr)`);
+            B.line(`call void @scr_coro_direct_void(ptr ${record})`);
+            this.emitPendingCheck();
+            return { name: "", type };
+        }
+        const t = B.tmp();
+        if (type.kind === "f64" || type.kind === "date") {
+            this.declare(`declare double @scr_coro_direct_f64(ptr)`);
+            B.line(`${t} = call double @scr_coro_direct_f64(ptr ${record})`);
+        }
+        else if (type.kind === "bool") {
+            this.declare(`declare zeroext i1 @scr_coro_direct_bool(ptr)`);
+            B.line(`${t} = call zeroext i1 @scr_coro_direct_bool(ptr ${record})`);
+        }
+        else if (type.kind === "string") {
+            this.declare(`declare ptr @scr_coro_direct_str(ptr)`);
+            B.line(`${t} = call ptr @scr_coro_direct_str(ptr ${record})`);
+        }
+        else {
+            this.declare(`declare ptr @scr_coro_direct_ref(ptr)`);
+            B.line(`${t} = call ptr @scr_coro_direct_ref(ptr ${record})`);
+        }
+        const out = this.own({ name: this.adoptHeap(t, type), type });
+        this.emitPendingCheck();
+        return out;
+    }
     /** The inline await entry of a fiberless async function (`sc_ai_*`): its
-     * body on the caller's stack between scr_async_inline_enter/exit, as in
-     * its spawn wrapper, returning the result and leaving a throw pending for
-     * the awaiting coroutine (emitCoroInlineAwait). */
+     * body on the caller's stack (between scr_async_inline_enter/exit when
+     * fiberlessFrames), as in its spawn wrapper, returning the result and
+     * leaving a throw pending for the awaiting coroutine (emitCoroInlineAwait). */
     emitAsyncInlineAwaitCall(fn) {
         const retTy = this.llType(fn.returnType);
         const params = fn.params.map((p, i) => `${this.llType(p.type)} %a${i}`);
         const args = params.join(", ");
-        this.declare(`declare void @scr_async_inline_enter(ptr)`);
-        this.declare(`declare void @scr_async_inline_exit(ptr)`);
+        const framed = this.fiberlessFrames;
+        if (framed) {
+            this.declare(`declare void @scr_async_inline_enter(ptr)`);
+            this.declare(`declare void @scr_async_inline_exit(ptr)`);
+        }
         const bodyCall = `call ${retTy} @${mangleFunction(fn.name)}(${args})`;
         return [
             `define internal ${retTy} @${mangleAsyncInlineAwaitCall(fn.name)}(${args}) ${FN_ATTRS} { ; inline await ${fn.name}`,
             `entry:`,
-            `  %frame = alloca { ptr, ptr }`,
-            `  call void @scr_async_inline_enter(ptr %frame)`,
+            ...(framed
+                ? [`  %frame = alloca { ptr, ptr }`, `  call void @scr_async_inline_enter(ptr %frame)`]
+                : []),
             retTy === "void" ? `  ${bodyCall}` : `  %r = ${bodyCall}`,
-            `  call void @scr_async_inline_exit(ptr %frame)`,
+            ...(framed ? [`  call void @scr_async_inline_exit(ptr %frame)`] : []),
             retTy === "void" ? `  ret void` : `  ret ${retTy} %r`,
             `}`,
             ``,
@@ -1457,6 +1658,193 @@ export class LlEmitter {
         this.emitPendingCheck();
         return value;
     }
+    /** The entries of `Promise.all(arg)` that a stackless coroutine body's
+     * await may run in place (emitCoroInlinePromiseAll): `arg` is a non-empty
+     * array literal, or the local whose declaration emitStmts deferred to this
+     * await (deferredPromiseAllEntries), whose every entry is a call to a
+     * never-suspending async function, and the result is an array. Null
+     * otherwise. Consumes a deferred local's entries. */
+    inlinePromiseAllEntries(all) {
+        if (all.name !== "promise.all" || all.type.kind !== "promise")
+            return null;
+        if (all.type.inner.kind !== "array")
+            return null;
+        const arg = all.args[0];
+        if (arg?.kind === "varRef") {
+            const deferred = this.deferredPromiseAllEntries.get(arg.localId);
+            if (deferred === undefined)
+                return null;
+            this.deferredPromiseAllEntries.delete(arg.localId);
+            return deferred;
+        }
+        return arg?.kind === "arrayLit" && this.promiseAllInlineable(arg) ? arg : null;
+    }
+    /** Whether every entry of `entries` is a call an await could run in place
+     * (inlineAwaitEligible) that yields its promise's inner type. */
+    promiseAllInlineable(entries) {
+        if (entries.elems.length === 0 || (entries.spreads?.length ?? 0) > 0)
+            return false;
+        if (entries.type.kind !== "array" || entries.type.elem.kind !== "promise")
+            return false;
+        const inner = entries.type.elem.inner;
+        return entries.elems.every((el) => {
+            if (el.kind !== "call" || !this.inlineAwaitEligible(el.callee))
+                return false;
+            const callee = this.fnByName.get(el.callee);
+            return typeEquals(callee.returnType, inner) && !this.callLifetimes.borrowed.has(el.callee);
+        });
+    }
+    /** Whether `stmts[i]` declares a local holding an array literal that only
+     * `stmts[i + 1]` reads, as the operand of `await Promise.all(local)` that
+     * runs first in that statement and may run its entries in place. Nothing
+     * runs between the literal and the await, so the await evaluates the
+     * literal itself (inlinePromiseAllEntries). Debug builds keep the local. */
+    deferredPromiseAllLocal(stmts, i) {
+        const decl = stmts[i];
+        const next = stmts[i + 1];
+        if (this.debug !== null || decl?.kind !== "varDecl" || decl.init?.kind !== "arrayLit")
+            return null;
+        if (this.currentCoro?.kind !== "async" || next === undefined)
+            return null;
+        const operand = next.kind === "varDecl"
+            ? next.init
+            : next.kind === "exprStmt"
+                ? next.expr
+                : next.kind === "assign"
+                    ? next.value
+                    : null;
+        if (operand?.kind !== "awaitExpr" || operand.adopt === true)
+            return null;
+        const all = operand.value;
+        if (all.kind !== "intrinsic" || all.name !== "promise.all" || all.type.kind !== "promise")
+            return null;
+        if (all.type.inner.kind !== "array")
+            return null;
+        const arg = all.args[0];
+        if (arg?.kind !== "varRef" || arg.localId !== decl.localId)
+            return null;
+        if (!this.promiseAllInlineable(decl.init))
+            return null;
+        if (this.currentLocals.get(decl.localId)?.boxed)
+            return null;
+        // The declaration and this read are the local's only mentions.
+        return countLocalMentions(this.currentFunctionBody, decl.localId) === 2 ? decl.init : null;
+    }
+    /** A stackless coroutine body's `await Promise.all([f(...), ...])` of
+     * never-suspending calls, with Promise.all's turns and without its
+     * promises: the entries run in place in order and their values fill the
+     * result array. Promise.all queues one reaction job per entry, back to
+     * back, and the last of them settles the result, whose await then takes a
+     * turn: here one turn stands for the entries' jobs and a second for the
+     * await. A throwing entry becomes the rejection the await re-throws from
+     * its turn; the remaining entries still run, and later throws are handled
+     * rejections, as Promise.all's subscriptions make them. */
+    emitCoroInlinePromiseAll(entries, type) {
+        if (type.kind !== "array")
+            throw new InternalCompilerError("llvm emitter bug: inline Promise.all result");
+        const B = this.B;
+        const elem = type.elem;
+        const acc = elemAccess(elem);
+        const values = B.tmp();
+        // Up to three values fit in the array's own block (scr_arr_new_*_small).
+        const small = entries.elems.length <= 3;
+        B.line(`${values} = ${arrNewCall(this.shapeHost, elem, small ? "0" : String(entries.elems.length), small)}`);
+        const out = this.own({ name: values, type });
+        this.declare(`declare ptr @scr_promise_new()`);
+        this.declare(`declare void @scr_promise_reject_pending(ptr)`);
+        this.declare(`declare void @scr_promise_mark_handled(ptr)`);
+        const promiseType = entries.type.kind === "array" ? entries.type.elem : type;
+        // Each entry's rejection, owned by the frame: unobserved until the
+        // entries have all run, as Promise.all subscribes only then, so an
+        // entry argument's synchronous throw leaves them unhandled.
+        const rejections = [];
+        for (const entry of entries.elems) {
+            if (entry.kind !== "call")
+                throw new InternalCompilerError("llvm emitter bug: inline Promise.all entry");
+            const slot = B.tmp();
+            B.entryAllocas.push(`${slot} = alloca ptr`);
+            B.line(`store ptr null, ptr ${slot}`);
+            this.ownSlot(slot, promiseType);
+            rejections.push(slot);
+            const value = emitCallExpr(this, entry, "inline");
+            const thrown = B.tmp();
+            for (const line of this.pendingTestLines(thrown))
+                B.line(line.trim());
+            const clean = B.newLabel("pa.clean");
+            const rejected = B.newLabel("pa.rejected");
+            const next = B.newLabel("pa.next");
+            B.condBr(thrown, rejected, clean);
+            B.startBlock(clean);
+            if (acc === "ref")
+                this.toHeap(value);
+            this.arrPush(values, acc, value.name);
+            B.br(next);
+            B.startBlock(rejected);
+            const promise = B.tmp();
+            B.line(`${promise} = call ptr @scr_promise_new()`);
+            B.line(`call void @scr_promise_reject_pending(ptr ${promise})`);
+            B.line(`store ptr ${promise}, ptr ${slot}`);
+            B.br(next);
+            B.startBlock(next);
+        }
+        // Promise.all's subscriptions handle every rejection, and the first
+        // (in entry order) rejects the result.
+        let first = "null";
+        for (let k = rejections.length - 1; k >= 0; k--) {
+            const slot = rejections[k];
+            const rejection = B.tmp();
+            const present = B.tmp();
+            B.line(`${rejection} = load ptr, ptr ${slot}`);
+            B.line(`${present} = icmp ne ptr ${rejection}, null`);
+            const mark = B.newLabel("pa.handled");
+            const after = B.newLabel("pa.unrejected");
+            B.condBr(present, mark, after);
+            B.startBlock(mark);
+            B.line(`call void @scr_promise_mark_handled(ptr ${rejection})`);
+            B.br(after);
+            B.startBlock(after);
+            const chosen = B.tmp();
+            B.line(`${chosen} = select i1 ${present}, ptr ${rejection}, ptr ${first}`);
+            first = chosen;
+        }
+        // The entries' reaction jobs.
+        this.emitCoroAwait(null);
+        const failed = B.tmp();
+        B.line(`${failed} = icmp ne ptr ${first}, null`);
+        const fulfilled = B.newLabel("pa.fulfilled");
+        const rejected = B.newLabel("pa.reject");
+        const join = B.newLabel("pa.join");
+        B.condBr(failed, rejected, fulfilled);
+        B.startBlock(fulfilled);
+        this.emitCoroAwait(null);
+        B.br(join);
+        B.startBlock(rejected);
+        this.declare(`declare void @scr_coro_await_void(ptr)`);
+        this.emitCoroAwait(first);
+        B.line(`call void @scr_coro_await_void(ptr ${first})`);
+        B.br(join);
+        B.startBlock(join);
+        // The rejections are released here, only where an entry threw, rather
+        // than by the frame, which releases each slot whether or not it holds a
+        // promise.
+        this.declare(`declare void @scr_promise_release(ptr)`);
+        for (const slot of rejections) {
+            const rejection = B.tmp();
+            const present = B.tmp();
+            B.line(`${rejection} = load ptr, ptr ${slot}`);
+            B.line(`${present} = icmp ne ptr ${rejection}, null`);
+            const release = B.newLabel("pa.release");
+            const after = B.newLabel("pa.released");
+            B.condBr(present, release, after);
+            B.startBlock(release);
+            B.line(`call void @scr_promise_release(ptr ${rejection})`);
+            B.br(after);
+            B.startBlock(after);
+        }
+        this.disownSlots(rejections.map((ptr) => ({ ptr })));
+        this.emitPendingCheck();
+        return out;
+    }
     emitAsyncAwaitCall(fn, argPackLines, adopt = false) {
         return emitAsyncAwaitCall(this, fn, argPackLines, adopt);
     }
@@ -1998,8 +2386,10 @@ export class LlEmitter {
      * releases the dummy (NULL for refcounted kinds) harmlessly. A scalar
      * call result of the function's return type may be passed as the unwind's
      * dummy value (see emitUnwind). `poll` marks a worker termination poll
-     * (function entry or loop budget), whose test must stay ordered. */
-    emitPendingCheck(passThrough, poll = false) {
+     * (function entry or loop budget), whose test must stay ordered. A
+     * `guard` (an i1) limits the test to the paths where it is true: false
+     * where the joined call could not have left anything pending. */
+    emitPendingCheck(passThrough, poll = false, guard) {
         const through = passThrough !== undefined &&
             this.llType(passThrough.type) === this.llType(this.currentReturnType) &&
             (passThrough.type.kind === "f64" || passThrough.type.kind === "bool")
@@ -2008,6 +2398,13 @@ export class LlEmitter {
         const B = this.B;
         if (B.isTerminated())
             return;
+        let skip;
+        if (guard !== undefined) {
+            const test = B.newLabel("exc.t");
+            skip = B.newLabel("exc.n");
+            B.condBr(guard, test, skip);
+            B.startBlock(test);
+        }
         if (this.mod.lib !== undefined) {
             this.declare(`declare zeroext i1 @scr_exc_pending()`);
             const p = B.tmp();
@@ -2018,6 +2415,10 @@ export class LlEmitter {
             B.startBlock(lu);
             this.emitUnwind(through);
             B.startBlock(lk);
+            if (skip !== undefined) {
+                B.br(skip);
+                B.startBlock(skip);
+            }
             return;
         }
         // Executables test the active exception cell's kind inline (its first
@@ -2094,6 +2495,10 @@ export class LlEmitter {
         B.startBlock(lu);
         this.emitUnwind(through);
         B.startBlock(lk);
+        if (skip !== undefined) {
+            B.br(skip);
+            B.startBlock(skip);
+        }
     }
     /** After a runtime call that ALWAYS leaves an exception pending (the
      * compiler-resolved Node throws): the pending test would always answer
@@ -2641,13 +3046,45 @@ export class LlEmitter {
      * 1 on hierarchy members, then the flattened field list. Runtime error
      * classes GEP through %ScrError (their structs live in the runtime; the
      * def's [name, message, %code, %cause] order matches the layout). */
-    classFieldPtr(objName, className, field) {
+    classFieldPtr(objName, className, field, refs = "pointer") {
         const meta = this.classMetaOf(className);
-        const { index, type } = classFieldIndex(meta, field);
+        const { index, type, compressed } = classFieldIndex(meta, field, refs);
         const p = this.B.tmp();
         this.B.line(`${p} = getelementptr inbounds %${classStructSym(className)}, ptr ${objName}, i64 0, i32 ${index}`);
         this.markFieldPointer(p, field);
-        return { ptr: p, type, inline: this.inlineUnions.classField(className, field) };
+        if (compressed)
+            this.compressedFieldPtrs.add(p);
+        return { ptr: p, type, inline: this.inlineUnions.classField(className, field), compressed };
+    }
+    /** Loads the reference a field pointer addresses: a pointer, or the
+     * decoded 32-bit reference of a compressed field (compressedFieldPtrs).
+     * `tagged`: the load carries the field's alias tags. */
+    loadRef(ptr, tagged = true) {
+        const B = this.B;
+        const v = B.tmp();
+        const tags = tagged ? this.fieldAliasAttachment(ptr) : "";
+        if (!this.compressedFieldPtrs.has(ptr)) {
+            B.line(`${v} = load ptr, ptr ${ptr}${tags}`);
+            return v;
+        }
+        const idx = B.tmp();
+        B.line(`${idx} = load i32, ptr ${ptr}${tags}`);
+        for (const line of compactRefLoadLines(idx, v, `${v}.r`))
+            B.line(line.trimStart());
+        return v;
+    }
+    /** Stores `value` (a pointer) through a field pointer: as is, or encoded
+     * as the 32-bit reference of a compressed field. */
+    storeRef(ptr, value) {
+        const B = this.B;
+        if (!this.compressedFieldPtrs.has(ptr)) {
+            B.line(`store ptr ${value}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+            return;
+        }
+        const idx = B.tmp();
+        for (const line of compactRefStoreLines(value, idx, `${idx}.r`))
+            B.line(line.trimStart());
+        B.line(`store i32 ${idx}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
     }
     /** The dynamic class's preorder number (borrowed object; the static class
      * names the struct spelling and where the number is, classPreLines). */
@@ -2754,6 +3191,8 @@ export class LlEmitter {
             const { tag, bits } = loadInlineUnion(B, ptr);
             return stackUnionBox(B, this.sizeType, tag, bits);
         }
+        if (this.compressedFieldPtrs.has(ptr))
+            return this.loadRef(ptr);
         const fieldTy = llFieldType(t, false);
         const raw = B.tmp();
         B.line(`${raw} = load ${fieldTy}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
@@ -2778,8 +3217,7 @@ export class LlEmitter {
     replaceField(ptr, type, inline, v) {
         if (!inline && isRefCounted(type)) {
             this.toHeap(v);
-            const old = this.B.tmp();
-            this.B.line(`${old} = load ptr, ptr ${ptr}`);
+            const old = this.loadRef(ptr, false);
             this.storeField(ptr, type, v.name, false);
             this.releaseHeap(old, type);
             return;
@@ -2802,6 +3240,10 @@ export class LlEmitter {
             storeInlineUnion(B, ptr, tag, bits);
             return;
         }
+        if (this.compressedFieldPtrs.has(ptr)) {
+            this.storeRef(ptr, value);
+            return;
+        }
         const fieldTy = llFieldType(t, false);
         if (fieldTy !== "i8") {
             B.line(`store ${fieldTy} ${value}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
@@ -2868,6 +3310,8 @@ export class LlEmitter {
             ranges: this.integerRanges,
             initialized,
             proven: this.bytesBounds,
+            workers: this.mod.workers === true,
+            owned: this.bytesOwned,
         });
     }
     /** The alias tag of a whole-slot load of a binding (module globals only). */
@@ -2907,6 +3351,24 @@ export class LlEmitter {
         this.B.line(`${b} = load ptr, ptr ${slot}`);
         return b;
     }
+    /** The function a call through `callee` is known to reach (a literal
+     * closure, or a binding the constant-callback census resolves) and the
+     * entry it calls directly. Async and generator functions stay indirect. */
+    knownCallbackTarget(callee) {
+        const knownName = callee.kind === "closure"
+            ? callee.fnName
+            : callee.kind === "varRef"
+                ? this.currentConstantCallbacks.get(callee.localId)
+                : undefined;
+        const known = knownName ? this.fnByName.get(knownName) : undefined;
+        if (!known || known.async || known.generator)
+            return undefined;
+        if (known.captures === undefined) {
+            this.fnValues.add(known.name);
+            return { known, direct: `@${mangleWrapper(known.name)}` };
+        }
+        return { known, direct: `@${this.callTarget(known.name)}` };
+    }
     /** The payload slot of a capture box (ScrBox.slot, field 5). */
     boxSlot(box) {
         const slot = this.B.tmp();
@@ -2919,13 +3381,15 @@ export class LlEmitter {
         const r = B.tmp();
         // Scalar payloads are read in place (scr_box_get_f64/bool are a
         // memcpy and a nonzero test of the same slot), so LLVM can keep a
-        // captured number in a register across a loop of calls.
+        // captured number in a register across a loop of calls. They have an
+        // alias category of their own: every other access to a box's payload
+        // is untagged or a runtime call.
         if (acc === "f64") {
-            B.line(`${r} = load double, ptr ${this.boxSlot(box)}`);
+            B.line(`${r} = load double, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`);
         }
         else if (acc === "bool") {
             const raw = B.tmp();
-            B.line(`${raw} = load i64, ptr ${this.boxSlot(box)}`);
+            B.line(`${raw} = load i64, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`);
             B.line(`${r} = icmp ne i64 ${raw}, 0`);
         }
         else {
@@ -2939,12 +3403,12 @@ export class LlEmitter {
         const B = this.B;
         const acc = boxAccess(t);
         if (acc === "f64") {
-            B.line(`store double ${value}, ptr ${this.boxSlot(box)}`);
+            B.line(`store double ${value}, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`);
         }
         else if (acc === "bool") {
             const raw = B.tmp();
             B.line(`${raw} = zext i1 ${value} to i64`);
-            B.line(`store i64 ${raw}, ptr ${this.boxSlot(box)}`);
+            B.line(`store i64 ${raw}, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`);
         }
         else {
             this.declare(`declare void @scr_box_set_ref(ptr, ptr)`);
@@ -3833,6 +4297,11 @@ export class LlEmitter {
                 if (cursor)
                     cursor.index = i;
                 this.stmtCursor = cursor;
+                const deferred = this.deferredPromiseAllLocal(stmts, i);
+                if (deferred !== null) {
+                    this.deferredPromiseAllEntries.set(stmts[i].localId, deferred);
+                    continue;
+                }
                 this.emitStmt(stmts[i]);
             }
         }
@@ -4376,14 +4845,16 @@ export class LlEmitter {
                     post: meta.post,
                     runtimeRooted: meta.root.def.runtime === true,
                     idInRc: meta.idInRc,
+                    compact: meta.compact,
                     // Inline scalar-union fields are plain bits: nothing to push.
                     fields: meta.def.fields.flatMap((f) => this.inlineUnions.classField(className, f.name)
                         ? []
                         : [
                             {
                                 name: f.name,
-                                index: classFieldIndex(meta, f.name).index,
+                                index: classFieldIndex(meta, f.name, "compressed").index,
                                 type: this.nullableFields.storageType(className, f.name, f.type),
+                                compressed: classFieldIndex(meta, f.name, "compressed").compressed,
                             },
                         ]),
                 };
@@ -4414,13 +4885,20 @@ export class LlEmitter {
     }
     /** Branches on "`obj` is published" (rc == SIZE_MAX, or a count of
      * UINT32_MAX in the low half for `count` i32: classes.ts
-     * LlClassMeta.idInRc); leaves the builder in the cold block and answers
-     * the continuation label. */
+     * LlClassMeta.idInRc, or the top bit of a compact header word for
+     * "compact": classes.ts COMPACT_PUBLISHED); leaves the builder in the cold
+     * block and answers the continuation label. */
     emitPublishedTest(obj, count = this.sizeType) {
         const B = this.B;
         const rc = B.tmp(), frozen = B.tmp(), expected = B.tmp();
-        B.line(`${rc} = load ${count}, ptr ${obj}`);
-        B.line(`${frozen} = icmp eq ${count} ${rc}, -1`);
+        if (count === "compact") {
+            B.line(`${rc} = load i32, ptr ${obj}`);
+            B.line(`${frozen} = icmp slt i32 ${rc}, 0`);
+        }
+        else {
+            B.line(`${rc} = load ${count}, ptr ${obj}`);
+            B.line(`${frozen} = icmp eq ${count} ${rc}, -1`);
+        }
         this.declare(`declare i1 @llvm.expect.i1(i1, i1)`);
         B.line(`${expected} = call i1 @llvm.expect.i1(i1 ${frozen}, i1 false)`);
         const cold = B.newLabel("pub.frozen"), ok = B.newLabel("pub.ok");
@@ -4461,7 +4939,7 @@ export class LlEmitter {
             return;
         const B = this.B;
         const meta = className === null ? undefined : this.classMeta.get(className);
-        const ok = this.emitPublishedTest(obj, meta?.idInRc === true ? "i32" : this.sizeType);
+        const ok = this.emitPublishedTest(obj, meta?.compact === true ? "compact" : meta?.idInRc === true ? "i32" : this.sizeType);
         let owner;
         if (meta === undefined)
             owner = this.cstr("Object");
@@ -4556,11 +5034,9 @@ export class LlEmitter {
         const nullable = this.nullableFieldGet(e);
         if (!nullable || e.kind !== "fieldGet")
             return this.emitReadReceiver(e);
-        const B = this.B;
         const receiver = this.emitReadReceiver(e.obj);
-        const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field);
-        const p = B.tmp();
-        B.line(`${p} = load ptr, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+        const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field, "compressed");
+        const p = this.loadRef(ptr);
         return { name: this.stackNullableBox(p, nullable), type: e.type };
     }
     /** A private stack box over a nullable-pointer field read whose payload
@@ -4572,9 +5048,8 @@ export class LlEmitter {
         if (!nullable || e.kind !== "fieldGet")
             throw new InternalCompilerError("llvm emitter bug: owned nullable stack of non-field");
         const receiver = this.emitReadReceiver(e.obj);
-        const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field);
-        const p = this.B.tmp();
-        this.B.line(`${p} = load ptr, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+        const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field, "compressed");
+        const p = this.loadRef(ptr);
         const owner = this.own({ name: this.retainFrame(p, nullable.arm), type: nullable.arm });
         return { box: this.stackNullableBox(owner.name, nullable), owner };
     }
@@ -4635,7 +5110,6 @@ export class LlEmitter {
      * retained payload of a borrowed box otherwise. Unlink-then-release like
      * every field store. */
     emitNullableFieldStore(obj, className, field, nullable, value) {
-        const B = this.B;
         let next;
         if (value.kind === "unionWrap" &&
             value.unionId === nullable.unionId &&
@@ -4660,10 +5134,9 @@ export class LlEmitter {
         else {
             next = this.unionToNullable(this.emitUnionProjection(value).name, nullable);
         }
-        const { ptr } = this.classFieldPtr(obj, className, field);
-        const old = B.tmp();
-        B.line(`${old} = load ptr, ptr ${ptr}`);
-        B.line(`store ptr ${next}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+        const { ptr } = this.classFieldPtr(obj, className, field, "compressed");
+        const old = this.loadRef(ptr, false);
+        this.storeRef(ptr, next);
         this.releaseHeap(old, nullable.arm);
     }
     /** A union binding whose slot may hold a private stack box: stack locals
@@ -4903,8 +5376,8 @@ export class LlEmitter {
     emitBytesLength(elem, receiver, bytes) {
         return emitBytesLength(this, elem, receiver, bytes);
     }
-    emitBytesGet(elem, receiver, index, expr, inBounds = false, invalidNaN = false) {
-        return emitBytesGet(this, elem, receiver, index, expr, inBounds, invalidNaN);
+    emitBytesGet(elem, receiver, index, expr, inBounds = false, invalidNaN = false, owned = false) {
+        return emitBytesGet(this, elem, receiver, index, expr, inBounds, invalidNaN, owned);
     }
     emitToUint32(value, expr, uint32) {
         return emitToUint32(this, value, expr, uint32);
@@ -4959,8 +5432,8 @@ export class LlEmitter {
         const integer = this.emitToUint32(value.name, expr, value.uint32);
         this.B.line(`store i32 ${integer}, ptr ${slot}`);
     }
-    emitBytesSet(elem, receiver, index, value, indexExpr, expr, inBounds = false) {
-        return emitBytesSet(this, elem, receiver, index, value, indexExpr, expr, inBounds);
+    emitBytesSet(elem, receiver, index, value, indexExpr, expr, inBounds = false, owned = false) {
+        return emitBytesSet(this, elem, receiver, index, value, indexExpr, expr, inBounds, owned);
     }
     emitBytesIntrinsic(e) {
         return emitBytesIntrinsic(this, e);