@geastack/compiler 1.0.15

package/dist/ir/dense-loops.js

@@ -0,0 +1,697 @@
+import { controlFlowGraphOf, dominatorTreeOf, naturalLoopsOf } from './dominance.js';
+import { loopInvariantHoistsOf } from './hoist.js';
+import { borrowSafeOperationsOf } from './borrow-effects.js';
+import { operandsOfIrOperation, resultOfIrOperation } from './queries.js';
+export const emptyDenseLoopPlan = { arrays: [], groups: [], accesses: new Map(), lengths: new Map() };
+/**
+ * Whether a window's array is one this body can actually dereference: a plain
+ * cell needs the target's own storage answer; a value defined before the loop
+ * needs nothing (it is simply named); and a ROW needs its own key already
+ * settled to a real integer -- an un-narrowed `number` key is not an element
+ * access at all (`ir/integers.ts`) -- on top of the same question for the
+ * array it is a row of.
+ */
+const referenceIsAdmitted = (reference, integerValues, admitsCell) => {
+    if (reference.kind === 'cell')
+        return admitsCell(reference.declaration);
+    if (reference.kind === 'value')
+        return true;
+    return integerValues.has(reference.key.value) && referenceIsAdmitted(reference.holder, integerValues, admitsCell);
+};
+/**
+ * Narrows `denseLoopsOf`'s raw plan to the windows this body may actually
+ * render.
+ *
+ * A window not admitted here is never a refusal: the array still renders
+ * through the ordinary indexed path, which is always correct, and this only
+ * decides which windows get the additional fast one. Three things a plan
+ * built from the IR alone cannot settle are decided here, and only the first
+ * is about this backend's own storage rather than about the program:
+ *
+ * - whether this body already has a plain name for the cells a window
+ *   reaches through (`admitsCell`);
+ * - whether the integer census narrowed every index a window's accesses
+ *   read -- an un-narrowed `number` key is not an element access at all --
+ *   except a WRAPPED window, which is exempt: its own admission already
+ *   proves the array non-empty and hole-free (`DenseArray.wrapped`), so a
+ *   remainder by that length or by a literal modulus needs no narrowed index
+ *   to be a real one; one un-narrowed access anywhere in an ordinary window
+ *   takes the WHOLE window down, since every access shares the one pointer
+ *   the narrowing proof is about;
+ * - and, once the two above have dropped some accesses, whether anything is
+ *   left of a window at all: an array with no surviving access has no
+ *   pointer worth materializing, and a flag chain with no claimed window
+ *   below it has nothing to compute either -- a flag ands its enclosing
+ *   loop's, so every group on a claimed window's chain has to exist even
+ *   when nothing indexes anything in that loop, and no group outside that
+ *   chain is needed at all.
+ */
+export const admittedDenseLoopPlanOf = (plan, integerValues, admitsCell) => {
+    if (plan.arrays.length === 0)
+        return { arrays: [], groups: new Map(), accesses: new Map(), lengths: new Map() };
+    const admitted = new Set(plan.arrays
+        .filter((array) => admitsCell(array.counter) && referenceIsAdmitted(array.reference, integerValues, admitsCell))
+        .map((array) => array.ordinal));
+    for (const [operation, access] of plan.accesses) {
+        const array = plan.arrays[access.array];
+        if (operation.kind !== 'get' && operation.kind !== 'set')
+            admitted.delete(access.array);
+        else if (!array?.wrapped && array?.typed === null && !integerValues.has(operation.key.value))
+            admitted.delete(access.array);
+    }
+    const accesses = new Map();
+    const claimed = new Set();
+    for (const [operation, access] of plan.accesses) {
+        if (!admitted.has(access.array))
+            continue;
+        accesses.set(operation, access);
+        claimed.add(access.array);
+    }
+    const arrays = plan.arrays.filter((array) => claimed.has(array.ordinal));
+    const lengths = new Map([...plan.lengths].filter(([, ordinal]) => claimed.has(ordinal)));
+    const groups = new Map();
+    for (const array of arrays)
+        for (const access of accesses.values()) {
+            if (access.array !== array.ordinal)
+                continue;
+            for (let at = access.flag; at !== null;) {
+                const group = plan.groups[at];
+                if (!group || groups.has(at))
+                    break;
+                groups.set(at, group);
+                at = group.parent;
+            }
+        }
+    return { arrays, groups, accesses, lengths };
+};
+export const denseLoopsOf = (body) => {
+    // A try region renders as one assembled chunk, so a preheader inside one has
+    // no single place for the setup to land -- the same restriction `hoist.ts`
+    // takes, and for the same reason.
+    if (body.tryRegions.length > 0 || (body.iteratorCloseRegions?.length ?? 0) > 0)
+        return emptyDenseLoopPlan;
+    const graph = controlFlowGraphOf(body);
+    const dominance = dominatorTreeOf(body);
+    const loops = naturalLoopsOf(graph, dominance);
+    if (loops.length === 0)
+        return emptyDenseLoopPlan;
+    const location = new Map();
+    const operationOf = new Map();
+    const readsCell = new Map();
+    const constantTexts = new Map();
+    const cellWrites = new Map();
+    const usesOf = new Map();
+    const blockOfOperation = new Map();
+    for (const blockId of body.blockOrder) {
+        const block = body.blocks.get(blockId);
+        if (!block)
+            continue;
+        for (const operation of block.operations) {
+            blockOfOperation.set(operation, blockId);
+            const result = 'result' in operation ? operation.result : null;
+            if (result) {
+                location.set(result.id, blockId);
+                operationOf.set(result.id, operation);
+            }
+            if (operation.kind === 'constant')
+                constantTexts.set(operation.result.id, operation.text);
+            if (operation.kind === 'binding-read')
+                readsCell.set(operation.result.id, operation.declaration);
+            if (operation.kind === 'binding-write') {
+                const written = cellWrites.get(operation.declaration) ?? [];
+                written.push({ value: operation.value, block: blockId });
+                cellWrites.set(operation.declaration, written);
+            }
+            for (const operand of operandsOfIrOperation(operation)) {
+                const sites = usesOf.get(operand.value) ?? [];
+                sites.push({ operation, block: blockId });
+                usesOf.set(operand.value, sites);
+            }
+        }
+        // A terminator's own operand is a use like any other: an array named by a
+        // branch condition is an array this window cannot account for.
+        const terminator = block.terminator;
+        if (terminator.kind === 'branch') {
+            const sites = usesOf.get(terminator.condition.value) ?? [];
+            usesOf.set(terminator.condition.value, sites);
+        }
+    }
+    // A value the emitter HOISTS is defined where the hoist puts it, not where
+    // the IR wrote it: `i * N` and the row load `a[i]` both live in the inner
+    // loop's own body until `ir/hoist.ts` moves them to its preheader, and asking
+    // the raw IR where they are answers "inside the loop" for every one of them.
+    // `emitBody` runs the same plan, and renders it before this setup.
+    for (const [blockId, operations] of loopInvariantHoistsOf(body).into)
+        for (const operation of operations) {
+            blockOfOperation.set(operation, blockId);
+            const result = resultOfIrOperation(operation);
+            if (result)
+                location.set(result.id, blockId);
+        }
+    const arrays = [];
+    const accesses = new Map();
+    const groups = [];
+    const definedOutside = (value, blocks) => {
+        const where = location.get(value);
+        return where === undefined || !blocks.has(where);
+    };
+    // A value the preheader may NAME: defined before the loop, so it is both
+    // unchanged by the loop (SSA) and already assigned where the setup renders.
+    // A cell the loop never writes is not enough -- the READ of it can be one of
+    // the loop's own operations, and naming that value in the preheader emits a
+    // use of a variable no statement has assigned yet.
+    const found = loops.map((loop) => loopWindowsOf(loop, body, graph, loops, {
+        body,
+        values: body.values,
+        readsCell,
+        constantTexts,
+        cellWrites,
+        usesOf,
+        operationOf,
+        definedOutside
+    }));
+    const groupOfLoop = new Map();
+    for (const [index, loop] of found.entries()) {
+        if (loop === null)
+            continue;
+        // Innermost-first, so an inner loop is numbered before the outer one it
+        // ands: the ordinals are identities, not an emission order.
+        groupOfLoop.set(index, groups.length);
+        groups.push({ ordinal: groups.length, parent: null, preheader: loop.preheader });
+    }
+    for (const [index, group] of groupOfLoop) {
+        const inner = loops[index];
+        if (!inner)
+            continue;
+        const enclosing = loops.findIndex((outer, at) => at !== index && outer.blocks.has(inner.header) && groupOfLoop.has(at));
+        const parent = enclosing < 0 ? null : (groupOfLoop.get(enclosing) ?? null);
+        groups[group] = { ordinal: group, parent, preheader: groups[group]?.preheader ?? inner.header };
+    }
+    /** The flag an access renders behind: the innermost enclosing loop that has one. */
+    const flagAt = (blockId) => {
+        for (const [index, loop] of loops.entries()) {
+            if (!loop.blocks.has(blockId))
+                continue;
+            const group = groupOfLoop.get(index);
+            if (group !== undefined)
+                return group;
+        }
+        return null;
+    };
+    const blocksOfArray = new Map();
+    for (const [index, loop] of found.entries()) {
+        const group = groupOfLoop.get(index);
+        if (loop === null || group === undefined)
+            continue;
+        for (const candidate of loop.candidates) {
+            const ordinal = arrays.length;
+            const blocks = loops[index]?.blocks;
+            if (blocks)
+                blocksOfArray.set(ordinal, blocks);
+            arrays.push({
+                ordinal,
+                group,
+                reference: candidate.reference,
+                element: candidate.element,
+                typed: candidate.typed,
+                preheader: loop.preheader,
+                wrapped: candidate.wrapped,
+                modulus: candidate.modulus,
+                bases: candidate.bases,
+                counter: loop.counter,
+                bound: loop.bound,
+                inclusive: loop.inclusive,
+                step: loop.step,
+                widened: loop.widened
+            });
+            for (const operation of candidate.operations) {
+                const flag = flagAt(blockOfOperation.get(operation) ?? loop.preheader);
+                if (flag === null)
+                    continue;
+                accesses.set(operation, { array: ordinal, flag });
+            }
+        }
+    }
+    // A window whose array is reached THROUGH one (`grid[i]`) names it behind a
+    // null check, and the preheader has no unconditional place to read a length.
+    // A read the loop does not contain is already outside it -- and substituting
+    // the preheader's name for one that renders BEFORE the preheader would name a
+    // variable no statement has assigned yet, so `location` (which the hoist pass
+    // updates) is what decides membership, not the block the IR wrote it in.
+    const lengths = new Map();
+    for (const array of arrays) {
+        // A constant modulus has no length to hoist: the divisor is already in the
+        // emitted text, and `gea::Divisor`'s prepared reciprocal answers a question
+        // a literal never asks.
+        if (!array.wrapped || array.modulus !== null || array.reference.kind === 'element')
+            continue;
+        const blocks = blocksOfArray.get(array.ordinal);
+        if (!blocks)
+            continue;
+        const cell = array.reference.kind === 'cell' ? array.reference.declaration : null;
+        const held = array.reference.kind === 'value' ? array.reference.operand.value : null;
+        for (const [result, operation] of operationOf) {
+            if (operation.kind !== 'get' || constantTexts.get(operation.key.value) !== 'length')
+                continue;
+            // The re-check every sibling `'length'` site in this file keeps
+            // (line ~560, ~610, `wrapsOwnLength` above) and this one omitted: a
+            // `get` whose key merely RENDERS as the text "length" says nothing on
+            // its own about what kind of receiver it reads. The receiver-identity
+            // test below (`readsCell.get(receiver) === cell` / `receiver === held`)
+            // already only matches a value this loop's own `arrays` census settled
+            // as `array-object` -- `array.reference` is never anything else once
+            // `wrapped` is true -- so this is a defensive restatement of a fact
+            // already implied, not a new refusal; kept for the same reason the
+            // siblings state it locally rather than leaving it to be re-derived
+            // from a different function's invariant.
+            if (operation.receiver.representation.kind !== 'array-object')
+                continue;
+            const where = location.get(result);
+            if (where === undefined || !blocks.has(where))
+                continue;
+            const receiver = operation.receiver.value;
+            if (cell !== null ? readsCell.get(receiver) === cell : receiver === held)
+                lengths.set(result, array.ordinal);
+        }
+    }
+    return { arrays, groups, accesses, lengths };
+};
+const loopWindowsOf = (loop, body, graph, loops, context) => {
+    const outside = (graph.predecessors.get(loop.header) ?? []).filter((predecessor) => !loop.blocks.has(predecessor));
+    const preheader = outside.length === 1 ? outside[0] : undefined;
+    if (preheader === undefined)
+        return null;
+    const header = body.blocks.get(loop.header);
+    if (header?.terminator.kind !== 'branch')
+        return null;
+    const test = context.operationOf.get(header.terminator.condition.value);
+    if (test?.kind !== 'compute' || test.form !== 'binary')
+        return null;
+    if (test.operator !== '<' && test.operator !== '<=')
+        return null;
+    const [left, right] = test.operands;
+    if (!left || !right)
+        return null;
+    const counter = context.readsCell.get(left.value);
+    if (counter === undefined || !context.definedOutside(right.value, loop.blocks))
+        return null;
+    // Exactly one advance, by an amount the preheader can name. Several
+    // advances, or a step the loop itself computes, and "the counter never
+    // exceeds the bound" stops being something the preheader can check.
+    const steps = (context.cellWrites.get(counter) ?? []).filter((write) => loop.blocks.has(write.block));
+    const advance = steps.length === 1 ? steps[0] : undefined;
+    if (!advance)
+        return null;
+    // ...and reached at most once per turn. A write inside an INNER loop runs an
+    // unknown number of times per turn of this one, and then no arithmetic on
+    // this loop's own bound says where the counter got to. Structured TypeScript
+    // compiles to reducible control flow, so every cycle within this loop is one
+    // of `loops`.
+    if (loops.some((inner) => inner.header !== loop.header && inner.blocks.has(advance.block) && loop.blocks.has(inner.header)))
+        return null;
+    const step = stepOf(advance.value, counter, context.operationOf, context.readsCell);
+    if (step === undefined)
+        return null;
+    if (step !== null && !context.definedOutside(step.value, loop.blocks))
+        return null;
+    const candidates = windowsOfLoop(loop.blocks, body, { ...context, counter });
+    if (candidates.length === 0)
+        return null;
+    return {
+        preheader,
+        counter,
+        bound: right,
+        inclusive: test.operator === '<=',
+        step,
+        widened: advanceReachesAnAccess(loop, body, graph, advance.block, counter),
+        candidates
+    };
+};
+/**
+ * Whether an element access can run after this turn's advance of the counter.
+ *
+ * True only when the body can reach an access from the counter's own write
+ * without going back through the header -- which a `for` loop's latch, whose
+ * one successor IS the header, never does.
+ */
+const advanceReachesAnAccess = (loop, body, graph, advanceBlock, counter) => {
+    const after = new Set();
+    const pending = (graph.successors.get(advanceBlock) ?? []).filter((next) => loop.blocks.has(next) && next !== loop.header);
+    while (pending.length > 0) {
+        const blockId = pending.pop();
+        if (blockId === undefined || after.has(blockId))
+            continue;
+        after.add(blockId);
+        for (const next of graph.successors.get(blockId) ?? [])
+            if (loop.blocks.has(next) && next !== loop.header)
+                pending.push(next);
+    }
+    for (const blockId of after) {
+        const block = body.blocks.get(blockId);
+        if (block?.operations.some((operation) => operation.kind === 'get' || operation.kind === 'set'))
+            return true;
+    }
+    const written = body.blocks.get(advanceBlock)?.operations ?? [];
+    const at = written.findIndex((operation) => operation.kind === 'binding-write' && operation.declaration === counter);
+    return at >= 0 && written.slice(at + 1).some((operation) => operation.kind === 'get' || operation.kind === 'set');
+};
+/** `counter + s` / `counter++`: the amount one turn adds, or `undefined` when the write is not an advance. */
+const stepOf = (written, counter, operationOf, readsCell) => {
+    const compute = operationOf.get(written.value);
+    if (compute?.kind !== 'compute')
+        return undefined;
+    if (compute.form === 'update') {
+        const target = compute.operands[0];
+        return target && readsCell.get(target.value) === counter && compute.operator === '++' ? null : undefined;
+    }
+    if (compute.form !== 'binary' || compute.operator !== '+')
+        return undefined;
+    const [left, right] = compute.operands;
+    if (!left || !right)
+        return undefined;
+    if (readsCell.get(left.value) === counter)
+        return right;
+    if (readsCell.get(right.value) === counter)
+        return left;
+    return undefined;
+};
+/** One window's identity, so two accesses to the same array in one loop meet. */
+const referenceKey = (reference) => reference.kind === 'cell'
+    ? `cell:${reference.declaration}`
+    : reference.kind === 'value'
+        ? `value:${reference.operand.value}`
+        : `element:${referenceKey(reference.holder)}:${reference.key.value}`;
+/** Every in-loop site that names the storage this reference stands for. */
+const usesOfReference = (reference, context) => {
+    if (reference.kind === 'cell')
+        return [...context.usesOf.entries()]
+            .filter(([value]) => context.readsCell.get(value) === reference.declaration)
+            .flatMap(([, sites]) => sites);
+    const operand = reference.kind === 'value' ? reference.operand : reference.operand;
+    return context.usesOf.get(operand.value) ?? [];
+};
+/**
+ * The array one access reaches, as something the preheader can name.
+ *
+ * A cell the loop never writes, a value defined before the loop, or -- one
+ * level in -- a row loaded from one of those by a loop-invariant index.
+ */
+const heldArrayOf = (receiver, context, blocks) => {
+    const cell = context.readsCell.get(receiver.value);
+    if (cell !== undefined) {
+        if (!(context.cellWrites.get(cell) ?? []).every((write) => !blocks.has(write.block)))
+            return null;
+        const reference = { kind: 'cell', declaration: cell, representation: receiver.representation };
+        return { reference, watch: [reference], excused: [] };
+    }
+    if (context.definedOutside(receiver.value, blocks)) {
+        const reference = {
+            kind: 'value',
+            operand: receiver,
+            storage: context.values.get(receiver.value) ?? receiver.representation
+        };
+        return { reference, watch: [reference], excused: [] };
+    }
+    const load = context.operationOf.get(receiver.value);
+    if (load?.kind !== 'get' || load.receiver.representation.kind !== 'array-object')
+        return null;
+    if (!context.definedOutside(load.key.value, blocks))
+        return null;
+    const holder = heldArrayOf(load.receiver, context, blocks);
+    // One level only: a row of a row would need the preheader to unpack two
+    // loads behind two conditions, and nothing in the corpus asks for it.
+    if (holder === null || holder.reference.kind === 'element')
+        return null;
+    const reference = { kind: 'element', holder: holder.reference, key: load.key, operand: receiver };
+    return { reference, watch: [reference, holder.reference], excused: [load] };
+};
+/**
+ * The arrays this loop touches only through counter-indexed element accesses.
+ *
+ * Grouped by the array's own identity -- the CELL, not the read: every turn of
+ * the loop reads the cell again, so asking where the receiver VALUE was defined
+ * answers "inside the loop" for an array the loop plainly never changes.
+ */
+const windowsOfLoop = (blocks, body, context) => {
+    const byReference = new Map();
+    const nativeOperations = borrowSafeOperationsOf(body);
+    // No pointer may outlive a callback that can replace/detach its storage.
+    // Numeric typed-array writes alias bytes but cannot invalidate geometry.
+    const nativeOnly = [...blocks].every((id) => body.blocks.get(id)?.operations.every((operation) => nativeOperations.has(operation)));
+    const noteUnsound = (key) => {
+        const found = byReference.get(key);
+        if (found)
+            found.sound = false;
+    };
+    for (const blockId of body.blockOrder) {
+        if (!blocks.has(blockId))
+            continue;
+        const block = body.blocks.get(blockId);
+        if (!block)
+            continue;
+        for (const operation of block.operations) {
+            if (operation.kind !== 'get' && operation.kind !== 'set')
+                continue;
+            const receiver = operation.receiver;
+            if (receiver.representation.kind !== 'array-object' && receiver.representation.kind !== 'typed-array')
+                continue;
+            // Dense typed-array windows lower to a cached raw T* and static
+            // readInBounds/writeInBounds calls. A SharedArrayBuffer view must route
+            // every ordinary access through its backing-store synchronization so it
+            // cannot race Atomics or an overlapping view.
+            if (receiver.representation.kind === 'typed-array' && receiver.representation.buffer === 'shared-array-buffer')
+                continue;
+            const typed = receiver.representation.kind === 'typed-array' ? receiver.representation.element : null;
+            if (typed !== null && !nativeOnly)
+                continue;
+            const element = receiver.representation.kind === 'array-object' ? receiver.representation.element : { kind: 'scalar', domain: 'number' };
+            // `a.length` is a `get` on an array like any element read, and it is the
+            // one that is not an ELEMENT access: it has no index to bound, so asking
+            // for one answers "cannot bound this" and takes the window down with it.
+            if (operation.kind === 'get' && context.constantTexts.get(operation.key.value) === 'length')
+                continue;
+            const held = heldArrayOf(receiver, context, blocks);
+            if (held === null)
+                continue;
+            const key = referenceKey(held.reference);
+            // The array's own length first: an index bounded by the length it is
+            // taken modulo needs no number carried to the preheader, and a program
+            // that spells both is better served by the shape that checks less.
+            const ownLength = wrapsOwnLength(operation.key, receiver, context);
+            const modulus = ownLength ? null : constantModulusOf(operation.key, context, block.operations, block.operations.indexOf(operation));
+            const wrapped = ownLength || modulus !== null;
+            if (typed !== null && (wrapped || held.reference.kind === 'element'))
+                continue;
+            const base = wrapped ? null : indexBaseOf(operation.key, context, blocks);
+            const found = byReference.get(key);
+            if (base === undefined) {
+                if (found)
+                    found.sound = false;
+                else
+                    byReference.set(key, { ...held, element, typed, wrapped, modulus, bases: [], operations: [], sound: false });
+                continue;
+            }
+            if (!found) {
+                byReference.set(key, { ...held, element, typed, wrapped, modulus, bases: [base], operations: [operation], sound: true });
+                continue;
+            }
+            // Different addends each contribute a range check to the one cumulative
+            // preheader flag. Selecting only one would leave the others unchecked.
+            // Wrapped and ordinary accesses still need different geometry proofs.
+            // Two constant moduli in one window would need the LARGER checked at the
+            // preheader, and taking the larger of a pair says nothing about a third
+            // that arrives later. Widening the window is a change of proof, not of
+            // bookkeeping, so a second modulus takes the window down exactly as a
+            // second base does.
+            if (found.wrapped !== wrapped || found.modulus !== modulus)
+                found.sound = false;
+            else {
+                if (!found.bases.some((known) => (known?.value ?? null) === (base?.value ?? null)))
+                    found.bases.push(base);
+                found.operations.push(operation);
+            }
+        }
+    }
+    // Every OTHER use of the array inside the loop disqualifies the window: a
+    // `push`, a call taking it, a store of it somewhere else -- each one can
+    // resize the storage the pointer names, and none of them is something a
+    // bound on the INDEX says anything about.
+    for (const [key, window] of byReference) {
+        if (!window.sound)
+            continue;
+        for (const held of window.watch)
+            for (const site of usesOfReference(held, context)) {
+                if (!blocks.has(site.block))
+                    continue;
+                if (window.operations.includes(site.operation) || window.excused.includes(site.operation))
+                    continue;
+                // A read of the array's own `length` is not a use of the STORAGE: it
+                // cannot resize anything, and it is exactly what a wrapped window's
+                // index is computed from -- so counting it would make the one shape
+                // that needs it impossible to admit.
+                if (site.operation.kind === 'get' && context.constantTexts.get(site.operation.key.value) === 'length')
+                    continue;
+                noteUnsound(key);
+            }
+    }
+    return [...byReference.values()].filter((window) => window.sound && window.operations.length > 0);
+};
+/**
+ * Whether an index is a REMAINDER by this very array's `length`.
+ *
+ * `x % a.length` is in `[0, a.length)` for every dividend, so an access keyed
+ * by one needs no bound of its own -- which is the whole point, because the
+ * bound is what a per-access size read would cost. The receiver of the length
+ * read has to be the SAME value the access itself indexes: `a[x % b.length]`
+ * proves nothing about `a`.
+ *
+ * The zero-length case is the one the arithmetic does not cover -- `x % 0` is
+ * NaN, which is no index at all -- and it is the preheader's `size() > 0` that
+ * rules it out, not this.
+ */
+const wrapsOwnLength = (key, receiver, context) => {
+    const compute = context.operationOf.get(key.value);
+    if (compute?.kind !== 'compute' || compute.form !== 'binary' || compute.operator !== '%')
+        return false;
+    const divisor = compute.operands[1];
+    if (!divisor)
+        return false;
+    const read = context.operationOf.get(divisor.value);
+    if (read?.kind !== 'get' || context.constantTexts.get(read.key.value) !== 'length')
+        return false;
+    if (read.receiver.representation.kind !== 'array-object')
+        return false;
+    // The same ARRAY, which is not the same SSA value: every turn of the loop
+    // reads the cell again, so `ring.length` and `ring[...]` name two different
+    // values of one cell. Comparing the cell is what the window is grouped by
+    // anyway (`referenceKey`), and the window already requires that the loop
+    // never writes it.
+    const own = context.readsCell.get(receiver.value);
+    const divisorCell = context.readsCell.get(read.receiver.value);
+    return read.receiver.value === receiver.value || (own !== undefined && own === divisorCell);
+};
+/**
+ * The positive integer an index is taken modulo, when the divisor is a
+ * CONSTANT -- `table[i % 16]`.
+ *
+ * The same arithmetic `wrapsOwnLength` relies on: `x % n` lies in `[0, n)` for
+ * every dividend whenever `n > 0`. What this does NOT prove is that `n` is
+ * inside the array, because a constant says nothing about a length; the
+ * preheader's `size() >= n` is what closes that, and `DenseArray.modulus`
+ * carries the number there.
+ *
+ * Rejects anything that is not a plain positive integer literal. A fractional
+ * or negative divisor is not a modulus a window can be proved from, and a text
+ * this cannot read is simply not one of these.
+ */
+const constantModulusOf = (key, context, operations, at) => {
+    const compute = remainderBehind(key, context, operations, at);
+    if (compute?.kind !== 'compute' || compute.form !== 'binary' || compute.operator !== '%')
+        return null;
+    const divisor = compute.operands[1];
+    if (!divisor)
+        return null;
+    const text = context.constantTexts.get(divisor.value);
+    if (text === undefined)
+        return null;
+    const value = Number(text);
+    if (!Number.isSafeInteger(value) || value <= 0)
+        return null;
+    return value;
+};
+/**
+ * Where an index's value was computed, seeing through a binding.
+ *
+ * `const slot = i % 16; table[slot] = v; return table[(slot + 1) % 16]` writes
+ * the remainder into a cell and indexes with a READ of it, so the store's key
+ * is a `binding-read` and the load's key is the `%` itself. Asking only the
+ * operation the key names would make those two accesses disagree about the
+ * window's shape, and a window whose accesses disagree is no window -- which is
+ * how the two halves of an ordinary table update came to prove nothing.
+ *
+ * The write it resolves to is the LAST one this block made before the access,
+ * which is the definition the read observes: within a block, operations run in
+ * order and a binding is the only thing that writes a binding. It deliberately
+ * looks no further -- a write in another block would need dominance, and the
+ * shape this exists for puts both in the body it indexes from.
+ */
+const remainderBehind = (key, context, operations, at) => {
+    const direct = context.operationOf.get(key.value);
+    if (direct?.kind === 'compute')
+        return direct;
+    const cell = context.readsCell.get(key.value);
+    if (cell === undefined)
+        return undefined;
+    let seen;
+    for (let index = 0; index < at; index += 1) {
+        const candidate = operations[index];
+        if (candidate?.kind === 'binding-write' && candidate.declaration === cell)
+            seen = context.operationOf.get(candidate.value.value);
+    }
+    return seen;
+};
+/**
+ * The loop-invariant addend an index carries, `null` for the bare counter, and
+ * `undefined` for an index this cannot bound.
+ */
+const indexBaseOf = (key, context, blocks) => {
+    if (context.readsCell.get(key.value) === context.counter)
+        return null;
+    const parallel = parallelCounterBaseOf(key, context, blocks);
+    if (parallel !== undefined)
+        return parallel;
+    const compute = context.operationOf.get(key.value);
+    if (compute?.kind !== 'compute' || compute.form !== 'binary' || compute.operator !== '+')
+        return undefined;
+    const [left, right] = compute.operands;
+    if (!left || !right)
+        return undefined;
+    if (context.readsCell.get(left.value) === context.counter && context.definedOutside(right.value, blocks))
+        return right;
+    if (context.readsCell.get(right.value) === context.counter && context.definedOutside(left.value, blocks))
+        return left;
+    return undefined;
+};
+/** Two counters advanced together by one differ by their initial offset.
+ * Requiring a zero primary seed and adjacent advances avoids synthesizing
+ * arithmetic or assuming that a conditional/inner-loop advance ran. */
+const parallelCounterBaseOf = (key, context, blocks) => {
+    const secondary = context.readsCell.get(key.value);
+    if (secondary === undefined || secondary === context.counter)
+        return undefined;
+    const primaryWrites = context.cellWrites.get(context.counter) ?? [];
+    const secondaryWrites = context.cellWrites.get(secondary) ?? [];
+    const primarySeeds = primaryWrites.filter((write) => !blocks.has(write.block));
+    const secondarySeeds = secondaryWrites.filter((write) => !blocks.has(write.block));
+    const primarySteps = primaryWrites.filter((write) => blocks.has(write.block));
+    const secondarySteps = secondaryWrites.filter((write) => blocks.has(write.block));
+    const isLiteral = (value, text) => {
+        const operation = context.operationOf.get(value.value);
+        return operation?.kind === 'constant' && operation.literal === 'number' && operation.text === text;
+    };
+    if (primarySeeds.length === 0 || !primarySeeds.every((seed) => isLiteral(seed.value, '0')))
+        return undefined;
+    if (secondarySeeds.length !== 1 || primarySteps.length !== 1 || secondarySteps.length !== 1)
+        return undefined;
+    const seed = secondarySeeds[0];
+    const primary = primarySteps[0];
+    const other = secondarySteps[0];
+    if (primary.block !== other.block || !context.definedOutside(seed.value.value, blocks))
+        return undefined;
+    const unitStep = (value, cell) => {
+        const step = stepOf(value, cell, context.operationOf, context.readsCell);
+        return step === null || (step !== undefined && isLiteral(step, '1'));
+    };
+    if (!unitStep(primary.value, context.counter) || !unitStep(other.value, secondary))
+        return undefined;
+    const operations = context.body.blocks.get(primary.block)?.operations ?? [];
+    const first = operations.findIndex((operation) => operation.kind === 'binding-write' && operation.declaration === context.counter);
+    const second = operations.findIndex((operation) => operation.kind === 'binding-write' && operation.declaration === secondary);
+    if (first < 0 || second < 0)
+        return undefined;
+    if (operations
+        .slice(Math.min(first, second) + 1, Math.max(first, second))
+        .some((operation) => operation.kind === 'get' || operation.kind === 'set'))
+        return undefined;
+    return seed.value;
+};