@scriptc/compiler 0.4.8 → 0.4.9

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

@@ -56,6 +56,10 @@ import { type Node } from "./region-ir.js";
 import { LlDyn, type DynHost, type JsEntryClosure } from "./dyn.js";
 import { LlWalkers } from "./walkers.js";
 import { NullableUnions } from "./nullable-unions.js";
+/** The ABSENT marker of an optional checked-dynamic record field: an
+ * immortal ScrDyn of kind SCR_DYN_UNDEF that is address-distinct from
+ * scr_dyn_undefined(). Emitted only when a program references it. */
+export declare const DYN_ABSENT = "@sc_dyn_absent";
 import { type InlineRcMode, type MapKeyAccess } from "./shapes.js";
 import type { ExprOf, LibCallExpr, LlStreamTypedRefAdapter, LlValue } from "./expr-context.js";
 import { type SpeculationContext, type SpeculativeValue } from "./speculative-integers.js";
@@ -161,6 +165,11 @@ export interface LlvmTargetOptions {
      * teardown after `process.exit` to a helper process (`--detached-exit`).
      * Executables only; the runtime's weak default keeps it off. */
     detachedExit?: boolean;
+    /** Define `scr_stdout_buffering` so the runtime keeps JavaScript-visible
+     * stdout in its 64 KiB buffer when fd 1 is not a terminal
+     * (`--stdout-buffering`). Executables only; the runtime's weak default
+     * keeps the per-call policy. */
+    stdoutBuffering?: boolean;
     /** The files of the program's Node island module tree, in manifest order
      * (node-islands/modules.ts), when the executable carries the tree. */
     nodeIslandModuleData?: Uint8Array;
@@ -182,16 +191,28 @@ export interface LlvmTargetOptions {
      * runs on any x86-64 CPU. */
     targetCpu?: TargetCpu;
     /** Give an x86-64 executable without a `targetCpu` an x86-64-v3 copy of
-     * each program function, which it runs on CPUs at that level
-     * (cpu-dispatch.ts). Ignored for other targets, libraries and builds
-     * with debug information. */
+     * the program functions whose loop x86-64-v3 widens (cpu-dispatch.ts),
+     * which it runs on CPUs at that level. Ignored for other targets,
+     * libraries, builds with debug information and profile-recording builds. */
     cpuDispatch?: boolean;
+    /** The build records a profile: a dispatching build emits one body per
+     * function and keeps the functions a copy takes out of line, so the
+     * profile names the functions a `--profile-use` build copies. */
+    profileGenerate?: boolean;
+    /** The functions the build's profile names, when it uses one: the copies
+     * are limited to the functions among them that have a loop. */
+    cpuCopyFunctions?: ReadonlySet<string>;
+    /** The most program text the copies may take (cpu-dispatch.ts
+     * cpuCopyBudget by default): lowers the set for a build or a test that
+     * wants fewer copies. */
+    cpuCopyCapBytes?: number;
 }
 /** 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`). */
+ * shadow memory there), and macOS targets without sanitizers, which keep the
+ * window at a fixed base instead (classes.ts compactRefBaseOf). Other systems
+ * map their own images and libraries below 32 GiB. `platform` is a target
+ * platform (`linux`, `darwin`, `win32`, `wasi`). */
 export declare function lowRegionTarget(platform: string, sanitize: boolean): boolean;
 /** The int32 slot analysis of one module and the inputs it read: the
  * constructor's own analyses of that module, which LlEmitter takes over
@@ -331,6 +352,10 @@ export declare class LlEmitter {
      * 32-bit references (LlClassMeta.compressed):
      * loadField/loadRef decode them and storeField/storeRef encode them. */
     readonly compressedFieldPtrs: Set<string>;
+    /** The window base that 32-bit references are offsets from (classes.ts
+     * compactRefBaseOf): 0 unless the low region applies on a target that
+     * places the window at a base. */
+    readonly compactRefBase: bigint;
     /** Compact class instances live in the program-lifetime region below
      * 32 GiB (LlvmTargetOptions.lowRegion, and the program has compact
      * classes): main reserves it before compiled code runs (scr_plr_init), and
@@ -408,7 +433,9 @@ export declare class LlEmitter {
     arrayAccess(arr: IrExpr, elem: IrType): ArrayAccess;
     /** Whether an element access at `index` of `arr` lies in the hole-free
      * prefix: a counter of a dense array loop's fast copy indexing one of the
-     * arrays its entry test covered. */
+     * arrays its entry test covered, or an index proven in range of a parameter
+     * whose every call passes an array of that many present elements
+     * (IrParam.constLength). */
     provenDenseIndex(arr: IrExpr, index: IrExpr): boolean;
     fieldAliasAttachment(ptr: string): string;
     fieldAliasMetadata(): string[];
