@scriptc/compiler 0.3.5 → 0.3.6

package/dist/backend/llvm/emitter.js

@@ -13,6 +13,7 @@ import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCou
 import { moduleRuntimeFeatures } from "../../ir/runtime-features.js";
 import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop, } from "../../ir/integer-loops.js";
 import { emitCountedLoopLimit } from "./counted-loops.js";
+import { emitSafeIntegerCheck, emitSpeculativeInteger, planSpeculativeLoop, speculativeReads, speculativeWriteTarget, SPECULATIVE_RANGE, } from "./speculative-integers.js";
 import { emitLiteralSwitch } from "./switch-dispatch.js";
 import { findBytesBounds } from "./bytes-bounds.js";
 import { emitByteWindowGuard, findInitializedByteLoopBindings, matchByteWindow, } from "./byte-windows.js";
@@ -101,7 +102,7 @@ import { literalCapWord, literalCapWord32 } from "./string-key-hash.js";
 import { MAP_ITER_DECL, NUMBER_MAP_ENTRY_DECL, STRING_MAP_ENTRY_DECL, } from "./map-number-lookup.js";
 import { STRING_READ_HELPERS, stringScanDecl } from "./string-reads.js";
 import { emitConcatInputs, emitMixedConcat, numberPart, stringParts, } from "./string-construction.js";