@@ -455,12 +482,22 @@ export declare class LlEmitter {
     readonly emitLibraryIdentity: boolean;
     readonly runtimeAbiMarker: boolean;
     readonly detachedExit: boolean;
+    readonly stdoutBuffering: boolean;
     readonly nodeIslandModuleData: Uint8Array | null;
     readonly targetCpu: TargetCpu | undefined;
+    /** LlvmTargetOptions.targetTriple, or "" for the host's ABI. */
+    readonly targetTriple: string;
     /** Emitted functions carry `sanitize_address` (LlvmTargetOptions). */
     readonly sanitizeAttributes: boolean;
     /** LlvmTargetOptions.cpuDispatch, where it applies. */
     readonly cpuDispatch: boolean;
+    /** LlvmTargetOptions.cpuCopyFunctions. */
+    private readonly cpuCopyFunctions;
+    /** LlvmTargetOptions.cpuCopyCapBytes. */
+    private readonly cpuCopyCapBytes;
+    /** Whether emission keeps the functions a dispatching build would copy out
+     * of line, so a recorded profile names them. */
+    private readonly keepCopyBodiesOutOfLine;
     /** How the program's functions are copied (cpu-dispatch.ts): for runtime
      * dispatch, for an x86-64-v3 `targetCpu` ("target"), or not at all. */
     readonly cpuCopies: CpuCopies | null;
@@ -494,6 +531,8 @@ export declare class LlEmitter {
     readonly retypeGuards: Map<string, string>;
     /** The nullable-union ABSENT sentinel was referenced (absentInstanceRef). */
     needsNullableAbsent: boolean;
+    /** The optional-dyn ABSENT marker was referenced (dynAbsentRef). */
+    needsDynAbsent: boolean;
     private readonly immortalValues;
     /** Regex literal templates: "<flags>/<pattern>" → { symbol, interned
      * source/flags literal refs } — one immortal ScrRegex template per distinct
@@ -531,6 +570,17 @@ export declare class LlEmitter {
     }>;
     /** Interned ScrMapOps descriptors (scr_map.h): initializer → symbol. */
     readonly mapOpsConsts: Map<string, string>;
+    /** Element data of the numeric array literals that become static tables
+     * (arrayLit, expr-primitives.ts): "<i32|double>:<literal location>" → the
+     * private constant's symbol, element type and the elements as their
+     * rendered literals. The array works from that data in place, so each
+     * entry also places the header in static storage (`<sym>_h`), initialized
+     * with the same table. */
+    readonly arrayConstData: Map<string, {
+        sym: string;
+        type: "i32" | "double";
+        values: readonly string[];
+    }>;
     /** Method-id slots of checked-dynamic method calls
      * (scr_dyn_invoke_prepared_id): method name → symbol of an i32 the
      * runtime fills with the name's id on the first call. */
@@ -661,6 +711,9 @@ export declare class LlEmitter {
     readonly nodeIndex: IrNodeIndex;
     private readonly tdzGlobals;
     readonly constantNumericTables: ReadonlyMap<string, ConstantNumericTable>;
+    /** Module-level numeric tables the emitter places in the program image,
+     * by their initializing array literal (ir/constant-tables.ts). */
+    readonly staticArrayTables: ReadonlySet<IrExpr>;
     /** Constant-key reads on checked-dynamic objects, each with its own
      * zero-initialized ScrDynReadIc (scr_runtime.h). */
     dynReadIcSites: number;
@@ -753,6 +806,8 @@ export declare class LlEmitter {
     /** Whether timer and tick scheduling goes through the *_als entry
      * points (RuntimeFeatures asyncContext). */
     get schedulesInContext(): boolean;
+    /** The JavaScript object model build is on (jsObjectModelFact). */
+    get jsObjectModel(): boolean;
     /** Emitted ref-kind resolve thunks for new Promise, interned per inner
      * typeKey → thunk symbol. */
     readonly resolveThunks: Map<string, string>;
@@ -1022,6 +1077,9 @@ export declare class LlEmitter {
      * not a constructor (where they change), not async or a generator. */
     finalFieldBorrows: boolean;
     integerRanges: IntegerRanges;
+    /** The current function's parameters whose every call passes an array of a
+     * known number of present elements (IrParam.constLength). */
+    constLengthParams: Map<string, number>;
     /** The current function's bounded for-loop cursors (integer-ranges.ts). */
     integerLoopRanges: ReadonlyMap<IrStmt, ReadonlyMap<string, IntegerRange>>;
     /** Number arrays of the current function whose every present element is
@@ -1181,6 +1239,9 @@ export declare class LlEmitter {
         globals: string[];
         defs: string[];
     };
+    /** What a dispatching build copies: the profile's functions, when it uses
+     * one, within the text budget. */
+    private copySelection;
     emit(): string;
     emitParts(): string[];
     /** The entry point and JavaScript name of each named function the
@@ -1348,6 +1409,20 @@ export declare class LlEmitter {
      * throws as usual). BigInt here is the same StringToBigInt as the
      * program's, so every accepted spelling folds to the value Node gives. */
     internBigIntLiteral(text: string): string | null;
+    /** The element data of the static array table at `at`
+     * (ir/constant-tables.ts), which the array itself holds: the emitter also
+     * places the header, `<sym>_h`, in static storage. Each table gets its own
+     * pair, so two tables with equal elements stay distinct arrays —
+     * `@`-refs, first-use order.
+     *
+     * The elements are rendered to their literals here, not in the module
+     * writer: a chunk's result crosses a JSON boundary (emit-module.ts), and
+     * JSON turns NaN and the infinities into null and negative zero into zero.
+     * `f64Lit` is the exact bit pattern, so every element survives it. */
+    staticArrayData(at: IrExpr, values: readonly number[], type: "i32" | "double"): {
+        data: string;
+        header: string;
+    };
     /** Interned NUL-terminated C-string constant (the scr_jb_puts /
      * stringify-indent currency) — `@`-ref, first-use order. */
     cstr(text: string): string;
@@ -1367,6 +1442,11 @@ export declare class LlEmitter {
     /** The immortal ABSENT state of an undefined-armed record field slot
      * (IR fieldAbsent). */
     absentInstanceRef(unionId: string): string;
+    /** The ABSENT marker of an optional checked-dynamic record field slot
+     * (IR fieldAbsent without a union). Address-compared, never dereferenced
+     * by compiled code: reads select it to scr_dyn_undefined, presence tests
+     * compare against it, and boxing omits it. */
+    dynAbsentRef(): string;
     /** i1: a union value loaded from a field slot is the ABSENT state — the
      * undefined arm's tag with the absent payload marker. */
     fieldAbsentTest(value: string, unionId: string): string;

package/dist/backend/llvm/emitter.js

@@ -16,7 +16,7 @@ import { createHash } from "node:crypto";
 import { endsWithJump, matchFieldSelfConcat, readsArraySlot, streamTypedRefEligible, undefinedArmTag, } from "../../ir/analysis.js";
 import { containsLoop, 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, classValueAbiEquals, } from "../../ir/ir.js";
-import { moduleRuntimeFeatures } from "../../ir/runtime-features.js";
+import { jsObjectModelFact, moduleRuntimeFeatures, } from "../../ir/runtime-features.js";
 import { captureFreeFunctions, observesStacks } from "../stack-observations.js";
 import { findInitializedByteLoopBindings } from "./byte-windows.js";
 import { matchBytesLoopVersion } from "./bytes-loop-versions.js";
@@ -28,6 +28,7 @@ import { specializeCallbackCalls } from "../../ir/callback-specialization.js";
 import { EmitJournal, registerReplay, renameChunk, replayJournal, } from "./emit-journal.js";
 import { specializeNumericCalls } from "../../ir/numeric-call-specialization.js";
 import { specializeTypedArguments } from "../../ir/typed-argument-clones.js";
+import { specializeConstantArrayLengths } from "../../ir/constant-length-clones.js";
 import { versionLoopBoundParameters } from "../../ir/parameter-versions.js";
 import { inlineExpressionFunctions } from "../../ir/expression-inlining.js";
 import { inlineArrayReads, NO_INLINE_ARRAYS, planInlineArrays, } from "../../ir/inline-arrays.js";
@@ -59,11 +60,11 @@ import { writeRepresentationReport } from "./repr-report.js";
 import { heapCensusOf } from "./heap-census.js";
 import { exactInteger, narrowInteger, widenInteger } from "./integer-values.js";
 import { findInitializerBindings } from "../../ir/initializer-bindings.js";
-import { findConstantNumericTables } from "../../ir/constant-tables.js";
+import { findConstantNumericTables, findStaticArrayTables, } from "../../ir/constant-tables.js";
 import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback, } from "../ffi-callbacks.js";
 import { computeMayThrow } from "../may-throw.js";
 import { UNWIND_PERSONALITY, UNWIND_RAISE, UNWIND_RAISE_DECLARATION, UNWIND_RESUME_DECLARATION, UNWIND_RESUME, UNWIND_SLOT, UnwindAbiViolation, bridgePlainUnwindCalls, unwindAbiFunctions, } from "./unwind-abi.js";
-import { cloneForCpuDispatch } from "./cpu-dispatch.js";
+import { cloneForCpuDispatch, keepCopiedBodiesOutOfLine, } from "./cpu-dispatch.js";
 import { mangleAsyncInlineAwaitCall, mangleAsyncSpawn, mangleBorrowedFunction, mangleClassObj, mangleFnClosure, mangleFunction, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleWrapper, mangleBorrowingWrapper, } from "../mangle.js";
 import { analyzeCallLifetimes } from "./call-lifetimes.js";
 import { stackObjectStruct, } from "./stack-objects.js";
@@ -116,7 +117,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 { assignCompactLayouts, buildClassGraph, classFieldTypes, classMembershipIntervals, classFieldIndex, compactRefLoadLines, compactRefStoreLines, classPreLines, classStructSym, programLifetimeClass, } from "./classes.js";
+import { assignCompactLayouts, buildClassGraph, classFieldTypes, classMembershipIntervals, classFieldIndex, compactRefBaseOf, compactRefLoadLines, compactRefStoreLines, classPreLines, classStructSym, programLifetimeClass, } from "./classes.js";
 import { LifetimeRegions, REGION_TYPES } from "./regions.js";
 import { planTreeClasses } from "../tree-classes.js";
 import { arenaAware, arenaCurrentAddress, arenaNewSym, arenasRequested, planArenas, } from "./arenas.js";
@@ -128,6 +129,10 @@ import { LlvmUnsupportedError } from "./unsupported.js";
 import { LlWalkers } from "./walkers.js";
 import { isObjectArm, isPayloadTag, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions, pointerTagFn, } from "./nullable-unions.js";
 import { classUnionHeaders, emitClassUnionHelpers } from "./class-unions.js";
+/** The ABSENT marker of an optional checked-dynamic record field: an
+ * immortal ScrDyn of kind SCR_DYN_UNDEF that is address-distinct from
+ * scr_dyn_undefined(). Emitted only when a program references it. */
+export const DYN_ABSENT = "@sc_dyn_absent";
 import { emitNullablePresent, emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { emitConcatInputs, emitMixedConcat, numberPart, stringParts, } from "./string-construction.js";
 import { arrNewCall, boxAccess, elemAccess, boxNewCall, boxReleaseSym, computeTraced, emitInlineRcHelpers, emitNullableRetainWrappers, emitShapeUnionHelpers, FN_ATTRS, inlineRcDecls, llFieldType, mapFlagsOffset, releaseSym, retainSym, traceArg, vAdapters, traceAdapter, } from "./shapes.js";
@@ -167,11 +172,12 @@ export function ffiCallbackDummyLl(callback) {
 }
 /** 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`). */
+ * shadow memory there), and macOS targets without sanitizers, which keep the
+ * window at a fixed base instead (classes.ts compactRefBaseOf). Other systems
+ * map their own images and libraries below 32 GiB. `platform` is a target
+ * platform (`linux`, `darwin`, `win32`, `wasi`). */
 export function lowRegionTarget(platform, sanitize) {
-    return platform === "linux" && !sanitize;
+    return (platform === "linux" || platform === "darwin") && !sanitize;
 }
 /** Function versions on loop-bounding number parameters
  * (ir/parameter-versions.ts). Library builds have no int32 entries, and a
@@ -296,7 +302,7 @@ function moduleEmitter(input, options) {
     // an earlier pass rewrote, which the index does not record.
     const nodes = new IrNodeIndex(mod);
     rounds.nodes = nodes;
-    const passed = versionUnionArmLoops(versionParameters(addRecordResultEntries(scalarizeLiteralResults(scalarizeNumericRecords(specializeCallbackCalls(specializeNumericCalls(specializeTypedArguments(pairRowSums(jamRuntimeCountLoops(jamSaturatingLoops(inlineArraysPass(options, inlineExpressionFunctions(foldConstantGlobals(copyStableCaptures(resolveSelfCaptures(hoistFinalFieldReads(freezeInitOnlyGlobals(holdCharLocalsAsUnits(dropUnwrittenPropertyBags(runPairedWhileLoopsAsFor(mod, nodes), nodes), nodes), nodes), nodes), nodes), nodes), nodes), nodes)), nodes), nodes), nodes), mangleFunction, nodes), mangleFunction, nodes), mangleFunction, nodes)), nodes), nodes), nodes), nodes);
+    const passed = versionUnionArmLoops(versionParameters(addRecordResultEntries(scalarizeLiteralResults(scalarizeNumericRecords(specializeCallbackCalls(specializeNumericCalls(specializeConstantArrayLengths(specializeTypedArguments(pairRowSums(jamRuntimeCountLoops(jamSaturatingLoops(inlineArraysPass(options, inlineExpressionFunctions(foldConstantGlobals(copyStableCaptures(resolveSelfCaptures(hoistFinalFieldReads(freezeInitOnlyGlobals(holdCharLocalsAsUnits(dropUnwrittenPropertyBags(runPairedWhileLoopsAsFor(mod, nodes), nodes), nodes), nodes), nodes), nodes), nodes), nodes), nodes)), nodes), nodes), nodes), mangleFunction, nodes), mangleFunction, nodes), mangleFunction, nodes), mangleFunction, nodes)), nodes), nodes), nodes), nodes);
     timing("llvm-emit-rewrites");
     let emitted = selectInt32Arrays(passed, proven, resultEntryTargets);
     let prepared = rounds.last;
@@ -570,6 +576,10 @@ export class LlEmitter {
      * 32-bit references (LlClassMeta.compressed):
      * loadField/loadRef decode them and storeField/storeRef encode them. */
     compressedFieldPtrs = new Set();
+    /** The window base that 32-bit references are offsets from (classes.ts
+     * compactRefBaseOf): 0 unless the low region applies on a target that
+     * places the window at a base. */
+    compactRefBase;
     /** Compact class instances live in the program-lifetime region below
      * 32 GiB (LlvmTargetOptions.lowRegion, and the program has compact
      * classes): main reserves it before compiled code runs (scr_plr_init), and
@@ -819,8 +829,23 @@ export class LlEmitter {
     }
     /** Whether an element access at `index` of `arr` lies in the hole-free
      * prefix: a counter of a dense array loop's fast copy indexing one of the
-     * arrays its entry test covered. */
+     * arrays its entry test covered, or an index proven in range of a parameter
+     * whose every call passes an array of that many present elements
+     * (IrParam.constLength). */
     provenDenseIndex(arr, index) {
+        if (arr.kind === "varRef") {
+            const length = this.constLengthParams.get(arr.localId);
+            if (length !== undefined) {
+                if (index.kind === "numLit" &&
+                    Number.isInteger(index.value) &&
+                    index.value >= 0 &&
+                    index.value < length)
+                    return true;
+                const range = this.integerRanges.get(index);
+                if (range !== null && range !== undefined && range.min >= 0 && range.max < length)
+                    return true;
+            }
+        }
         const loop = LOOPS.of(this).denseLoop;
         return (loop !== null &&
             arr.kind === "varRef" &&
@@ -879,12 +904,22 @@ export class LlEmitter {
     emitLibraryIdentity;
     runtimeAbiMarker;
     detachedExit;
+    stdoutBuffering;
     nodeIslandModuleData;
     targetCpu;
+    /** LlvmTargetOptions.targetTriple, or "" for the host's ABI. */
+    targetTriple;
     /** Emitted functions carry `sanitize_address` (LlvmTargetOptions). */
     sanitizeAttributes;
     /** LlvmTargetOptions.cpuDispatch, where it applies. */
     cpuDispatch;
+    /** LlvmTargetOptions.cpuCopyFunctions. */
+    cpuCopyFunctions;
+    /** LlvmTargetOptions.cpuCopyCapBytes. */
+    cpuCopyCapBytes;
+    /** Whether emission keeps the functions a dispatching build would copy out
+     * of line, so a recorded profile names them. */
+    keepCopyBodiesOutOfLine;
     /** How the program's functions are copied (cpu-dispatch.ts): for runtime
      * dispatch, for an x86-64-v3 `targetCpu` ("target"), or not at all. */
     cpuCopies;
@@ -912,6 +947,8 @@ export class LlEmitter {
     retypeGuards = new Map();
     /** The nullable-union ABSENT sentinel was referenced (absentInstanceRef). */
     needsNullableAbsent = false;
+    /** The optional-dyn ABSENT marker was referenced (dynAbsentRef). */
+    needsDynAbsent = false;
     immortalValues = new Set();
     /** Regex literal templates: "<flags>/<pattern>" → { symbol, interned
      * source/flags literal refs } — one immortal ScrRegex template per distinct
@@ -932,6 +969,13 @@ export class LlEmitter {
     cstrs = new Map();
     /** Interned ScrMapOps descriptors (scr_map.h): initializer → symbol. */
     mapOpsConsts = new Map();
+    /** Element data of the numeric array literals that become static tables
+     * (arrayLit, expr-primitives.ts): "<i32|double>:<literal location>" → the
+     * private constant's symbol, element type and the elements as their
+     * rendered literals. The array works from that data in place, so each
+     * entry also places the header in static storage (`<sym>_h`), initialized
+     * with the same table. */
+    arrayConstData = new Map();
     /** Method-id slots of checked-dynamic method calls
      * (scr_dyn_invoke_prepared_id): method name → symbol of an i32 the
      * runtime fills with the name's id on the first call. */
@@ -1057,6 +1101,9 @@ export class LlEmitter {
     nodeIndex;
     tdzGlobals = new Map();
     constantNumericTables;
+    /** Module-level numeric tables the emitter places in the program image,
+     * by their initializing array literal (ir/constant-tables.ts). */
+    staticArrayTables;
     /** Constant-key reads on checked-dynamic objects, each with its own
      * zero-initialized ScrDynReadIc (scr_runtime.h). */
     dynReadIcSites = 0;
@@ -1148,6 +1195,10 @@ export class LlEmitter {
     get schedulesInContext() {
         return this.runtimeFeatures.asyncContext;
     }
+    /** The JavaScript object model build is on (jsObjectModelFact). */
+    get jsObjectModel() {
+        return jsObjectModelFact(this.runtimeFeatures);
+    }
     /** Emitted ref-kind resolve thunks for new Promise, interned per inner
      * typeKey → thunk symbol. */
     resolveThunks = new Map();
@@ -1374,6 +1425,9 @@ export class LlEmitter {
      * not a constructor (where they change), not async or a generator. */
     finalFieldBorrows = false;
     integerRanges = new Map();
+    /** The current function's parameters whose every call passes an array of a
+     * known number of present elements (IrParam.constLength). */
+    constLengthParams = new Map();
     /** The current function's bounded for-loop cursors (integer-ranges.ts). */
     integerLoopRanges = new Map();
     /** Number arrays of the current function whose every present element is
@@ -1513,6 +1567,7 @@ export class LlEmitter {
                 ? null
                 : new LlvmDebugInfo(mod.sourceFile, options.debugSources, options.pointerBits, mod.unions, this.nullableUnions.armTypes());
         this.constantNumericTables = findConstantNumericTables(mod);
+        this.staticArrayTables = findStaticArrayTables(mod);
         this.untypedIntegrity = mod.untypedIntegrity === true;
         this.sloppyDynWrites = new Set(mod.sloppyDynWrites ?? []);
         this.liveViewsReadOnly =
@@ -1539,6 +1594,7 @@ export class LlEmitter {
                 (options.targetTriple
                     ? /^(x86_64|amd64)\b/i.test(options.targetTriple)
                     : process.arch === "x64");
+        this.compactRefBase = options.lowRegion === true ? compactRefBaseOf(options.targetTriple) : 0n;
         this.executableTls =
             mod.workers === true &&
                 mod.lib === undefined &&
@@ -1556,14 +1612,24 @@ export class LlEmitter {
         this.emitLibraryIdentity = options.emitLibraryIdentity !== false;
         this.runtimeAbiMarker = options.runtimeAbiMarker === true;
         this.detachedExit = options.detachedExit === true;
+        this.stdoutBuffering = options.stdoutBuffering === true;
         this.nodeIslandModuleData = options.nodeIslandModuleData ?? null;
         this.targetCpu = options.targetCpu;
+        this.targetTriple = options.targetTriple ?? "";
         this.sanitizeAttributes = options.sanitizeAttributes !== false;
         const copyable = !this.wasi &&
             mod.lib === undefined &&
             this.debug === null &&
             /^(x86_64|amd64|x64)\b/.test(options.targetTriple || process.arch);
-        this.cpuDispatch = options.cpuDispatch === true && options.targetCpu === undefined && copyable;
+        this.cpuDispatch =
+            options.cpuDispatch === true &&
+                options.targetCpu === undefined &&
+                copyable &&
+                options.profileGenerate !== true;
+        this.cpuCopyFunctions = options.cpuCopyFunctions;
+        this.cpuCopyCapBytes = options.cpuCopyCapBytes;
+        this.keepCopyBodiesOutOfLine =
+            options.cpuDispatch === true && options.profileGenerate === true && copyable;
         this.cpuCopies = this.cpuDispatch
             ? "dispatch"
             : options.targetCpu === "x86-64-v3" && copyable
@@ -1798,8 +1864,9 @@ export class LlEmitter {
             // Worker programs keep one allocator per script thread: the inline
             // paths address its thread-local state.
             threadLocalAlloc: mod.workers === true,
-            // Linux executables find a block's owner in the chunk map.
-            windowMap: options.lowRegion === true,
+            // Linux executables find a block's owner in the chunk map, which
+            // indexes the low 32 GiB by address; a window with a base has none.
+            windowMap: options.lowRegion === true && compactRefBaseOf(options.targetTriple) === 0n,
             rcHelpers: this.rcHelpers,
             ...(this.rcMode !== undefined ? { rcMode: this.rcMode } : {}),
             ...(this.rcHelpersNoinline ? { rcHelpersNoinline: true } : {}),
@@ -1817,8 +1884,10 @@ export class LlEmitter {
             retypeGuardRef: (unionId) => this.retypeGuardRef(unionId),
             fieldAbsentTestIn: (B, value, unionId) => this.fieldAbsentTestIn(B, value, unionId),
             absentInstanceRef: (unionId) => this.absentInstanceRef(unionId),
+            dynAbsentRef: () => this.dynAbsentRef(),
             liveDynRefAdapter: (type) => this.liveDynRefAdapter(type),
             usesDynBuiltinStream: () => this.usesDynBuiltinStream,
+            jsObjectModel: () => jsObjectModelFact(this.runtimeFeatures),
             liveDynUnionRefAdapter: (type) => this.liveDynUnionRefAdapter(type),
             declBoundary: () => this.mod.declBoundary === true,
             dynPromiseAdapter: (type) => this.dynPromiseAdapter(type),
@@ -2156,13 +2225,26 @@ export class LlEmitter {
     emitFfiCallbackDefs() {
         return emitFfiCallbackDefs(this);
     }
+    /** What a dispatching build copies: the profile's functions, when it uses
+     * one, within the text budget. */
+    copySelection() {
+        const selection = {};
+        if (this.cpuCopyFunctions !== undefined)
+            selection.hot = this.cpuCopyFunctions;
+        if (this.cpuCopyCapBytes !== undefined)
+            selection.capBytes = this.cpuCopyCapBytes;
+        return selection;
+    }
     emit() {
         return this.emitParts().join("\n");
     }
     emitParts() {
         const parts = emitParts(this);
         const bridged = this.unwindAbi.size > 0 ? bridgePlainUnwindCalls(parts) : parts;
-        const out = this.cpuCopies === null ? bridged : cloneForCpuDispatch(bridged, this.cpuCopies);
+        const profiled = this.keepCopyBodiesOutOfLine ? keepCopiedBodiesOutOfLine(bridged) : bridged;
+        const out = this.cpuCopies === null
+            ? profiled
+            : cloneForCpuDispatch(profiled, this.cpuCopies, this.cpuCopies === "dispatch" ? this.copySelection() : undefined);
         return this.heapCensus === null ? out : [...out, this.heapCensus.definitions().join("\n")];
     }
     /** The entry point and JavaScript name of each named function the
@@ -2926,6 +3008,30 @@ export class LlEmitter {
         this.immortalValues.add(name);
         return name;
     }
+    /** The element data of the static array table at `at`
+     * (ir/constant-tables.ts), which the array itself holds: the emitter also
+     * places the header, `<sym>_h`, in static storage. Each table gets its own
+     * pair, so two tables with equal elements stay distinct arrays —
+     * `@`-refs, first-use order.
+     *
+     * The elements are rendered to their literals here, not in the module
+     * writer: a chunk's result crosses a JSON boundary (emit-module.ts), and
+     * JSON turns NaN and the infinities into null and negative zero into zero.
+     * `f64Lit` is the exact bit pattern, so every element survives it. */
+    staticArrayData(at, values, type) {
+        const key = `${type}:${at.loc?.file}:${at.loc?.start}:${at.loc?.end}`;
+        let c = this.arrayConstData.get(key);
+        if (!c) {
+            c = {
+                sym: this.contentSymbol("sc_arr_const_", key),
+                type,
+                values: values.map((v) => (type === "i32" ? String(v) : f64Lit(v))),
+            };
+            this.arrayConstData.set(key, c);
+        }
+        this.journal?.entry("arrayConst", key, c);
+        return { data: `@${c.sym}`, header: `@${c.sym}_h` };
+    }
     /** Interned NUL-terminated C-string constant (the scr_jb_puts /
      * stringify-indent currency) — `@`-ref, first-use order. */
     cstr(text) {
@@ -3021,6 +3127,15 @@ export class LlEmitter {
         this.immortalValues.add(name);
         return name;
     }
+    /** The ABSENT marker of an optional checked-dynamic record field slot
+     * (IR fieldAbsent without a union). Address-compared, never dereferenced
+     * by compiled code: reads select it to scr_dyn_undefined, presence tests
+     * compare against it, and boxing omits it. */
+    dynAbsentRef() {
+        this.needsDynAbsent = true;
+        this.immortalValues.add(DYN_ABSENT);
+        return DYN_ABSENT;
+    }
     /** i1: a union value loaded from a field slot is the ABSENT state — the
      * undefined arm's tag with the absent payload marker. */
     fieldAbsentTest(value, unionId) {
@@ -4265,7 +4380,7 @@ export class LlEmitter {
         }
         const idx = B.tmp();
         B.line(`${idx} = load i32, ptr ${ptr}${tags}`);
-        for (const line of compactRefLoadLines(idx, v, `${v}.r`))
+        for (const line of compactRefLoadLines(this.compactRefBase, idx, v, `${v}.r`))
             B.line(line.trimStart());
         return v;
     }
@@ -5198,6 +5313,7 @@ export class LlEmitter {
                 usesGenSlots: this.usesGenSlots,
                 needsUnionNone: this.needsUnionNone,
                 needsNullableAbsent: this.needsNullableAbsent,
+                needsDynAbsent: this.needsDynAbsent,
                 needsOom: this.needsOom,
                 needsBadTag: this.needsBadTag,
                 needsBadKey: this.needsBadKey,
@@ -5235,6 +5351,7 @@ export class LlEmitter {
         this.usesGenSlots ||= flags.usesGenSlots;
         this.needsUnionNone ||= flags.needsUnionNone;
         this.needsNullableAbsent ||= flags.needsNullableAbsent;
+        this.needsDynAbsent ||= flags.needsDynAbsent;
         this.needsOom ||= flags.needsOom;
         this.needsBadTag ||= flags.needsBadTag;
         this.needsBadKey ||= flags.needsBadKey;
@@ -5303,6 +5420,9 @@ export class LlEmitter {
             case "cstr":
                 this.addContentEntry(this.cstrs, key, value, "sc_cs_", names);
                 return;
+            case "arrayConst":
+                this.addContentEntry(this.arrayConstData, key, value, "sc_arr_const_", names);
+                return;
             case "mapOps": {
                 let own = this.mapOpsConsts.get(key);
                 if (own === undefined) {
@@ -6568,6 +6688,7 @@ export class LlEmitter {
             declare: (decl) => this.declare(decl),
             cstr: (text) => this.cstr(text),
             sizeType: this.sizeType,
+            compactRefBase: this.compactRefBase,
             rcAudit: this.shapeHost.objectAudit !== false,
             tracedShapes: this.tracedShapes,
             unionsById: this.unionsById,