-import { arrNewCall, boxAccess, boxNewCall, boxReleaseSym, computeTraced, elemAccess, emitInlineRcHelpers, emitNullableRetainWrappers, FN_ATTRS, inlineRcDecls, limitInlineDynReleases, llFieldType, releaseSym, retainSym, traceArg, typedRefConstructor, vAdapters, } from "./shapes.js";
+import { arrNewCall, boxAccess, boxNewCall, boxReleaseSym, computeTraced, elemAccess, emitInlineRcHelpers, emitNullableRetainWrappers, FN_ATTRS, inlineRcDecls, limitInlineDynReleases, llFieldType, mapFlagsOffset, releaseSym, retainSym, traceArg, typedRefConstructor, vAdapters, } from "./shapes.js";
 import { INLINE_LITERAL_BYTES, literalEqualityDefinition } from "./string-literal-equality.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
 function ffiCallbackDummyLl(callback) {
@@ -421,6 +422,9 @@ export class LlEmitter {
     stableGlobals = new Set();
     tdzGlobals = new Map();
     constantNumericTables;
+    /** Constant-key reads on checked-dynamic objects, each with its own
+     * zero-initialized ScrDynReadIc (scr_runtime.h). */
+    dynReadIcSites = 0;
     /** May-throw analysis (computeMayThrow): pending
      * checks are emitted only after calls that can actually raise. */
     mayThrow;
@@ -562,6 +566,17 @@ export class LlEmitter {
     /** Active induction bindings retain their width independently of size_t. */
     integerLoopBindings = new Map();
     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;
+    /** The ordinary copy being emitted: resume labels still to place. */
+    speculationResume = null;
+    /** The function being emitted, for speculative globals. */
+    speculativeFunction = "";
+    /** Every function that writes each number global (computed on demand). */
+    globalWriters = null;
     /** Whole-program final reference fields (ir/final-fields.ts). */
     finalFields;
     /** The current function may borrow final fields of borrowable objects:
@@ -1691,6 +1706,11 @@ export class LlEmitter {
             out.push(d);
         out.push(``);
         const flushedDecls = new Set(this.decls);
+        {
+            const tl = this.mod.workers === true || this.mod.lib?.threadInstances === true ? "thread_local " : "";
+            for (let site = 0; site < this.dynReadIcSites; site++)
+                out.push(`@sc_dyn_read_ic_${site} = internal ${tl}global { ptr, ${this.sizeType}, ${this.sizeType}, ptr } zeroinitializer`);
+        }
         for (const table of this.constantNumericTables.values()) {
             const n = table.values.length;
             let tableTmp = 0;
@@ -3723,6 +3743,259 @@ export class LlEmitter {
         this.B.line(`store i32 0, ptr ${slot}`);
         return slot;
     }
+    /** Emit a loop's condition, body and update through `emitCopy`, twice
+     * when speculative-integers.ts plans a fast integer copy. Both copies
+     * share the loop's setup and exit; the ordinary copy comes first so the
+     * fast copy is only emitted when every resume point exists. */
+    emitLoopCopies(loop, allowed, exit, emitCopy) {
+        const plan = allowed &&
+            this.speculativeLoopsEnabled &&
+            this.speculation === null &&
+            this.speculationResume === null
+            ? planSpeculativeLoop(loop, (id) => this.speculativeLocal(id), (id) => this.integerLoopBindings.has(id) || this.int32Locals.has(id), (e) => {
+                const range = this.integerRanges.get(e);
+                return (range !== undefined &&
+                    range !== null &&
+                    range.min >= -Number.MAX_SAFE_INTEGER &&
+                    range.max <= Number.MAX_SAFE_INTEGER);
+            }, (id) => this.speculativeLocal(id) || this.speculativeInvariantGlobal(id))
+            : null;
+        if (!plan) {
+            emitCopy(exit);
+            return;
+        }
+        const B = this.B;
+        const entries = new Map();
+        let ok = "true";
+        for (const [id, live] of plan.locals) {
+            if (!live)
+                continue;
+            const value = B.tmp();
+            B.line(`${value} = load double, ptr ${this.binding(id).slot}`);
+            const [integer, exact] = emitSafeIntegerCheck(this, value);
+            entries.set(id, integer);
+            if (ok === "true")
+                ok = exact;
+            else {
+                const both = B.tmp();
+                B.line(`${both} = and i1 ${ok}, ${exact}`);
+                ok = both;
+            }
+        }
+        const fast = B.newLabel("spec.fast"), slow = B.newLabel("spec.slow");
+        B.condBr(ok, fast, slow);
+        const resume = new Map();
+        for (const s of plan.writes)
+            resume.set(s, { label: B.newLabel("spec.resume"), placed: false });
+        B.startBlock(slow);
+        this.speculationResume = resume;
+        try {
+            emitCopy(exit);
+        }
+        finally {
+            this.speculationResume = null;
+        }
+        B.startBlock(fast);
+        if (![...resume.values()].every((r) => r.placed)) {
+            B.br(slow);
+            return;
+        }
+        for (const id of plan.locals.keys()) {
+            const shadow = B.slot();
+            B.entryAllocas.push(`${shadow} = alloca i64 ; speculative integer ${this.currentLocals.get(id)?.name ?? id}`);
+            const entry = entries.get(id);
+            if (entry !== undefined) {
+                // The same double, now visibly an integer conversion: the double
+                // phis of the fast copy fold into integer phis.
+                const exact = B.tmp();
+                B.line(`store i64 ${entry}, ptr ${shadow}`);
+                B.line(`${exact} = sitofp i64 ${entry} to double`);
+                B.line(`store double ${exact}, ptr ${this.binding(id).slot}`);
+            }
+            else
+                B.line(`store i64 0, ptr ${shadow}`);
+            this.integerLoopBindings.set(id, {
+                slot: shadow,
+                type: "i64",
+                signed: true,
+                range: SPECULATIVE_RANGE,
+            });
+        }
+        // A global's store stays in the loop (calls may read it). When nothing
+        // in the loop can observe it, its double is written once on leaving the
+        // copy instead, so the loop keeps it in a register as the double copy
+        // would.
+        const deferred = new Set();
+        // Worker loops also leave through their cancellation poll.
+        if (plan.observerFree && !this.mod.workers)
+            for (const s of plan.writes) {
+                const id = speculativeWriteTarget(s).localId;
+                if (!this.currentLocals.has(id))
+                    deferred.add(id);
+            }
+        this.speculation = {
+            writes: plan.writes,
+            resume: new Map([...resume].map(([s, r]) => [s, r.label])),
+            deferred,
+        };
+        try {
+            if (deferred.size === 0)
+                emitCopy(exit);
+            else {
+                const leave = B.newLabel("spec.leave");
+                emitCopy(leave);
+                B.startBlock(leave);
+                this.writeBackSpeculativeGlobals(deferred);
+                B.br(exit);
+            }
+        }
+        finally {
+            this.speculation = null;
+            for (const id of plan.locals.keys())
+                this.integerLoopBindings.delete(id);
+        }
+    }
+    writeBackSpeculativeGlobals(deferred) {
+        const B = this.B;
+        for (const id of deferred) {
+            const integer = B.tmp(), number = B.tmp();
+            B.line(`${integer} = load i64, ptr ${this.integerLoopBindings.get(id).slot}`);
+            B.line(`${number} = sitofp i64 ${integer} to double`);
+            B.line(`store double ${number}, ptr ${this.binding(id).slot}`);
+        }
+    }
+    /** A number local whose only storage is its own double slot, so an i64
+     * shadow beside it can stand for it within one loop. */
+    speculativeLocal(id) {
+        const local = this.currentLocals.get(id);
+        if (!local)
+            return this.speculativeGlobal(id);
+        if (local.type.kind !== "f64" || local.boxed || local.tdz)
+            return false;
+        return !(this.captureIds.has(id) ||
+            this.int32Locals.has(id) ||
+            this.integerLoopBindings.has(id) ||
+            this.integerViews.has(id) ||
+            this.localUnionStorage.has(id) ||
+            this.reboundOwnerSlots.has(id) ||
+            this.lazyCaptureBoxes.has(id) ||
+            this.privateSplitLocals.has(id));
+    }
+    /** A module-level number written only by the file's top-level code that
+     * is emitting this loop. Calls may still read it: the fast copy keeps its
+     * double current. An init function runs once and is never re-entered, so
+     * no call from the loop can write the global behind the shadow. */
+    speculativeGlobal(id) {
+        if (!this.speculativeFunction.startsWith("%init."))
+            return false;
+        const writers = this.numberGlobalWriters(id);
+        return (writers !== null &&
+            (writers.size === 0 || (writers.size === 1 && writers.has(this.speculativeFunction))));
+    }
+    /** A module-level number a loop of any function only reads, written by
+     * nothing but top-level code: an init function never runs during a loop
+     * of another function, so the entry value stays its value. */
+    speculativeInvariantGlobal(id) {
+        const writers = this.numberGlobalWriters(id);
+        return writers !== null && [...writers].every((name) => name.startsWith("%init."));
+    }
+    /** The functions writing a number global a shadow may stand for, or null
+     * when the global is not such a number. */
+    numberGlobalWriters(id) {
+        if (this.globalTypes.get(id)?.kind !== "f64")
+            return null;
+        if (this.tdzGlobals.has(id) || this.integerViews.has(id))
+            return null;
+        if (!this.globalWriters) {
+            const writers = new Map();
+            for (const fn of this.mod.functions) {
+                const note = (localId) => {
+                    if (!localId.startsWith("%g."))
+                        return;
+                    const set = writers.get(localId) ?? new Set();
+                    set.add(fn.name);
+                    writers.set(localId, set);
+                };
+                everyStmtList(fn.body, {
+                    stmt: (s) => {
+                        if (s.kind === "assign" || s.kind === "varDecl")
+                            note(s.localId);
+                        return true;
+                    },
+                    expr: (e) => {
+                        if (e.kind === "assignExpr" || e.kind === "incDec")
+                            note(e.localId);
+                        return true;
+                    },
+                });
+            }
+            this.globalWriters = writers;
+        }
+        return this.globalWriters.get(id) ?? new Set();
+    }
+    /** A speculated write in the fast copy: compute the value as a safe
+     * integer, store it to the shadow and its exact double to the local.
+     * Any failed check re-executes the statement in the ordinary copy. */
+    emitSpeculativeWrite(s, resume) {
+        const B = this.B;
+        const target = speculativeWriteTarget(s);
+        const binding = this.integerLoopBindings.get(target.localId);
+        const failed = B.newLabel("spec.bail");
+        let bails = false;
+        this.declare("declare i1 @llvm.expect.i1(i1, i1)");
+        const bail = (condition) => {
+            if (condition === "false")
+                return;
+            bails = true;
+            const expected = B.tmp();
+            B.line(`${expected} = call i1 @llvm.expect.i1(i1 ${condition}, i1 false)`);
+            const next = B.newLabel("spec.ok");
+            B.condBr(expected, failed, next);
+            B.startBlock(next);
+        };
+        // Heap reads come first, before any check, and release their temporaries
+        // at once: a bailing path then owns nothing, and reads have no effect
+        // whose reordering before the arithmetic could be observed.
+        const reads = new Map();
+        if (target.value !== null) {
+            this.frames.push([]);
+            for (const read of speculativeReads(target.value))
+                reads.set(read, this.emitExpr(read));
+            this.releaseFrame(this.frames.pop());
+        }
+        this.frames.push([]);
+        let result;
+        if (target.value === null) {
+            const old = B.tmp();
+            result = B.tmp();
+            B.line(`${old} = load i64, ptr ${binding.slot}`);
+            B.line(`${result} = ${target.op === "+" ? "add" : "sub"} nsw i64 ${old}, 1`);
+            const biased = B.tmp(), outside = B.tmp();
+            B.line(`${biased} = add i64 ${result}, ${Number.MAX_SAFE_INTEGER}`);
+            B.line(`${outside} = icmp ugt i64 ${biased}, ${2 * Number.MAX_SAFE_INTEGER}`);
+            bail(outside);
+        }
+        else
+            result = emitSpeculativeInteger(this, target.value, bail, reads);
+        // Speculable values read only numbers past this point.
+        if (this.frames.pop().length > 0)
+            throw new InternalCompilerError("llvm emitter bug: speculative write owns a temporary");
+        B.line(`store i64 ${result}, ptr ${binding.slot}`);
+        const deferred = this.speculation.deferred;
+        if (!deferred.has(target.localId)) {
+            const number = B.tmp();
+            B.line(`${number} = sitofp i64 ${result} to double`);
+            B.line(`store double ${number}, ptr ${this.binding(target.localId).slot}`);
+        }
+        if (!bails)
+            return;
+        const done = B.newLabel("spec.done");
+        B.br(done);
+        B.startBlock(failed);
+        this.writeBackSpeculativeGlobals(deferred);
+        B.br(resume);
+        B.startBlock(done);
+    }
     /** The amortized cancellation poll, emitted on the loop's back edge (the
      * continue target), after the body. A poll in the header would be a loop
      * exit ahead of the body; LLVM then cannot rotate the loop, so loads that
@@ -4161,6 +4434,14 @@ export class LlEmitter {
         this.B.line(`${v} = load ptr, ptr ${p}`);
         return v;
     }
+    /** The pointer to ScrMap.flags of an index-signature record's overflow
+     * map (byte offset sizeof(size_t) + 3; SCR_MAP_NULL_PROTO is bit 0). */
+    recordMapFlagsPtr(objName, shapeId) {
+        const ovf = this.recordOvfPtr(objName, shapeId);
+        const p = this.B.tmp();
+        this.B.line(`${p} = getelementptr inbounds i8, ptr ${ovf}, i64 ${mapFlagsOffset(this.sizeType)}`);
+        return p;
+    }
     /** Loads a record field (i8-stored bools trunc to i1). An inline union
      * field answers a private stack box with the slot's own bits, ABSENT
      * included: it may only be borrowed. */
@@ -4750,6 +5031,10 @@ export class LlEmitter {
             fn.captures !== undefined ? this.lazyCaptures.stableCaptures(fn.name) : new Set();
         this.integerLoopBindings.clear();
         this.countedLoopsEnabled = this.debug === null && !fn.async && !fn.generator;
+        this.speculativeLoopsEnabled = this.countedLoopsEnabled;
+        this.speculativeFunction = fn.name;
+        this.speculation = null;
+        this.speculationResume = null;
         this.finalFieldBorrows =
             !fn.async && !fn.generator && constructorClass(fn.name) === null && this.finalFields.size > 0;
         this.byteWindowsEnabled = this.countedLoopsEnabled;
@@ -5727,6 +6012,17 @@ export class LlEmitter {
             this.releaseScope(scope);
     }
     emitStmt(s) {
+        const resume = this.speculationResume?.get(s);
+        if (resume && !resume.placed && !this.B.isTerminated()) {
+            // The fast copy's failed checks re-execute this statement here.
+            resume.placed = true;
+            this.B.br(resume.label);
+            this.B.startBlock(resume.label);
+        }
+        if (this.speculation?.writes.has(s)) {
+            this.emitSpeculativeWrite(s, this.speculation.resume.get(s));
+            return;
+        }
         const previous = this.B.debugLocation;
         this.B.debugLocation = this.debug?.location(s.loc, this.debugScope) ?? null;
         const loop = s.kind === "while" || s.kind === "doWhile" || s.kind === "for" || s.kind === "forOf";
@@ -6357,57 +6653,61 @@ export class LlEmitter {
             }
             case "while": {
                 const workerBudget = this.workerLoopBudget(s);
-                const lc = B.newLabel("loop.c");
-                const lb = B.newLabel("loop.b");
                 const le = B.newLabel("loop.e");
-                const lp = workerBudget !== null ? B.newLabel("loop.p") : lc;
-                B.br(lc);
-                B.startBlock(lc);
-                B.condBr(this.emitCondition(s.cond), lb, le);
-                B.startBlock(lb);
-                this.jumpTargets.push({
-                    kind: "loop",
-                    brkLabel: le,
-                    contLabel: lp,
-                    labels: s.labels,
-                    frameDepth: this.frames.length,
-                    scopeDepth: this.scopes.length,
-                    finallyDepth: this.finallyStack.length,
-                });
-                this.emitBlock(s.body);
-                this.jumpTargets.pop();
-                B.br(lp);
-                if (lp !== lc) {
-                    B.startBlock(lp);
-                    this.emitWorkerLoopCheck(workerBudget);
+                this.emitLoopCopies(s, true, le, (exit) => {
+                    const lc = B.newLabel("loop.c");
+                    const lb = B.newLabel("loop.b");
+                    const lp = workerBudget !== null ? B.newLabel("loop.p") : lc;
                     B.br(lc);
-                }
+                    B.startBlock(lc);
+                    B.condBr(this.emitCondition(s.cond), lb, exit);
+                    B.startBlock(lb);
+                    this.jumpTargets.push({
+                        kind: "loop",
+                        brkLabel: exit,
+                        contLabel: lp,
+                        labels: s.labels,
+                        frameDepth: this.frames.length,
+                        scopeDepth: this.scopes.length,
+                        finallyDepth: this.finallyStack.length,
+                    });
+                    this.emitBlock(s.body);
+                    this.jumpTargets.pop();
+                    B.br(lp);
+                    if (lp !== lc) {
+                        B.startBlock(lp);
+                        this.emitWorkerLoopCheck(workerBudget);
+                        B.br(lc);
+                    }
+                });
                 B.startBlock(le);
                 break;
             }
             case "doWhile": {
                 const workerBudget = this.workerLoopBudget(s);
                 // Body first (runs at least once); continue jumps to the CONDITION.
-                const lb = B.newLabel("loop.b");
-                const lc = B.newLabel("loop.c");
                 const le = B.newLabel("loop.e");
-                B.br(lb);
-                B.startBlock(lb);
-                this.jumpTargets.push({
-                    kind: "loop",
-                    brkLabel: le,
-                    contLabel: lc,
-                    labels: s.labels,
-                    frameDepth: this.frames.length,
-                    scopeDepth: this.scopes.length,
-                    finallyDepth: this.finallyStack.length,
+                this.emitLoopCopies(s, true, le, (exit) => {
+                    const lb = B.newLabel("loop.b");
+                    const lc = B.newLabel("loop.c");
+                    B.br(lb);
+                    B.startBlock(lb);
+                    this.jumpTargets.push({
+                        kind: "loop",
+                        brkLabel: exit,
+                        contLabel: lc,
+                        labels: s.labels,
+                        frameDepth: this.frames.length,
+                        scopeDepth: this.scopes.length,
+                        finallyDepth: this.finallyStack.length,
+                    });
+                    this.emitBlock(s.body);
+                    this.jumpTargets.pop();
+                    B.br(lc);
+                    B.startBlock(lc);
+                    this.emitWorkerLoopCheck(workerBudget);
+                    B.condBr(this.emitCondition(s.cond), lb, exit);
                 });
-                this.emitBlock(s.body);
-                this.jumpTargets.pop();
-                B.br(lc);
-                B.startBlock(lc);
-                this.emitWorkerLoopCheck(workerBudget);
-                B.condBr(this.emitCondition(s.cond), lb, le);
                 B.startBlock(le);
                 break;
             }
@@ -6539,8 +6839,6 @@ export class LlEmitter {
                     for (const initializer of initializers)
                         this.emitStmt(initializer);
                 }
-                const lc = B.newLabel("loop.c");
-                const lb = B.newLabel("loop.b");
                 const le = B.newLabel("loop.e");
                 // JS `for (let i ...)`: each iteration gets a FRESH binding holding
                 // a copy of the previous one (closures made in iteration k keep
@@ -6567,70 +6865,76 @@ export class LlEmitter {
                     }
                 };
                 const workerBudget = this.workerLoopBudget(s);
-                const lu = s.update || capturedLets.length > 0 || workerBudget !== null ? B.newLabel("loop.u") : lc;
                 freshenBindings();
-                B.br(lc);
-                B.startBlock(lc);
-                if (integerLoop && integerSlot) {
-                    const receiver = this.emitStableReceiver(integerLoop.limitReceiver, []);
-                    const lenPtr = B.tmp();
-                    const len = B.tmp();
-                    const index = B.tmp();
-                    const inBounds = B.tmp();
-                    B.line(`${lenPtr} = getelementptr inbounds %${integerArrayLoop ? "ScrArr" : "ScrBytes"}, ptr ${receiver.name}, i64 0, i32 1`);
-                    if (integerArrayLoop)
-                        this.markMemoryPointer(lenPtr, "array:header");
-                    B.line(`${len} = load ${this.sizeType}, ptr ${lenPtr}${this.fieldAliasAttachment(lenPtr)}`);
-                    B.line(`${index} = load ${this.sizeType}, ptr ${integerSlot}`);
-                    B.line(`${inBounds} = icmp ult ${this.sizeType} ${index}, ${len}`);
-                    B.condBr(inBounds, lb, le);
-                }
-                else if (countedLoop && integerSlot && countedLimit) {
-                    const index = B.tmp();
-                    const inBounds = B.tmp();
-                    B.line(`${index} = load i64, ptr ${integerSlot}`);
-                    B.line(`${inBounds} = icmp ${countedLoop.step > 0 ? "slt" : "sgt"} i64 ${index}, ${countedLimit}`);
-                    B.condBr(inBounds, lb, le);
-                }
-                else if (s.cond)
-                    B.condBr(this.emitCondition(s.cond), lb, le);
-                else
-                    B.br(lb);
-                B.startBlock(lb);
-                this.jumpTargets.push({
-                    kind: "loop",
-                    brkLabel: le,
-                    contLabel: lu,
-                    labels: s.labels,
-                    frameDepth: this.frames.length,
-                    scopeDepth: this.scopes.length,
-                    finallyDepth: this.finallyStack.length,
-                });
-                this.emitBlock(s.body);
-                this.jumpTargets.pop();
-                B.br(lu);
-                if (lu !== lc) {
-                    B.startBlock(lu);
-                    this.emitWorkerLoopCheck(workerBudget);
-                    freshenBindings();
+                this.emitLoopCopies(s, capturedLets.length === 0, le, (exit) => {
+                    const lc = B.newLabel("loop.c");
+                    const lb = B.newLabel("loop.b");
+                    const lu = s.update || capturedLets.length > 0 || workerBudget !== null
+                        ? B.newLabel("loop.u")
+                        : lc;
+                    B.br(lc);
+                    B.startBlock(lc);
                     if (integerLoop && integerSlot) {
-                        const old = B.tmp();
-                        const next = B.tmp();
-                        B.line(`${old} = load ${this.sizeType}, ptr ${integerSlot}`);
-                        B.line(`${next} = add nuw ${this.sizeType} ${old}, 1`);
-                        B.line(`store ${this.sizeType} ${next}, ptr ${integerSlot}`);
+                        const receiver = this.emitStableReceiver(integerLoop.limitReceiver, []);
+                        const lenPtr = B.tmp();
+                        const len = B.tmp();
+                        const index = B.tmp();
+                        const inBounds = B.tmp();
+                        B.line(`${lenPtr} = getelementptr inbounds %${integerArrayLoop ? "ScrArr" : "ScrBytes"}, ptr ${receiver.name}, i64 0, i32 1`);
+                        if (integerArrayLoop)
+                            this.markMemoryPointer(lenPtr, "array:header");
+                        B.line(`${len} = load ${this.sizeType}, ptr ${lenPtr}${this.fieldAliasAttachment(lenPtr)}`);
+                        B.line(`${index} = load ${this.sizeType}, ptr ${integerSlot}`);
+                        B.line(`${inBounds} = icmp ult ${this.sizeType} ${index}, ${len}`);
+                        B.condBr(inBounds, lb, exit);
                     }
-                    else if (countedLoop && integerSlot) {
-                        const old = B.tmp();
-                        const next = B.tmp();
-                        B.line(`${old} = load i64, ptr ${integerSlot}`);
-                        B.line(`${next} = add nsw i64 ${old}, ${countedLoop.step}`);
-                        B.line(`store i64 ${next}, ptr ${integerSlot}`);
+                    else if (countedLoop && integerSlot && countedLimit) {
+                        const index = B.tmp();
+                        const inBounds = B.tmp();
+                        B.line(`${index} = load i64, ptr ${integerSlot}`);
+                        B.line(`${inBounds} = icmp ${countedLoop.step > 0 ? "slt" : "sgt"} i64 ${index}, ${countedLimit}`);
+                        B.condBr(inBounds, lb, exit);
                     }
-                    else if (s.update)
-                        this.emitStmt(s.update);
-                    B.br(lc);
-                }
+                    else if (s.cond)
+                        B.condBr(this.emitCondition(s.cond), lb, exit);
+                    else
+                        B.br(lb);
+                    B.startBlock(lb);
+                    this.jumpTargets.push({
+                        kind: "loop",
+                        brkLabel: exit,
+                        contLabel: lu,
+                        labels: s.labels,
+                        frameDepth: this.frames.length,
+                        scopeDepth: this.scopes.length,
+                        finallyDepth: this.finallyStack.length,
+                    });
+                    this.emitBlock(s.body);
+                    this.jumpTargets.pop();
+                    B.br(lu);
+                    if (lu !== lc) {
+                        B.startBlock(lu);
+                        this.emitWorkerLoopCheck(workerBudget);
+                        freshenBindings();
+                        if (integerLoop && integerSlot) {
+                            const old = B.tmp();
+                            const next = B.tmp();
+                            B.line(`${old} = load ${this.sizeType}, ptr ${integerSlot}`);
+                            B.line(`${next} = add nuw ${this.sizeType} ${old}, 1`);
+                            B.line(`store ${this.sizeType} ${next}, ptr ${integerSlot}`);
+                        }
+                        else if (countedLoop && integerSlot) {
+                            const old = B.tmp();
+                            const next = B.tmp();
+                            B.line(`${old} = load i64, ptr ${integerSlot}`);
+                            B.line(`${next} = add nsw i64 ${old}, ${countedLoop.step}`);
+                            B.line(`store i64 ${next}, ptr ${integerSlot}`);
+                        }
+                        else if (s.update)
+                            this.emitStmt(s.update);
+                        B.br(lc);
+                    }
+                });
                 B.startBlock(le);
                 this.releaseScope(this.scopes.pop());
                 if (integerLoop)
@@ -8424,6 +8728,10 @@ export class LlEmitter {
     emitExpr(e) {
         return emitExpr(this, e);
     }
+    /** A fresh read-site cache for one constant-key dyn read. */
+    dynReadIcSite() {
+        return `@sc_dyn_read_ic_${this.dynReadIcSites++}`;
+    }
     dynKind(d) {
         return dynKind(this, d);
     }