redscript-mc 2.6.2 → 3.0.0

package/dist/src/optimizer/licm.js

@@ -0,0 +1,371 @@
+"use strict";
+/**
+ * Loop-Invariant Code Motion (LICM) — MIR optimization pass.
+ *
+ * For each natural loop (detected by the loop_header / loop_body / loop_latch
+ * naming convention used by the RedScript HIR→MIR lowering), instructions
+ * whose operands are not modified inside the loop and that have no side
+ * effects are hoisted to a newly-inserted preheader block that jumps to the
+ * loop header.
+ *
+ * Algorithm:
+ *   1. Identify all loops via the loop_header block naming convention.
+ *   2. Collect all temps defined anywhere in the loop (variant set).
+ *   3. Walk each loop block's instructions; an instruction is loop-invariant
+ *      when:
+ *        a. It has no side effects (no call, nbt_write, score_write, etc.).
+ *        b. Every operand is either a constant OR a temp not in the variant set.
+ *   4. Insert a fresh preheader block before the loop header, redirect the
+ *      predecessor(s) of the header (excluding the back-edge latch) to the
+ *      preheader, and move the hoisted instructions there.
+ *   5. Remove hoisted instructions from their original blocks.
+ *   6. Recompute predecessor lists.
+ *
+ * Limitations:
+ *   - Only handles the canonical loop shape produced by the RedScript compiler
+ *     (loop_header / loop_body / loop_latch block id prefixes).
+ *   - Requires that the loop have exactly one non-back-edge predecessor of
+ *     the header (i.e. one entry edge).
+ *   - Does not hoist instructions that could trap (div/mod with a variable
+ *     denominator) — we conservatively keep those in place.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.licm = licm;
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function licm(fn) {
+    let current = fn;
+    let changed = true;
+    // Iterate to fixpoint — multiple loops, or newly-exposed invariants
+    while (changed) {
+        changed = false;
+        const result = tryHoistOne(current);
+        if (result !== current) {
+            current = result;
+            changed = true;
+        }
+    }
+    return current;
+}
+function tryHoistOne(fn) {
+    const blockMap = new Map(fn.blocks.map(b => [b.id, b]));
+    for (const block of fn.blocks) {
+        if (!block.id.startsWith('loop_header'))
+            continue;
+        const info = analyzeLoop(fn, blockMap, block);
+        if (!info)
+            continue;
+        const hoisted = collectInvariant(info, blockMap);
+        if (hoisted.length === 0)
+            continue;
+        return applyHoist(fn, blockMap, info, hoisted);
+    }
+    return fn;
+}
+// ---------------------------------------------------------------------------
+// Loop detection
+// ---------------------------------------------------------------------------
+function analyzeLoop(fn, blockMap, header) {
+    // Header must branch (loop condition check)
+    if (header.term.kind !== 'branch')
+        return null;
+    // Find the latch: the block that jumps back to the header
+    const latchId = findLatch(fn, header.id);
+    if (!latchId)
+        return null;
+    // Find the non-back-edge predecessor (the block that first enters the loop)
+    const preHeaderPredId = findPreHeaderPred(fn, header.id, latchId);
+    if (!preHeaderPredId)
+        return null;
+    // Collect all loop block ids: header + any block reachable from header
+    // that can reach the latch (simple: everything up to and including latch)
+    const loopBlockIds = collectLoopBlocks(fn, blockMap, header.id, latchId);
+    return { headerId: header.id, loopBlockIds, preHeaderPredId, latchId };
+}
+/** Find the latch: a predecessor of header that is dominated by header.
+ *  In the canonical shape, it's the block with id prefix loop_latch that
+ *  jumps back to the header.  Fall back to any predecessor != preheader. */
+function findLatch(fn, headerId) {
+    for (const block of fn.blocks) {
+        if (block.id.startsWith('loop_latch')) {
+            const targets = getTermTargets(block.term);
+            if (targets.includes(headerId))
+                return block.id;
+        }
+    }
+    // Fallback: any predecessor that comes after the header in block order
+    // (a back-edge in the CFG)
+    const headerIdx = fn.blocks.findIndex(b => b.id === headerId);
+    for (let i = headerIdx + 1; i < fn.blocks.length; i++) {
+        const block = fn.blocks[i];
+        const targets = getTermTargets(block.term);
+        if (targets.includes(headerId))
+            return block.id;
+    }
+    return null;
+}
+/** Find the single non-latch predecessor of the header. */
+function findPreHeaderPred(fn, headerId, latchId) {
+    const preds = [];
+    for (const block of fn.blocks) {
+        if (block.id === latchId)
+            continue;
+        const targets = getTermTargets(block.term);
+        if (targets.includes(headerId))
+            preds.push(block.id);
+    }
+    return preds.length === 1 ? preds[0] : null;
+}
+/** BFS/DFS: collect all block ids that are in the loop (header..latch). */
+function collectLoopBlocks(fn, blockMap, headerId, latchId) {
+    const result = new Set();
+    const queue = [headerId];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (result.has(id))
+            continue;
+        result.add(id);
+        if (id === latchId)
+            continue; // don't expand past the latch's targets
+        const block = blockMap.get(id);
+        if (!block)
+            continue;
+        for (const target of getTermTargets(block.term)) {
+            // Only follow edges that stay inside the loop (don't chase the exit edge)
+            // Heuristic: follow targets that have 'loop_' prefix or are the latch
+            if (!result.has(target) && isLoopBlock(target, headerId)) {
+                queue.push(target);
+            }
+        }
+    }
+    return result;
+}
+function isLoopBlock(id, headerId) {
+    // A block belongs to the loop if it has a loop_ prefix derived from the same
+    // loop as headerId, or is the header itself.
+    if (id === headerId)
+        return true;
+    // Extract the loop suffix from headerId: "loop_header" or "loop_header_N"
+    const suffix = headerId.replace(/^loop_header/, '');
+    return (id.startsWith('loop_body' + suffix) ||
+        id.startsWith('loop_latch' + suffix) ||
+        id.startsWith('loop_header' + suffix) ||
+        // Nested loop blocks will have further prefixes — include them
+        id.startsWith('loop_') && id.includes(suffix));
+}
+function collectInvariant(info, blockMap) {
+    // Step 1: collect the set of all temps defined (written) anywhere in the loop
+    const variantTemps = new Set();
+    for (const id of info.loopBlockIds) {
+        const block = blockMap.get(id);
+        if (!block)
+            continue;
+        for (const instr of block.instrs) {
+            const dst = getInstrDst(instr);
+            if (dst !== null)
+                variantTemps.add(dst);
+        }
+        // Terminator dsts (there are none in practice, but be safe)
+        const termDst = getInstrDst(block.term);
+        if (termDst !== null)
+            variantTemps.add(termDst);
+    }
+    // Step 2: iteratively find invariant instructions
+    // (an instr whose operands are all non-variant can itself be treated as
+    //  non-variant after it is removed, exposing further candidates)
+    const hoisted = [];
+    let changed = true;
+    const removedKeys = new Set(); // "blockId:index"
+    while (changed) {
+        changed = false;
+        for (const id of info.loopBlockIds) {
+            const block = blockMap.get(id);
+            if (!block)
+                continue;
+            for (let i = 0; i < block.instrs.length; i++) {
+                const key = `${id}:${i}`;
+                if (removedKeys.has(key))
+                    continue;
+                const instr = block.instrs[i];
+                const dst = getInstrDst(instr);
+                // Must have a dst (otherwise it's a side-effectful no-dst instr)
+                if (dst === null)
+                    continue;
+                // Must not have side effects
+                if (hasSideEffects(instr))
+                    continue;
+                // Skip div/mod with variable denominator (potential trap)
+                if ((instr.kind === 'div' || instr.kind === 'mod') && instr.b.kind === 'temp')
+                    continue;
+                // All source operands must be invariant (not in variantTemps)
+                if (!allOperandsInvariant(instr, variantTemps))
+                    continue;
+                // This instruction is loop-invariant — hoist it
+                hoisted.push({ fromBlockId: id, instrIndex: i, instr });
+                removedKeys.add(key);
+                // After hoisting, the dst is no longer variant inside the loop
+                variantTemps.delete(dst);
+                changed = true;
+            }
+        }
+    }
+    return hoisted;
+}
+function allOperandsInvariant(instr, variantTemps) {
+    for (const op of getSourceOperands(instr)) {
+        if (op.kind === 'temp' && variantTemps.has(op.name))
+            return false;
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Applying the hoist
+// ---------------------------------------------------------------------------
+function applyHoist(fn, blockMap, info, hoisted) {
+    const { headerId, preHeaderPredId, latchId } = info;
+    // Build a key set for quick lookup: "blockId:instrIndex"
+    const hoistedKeys = new Set(hoisted.map(h => `${h.fromBlockId}:${h.instrIndex}`));
+    // Collect hoisted instrs in order (they were collected left-to-right)
+    const hoistedInstrs = hoisted.map(h => h.instr);
+    // Insert a fresh preheader block
+    const preHeaderId = headerId.replace('loop_header', 'loop_preheader');
+    const preHeaderBlock = {
+        id: preHeaderId,
+        instrs: hoistedInstrs,
+        term: { kind: 'jump', target: headerId },
+        preds: [], // will be recomputed
+    };
+    // Rewrite the predecessor's jump from header → preHeader
+    const newBlocks = [];
+    for (const block of fn.blocks) {
+        if (block.id === preHeaderPredId) {
+            // Redirect its outgoing edge(s) from headerId to preHeaderId
+            newBlocks.push({
+                ...block,
+                term: redirectTerm(block.term, headerId, preHeaderId),
+            });
+            // Insert the new preheader right after this block
+            newBlocks.push(preHeaderBlock);
+        }
+        else {
+            // Remove hoisted instructions from their source blocks
+            if (info.loopBlockIds.has(block.id)) {
+                const newInstrs = block.instrs.filter((_, i) => !hoistedKeys.has(`${block.id}:${i}`));
+                newBlocks.push({ ...block, instrs: newInstrs });
+            }
+            else {
+                newBlocks.push(block);
+            }
+        }
+    }
+    return { ...fn, blocks: recomputePreds(newBlocks) };
+}
+function redirectTerm(term, from, to) {
+    switch (term.kind) {
+        case 'jump':
+            return term.target === from ? { ...term, target: to } : term;
+        case 'branch':
+            return {
+                ...term,
+                then: term.then === from ? to : term.then,
+                else: term.else === from ? to : term.else,
+            };
+        default:
+            return term;
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function hasSideEffects(instr) {
+    return (instr.kind === 'call' ||
+        instr.kind === 'call_macro' ||
+        instr.kind === 'call_context' ||
+        instr.kind === 'nbt_write' ||
+        instr.kind === 'nbt_write_dynamic' ||
+        instr.kind === 'score_write');
+}
+function getInstrDst(instr) {
+    switch (instr.kind) {
+        case 'const':
+        case 'copy':
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'neg':
+        case 'cmp':
+        case 'and':
+        case 'or':
+        case 'not':
+        case 'nbt_read':
+        case 'nbt_read_dynamic':
+        case 'nbt_list_len':
+        case 'string_match':
+        case 'score_read':
+            return instr.dst;
+        case 'call':
+        case 'call_macro':
+            return instr.dst;
+        default:
+            return null;
+    }
+}
+function getSourceOperands(instr) {
+    switch (instr.kind) {
+        case 'copy':
+        case 'neg':
+        case 'not':
+            return [instr.src];
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'cmp':
+        case 'and':
+        case 'or':
+            return [instr.a, instr.b];
+        case 'nbt_write':
+            return [instr.src];
+        case 'nbt_write_dynamic':
+            return [instr.indexSrc, instr.valueSrc];
+        case 'nbt_read_dynamic':
+            return [instr.indexSrc];
+        case 'call':
+            return [...instr.args];
+        case 'call_macro':
+            return instr.args.map(a => a.value);
+        case 'branch':
+            return [instr.cond];
+        case 'return':
+            return instr.value ? [instr.value] : [];
+        case 'score_write':
+            return [instr.src];
+        default:
+            return [];
+    }
+}
+function getTermTargets(term) {
+    switch (term.kind) {
+        case 'jump': return [term.target];
+        case 'branch': return [term.then, term.else];
+        default: return [];
+    }
+}
+function recomputePreds(blocks) {
+    const predMap = new Map();
+    for (const b of blocks)
+        predMap.set(b.id, []);
+    for (const block of blocks) {
+        for (const target of getTermTargets(block.term)) {
+            const preds = predMap.get(target);
+            if (preds)
+                preds.push(block.id);
+        }
+    }
+    return blocks.map(b => ({ ...b, preds: predMap.get(b.id) ?? [] }));
+}
+//# sourceMappingURL=licm.js.map

package/dist/src/optimizer/pipeline.js

@@ -13,13 +13,18 @@ exports.selectorCache = void 0;
 exports.optimizeFunction = optimizeFunction;
 exports.optimizeModule = optimizeModule;
 const constant_fold_1 = require("./constant_fold");
+const strength_reduction_1 = require("./strength_reduction");
 const copy_prop_1 = require("./copy_prop");
 const dce_1 = require("./dce");
 const block_merge_1 = require("./block_merge");
 const branch_simplify_1 = require("./branch_simplify");
 const unroll_1 = require("./unroll");
+const licm_1 = require("./licm");
 const nbt_batch_1 = require("./nbt-batch");
 const interprocedural_1 = require("./interprocedural");
+const auto_inline_1 = require("./auto-inline");
+const inline_1 = require("./inline");
+const cse_1 = require("./cse");
 // selectorCache is intentionally excluded from the default pipeline:
 // it emits synthetic __sel_cleanup_* / __sel_tag_* call_context instructions
 // that require codegen support before being used end-to-end.
@@ -27,8 +32,11 @@ var selector_cache_1 = require("./selector-cache");
 Object.defineProperty(exports, "selectorCache", { enumerable: true, get: function () { return selector_cache_1.selectorCache; } });
 const defaultPasses = [
     unroll_1.loopUnroll,
+    licm_1.licm,
     nbt_batch_1.nbtBatchRead,
     constant_fold_1.constantFold,
+    strength_reduction_1.strengthReduction,
+    cse_1.cse,
     copy_prop_1.copyProp,
     branch_simplify_1.branchSimplify,
     dce_1.dce,
@@ -48,9 +56,11 @@ function optimizeFunction(fn, passes = defaultPasses) {
     return current;
 }
 function optimizeModule(mod, passes) {
+    // Module-level pass: inline @inline-marked functions before per-function opts
+    const inlined = (0, auto_inline_1.autoInlineSmallFunctions)((0, inline_1.inlinePass)(mod));
     const perFnOptimized = {
-        ...mod,
-        functions: mod.functions.map(fn => optimizeFunction(fn, passes)),
+        ...inlined,
+        functions: inlined.functions.map(fn => optimizeFunction(fn, passes)),
     };
     // Module-level pass: interprocedural constant propagation
     return (0, interprocedural_1.interproceduralConstProp)(perFnOptimized);

package/dist/src/optimizer/strength_reduction.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Strength Reduction — MIR algebraic simplification pass.
+ *
+ * Rewrites expensive or redundant arithmetic into cheaper equivalents:
+ * - x * 2   -> x + x
+ * - x * 1   -> x
+ * - x * 0   -> 0
+ * - x + 0   -> x
+ * - x - 0   -> x
+ * - x / 1   -> x
+ * - x ^ 1   -> x
+ * - x * -1  -> -x
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function strengthReduction(fn: MIRFunction): MIRFunction;

package/dist/src/optimizer/strength_reduction.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Strength Reduction — MIR algebraic simplification pass.
+ *
+ * Rewrites expensive or redundant arithmetic into cheaper equivalents:
+ * - x * 2   -> x + x
+ * - x * 1   -> x
+ * - x * 0   -> 0
+ * - x + 0   -> x
+ * - x - 0   -> x
+ * - x / 1   -> x
+ * - x ^ 1   -> x
+ * - x * -1  -> -x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strengthReduction = strengthReduction;
+function strengthReduction(fn) {
+    return {
+        ...fn,
+        blocks: fn.blocks.map(rewriteBlock),
+    };
+}
+function rewriteBlock(block) {
+    return {
+        ...block,
+        instrs: block.instrs.map(instr => rewriteInstr(instr) ?? instr),
+    };
+}
+function rewriteInstr(instr) {
+    const powInstr = asPowInstr(instr);
+    if (powInstr && isConst(powInstr.b, 1))
+        return makeCopy(powInstr.dst, powInstr.a, powInstr.sourceLoc);
+    switch (instr.kind) {
+        case 'mul':
+            return rewriteMul(instr);
+        case 'add':
+            if (isConst(instr.a, 0))
+                return makeCopy(instr.dst, instr.b, instr.sourceLoc);
+            if (isConst(instr.b, 0))
+                return makeCopy(instr.dst, instr.a, instr.sourceLoc);
+            return null;
+        case 'sub':
+            if (isConst(instr.b, 0))
+                return makeCopy(instr.dst, instr.a, instr.sourceLoc);
+            return null;
+        case 'div':
+            if (isConst(instr.b, 1))
+                return makeCopy(instr.dst, instr.a, instr.sourceLoc);
+            return null;
+        default:
+            return null;
+    }
+}
+function rewriteMul(instr) {
+    if (isConst(instr.a, 0) || isConst(instr.b, 0))
+        return makeConst(instr.dst, 0, instr.sourceLoc);
+    if (isConst(instr.a, 1))
+        return makeCopy(instr.dst, instr.b, instr.sourceLoc);
+    if (isConst(instr.b, 1))
+        return makeCopy(instr.dst, instr.a, instr.sourceLoc);
+    if (isConst(instr.a, -1))
+        return makeNeg(instr.dst, instr.b, instr.sourceLoc);
+    if (isConst(instr.b, -1))
+        return makeNeg(instr.dst, instr.a, instr.sourceLoc);
+    if (isConst(instr.a, 2))
+        return makeAdd(instr.dst, instr.b, instr.b, instr.sourceLoc);
+    if (isConst(instr.b, 2))
+        return makeAdd(instr.dst, instr.a, instr.a, instr.sourceLoc);
+    return null;
+}
+function isConst(op, value) {
+    return op.kind === 'const' && op.value === value;
+}
+function asPowInstr(instr) {
+    const candidate = instr;
+    return candidate.kind === 'pow' ? candidate : null;
+}
+function makeCopy(dst, src, sourceLoc) {
+    return sourceLoc ? { kind: 'copy', dst, src, sourceLoc } : { kind: 'copy', dst, src };
+}
+function makeConst(dst, value, sourceLoc) {
+    return sourceLoc ? { kind: 'const', dst, value, sourceLoc } : { kind: 'const', dst, value };
+}
+function makeNeg(dst, src, sourceLoc) {
+    return sourceLoc ? { kind: 'neg', dst, src, sourceLoc } : { kind: 'neg', dst, src };
+}
+function makeAdd(dst, a, b, sourceLoc) {
+    return sourceLoc ? { kind: 'add', dst, a, b, sourceLoc } : { kind: 'add', dst, a, b };
+}
+//# sourceMappingURL=strength_reduction.js.map

package/dist/src/optimizer/tco.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Tail Call Optimization (TCO) — MIR optimization pass.
+ *
+ * Detects direct self-tail-calls and converts them into loops, eliminating
+ * the recursive function call entirely.
+ *
+ * ## Definition
+ * A tail call is a `call` instruction whose result is immediately returned
+ * in the same block (i.e., the block's terminator is `return` and the last
+ * non-terminator instruction is `call dst fn args` where fn === current fn,
+ * and the return value is that dst temp).
+ *
+ * ## Transformation
+ * Given a function like:
+ *
+ *   fn factorial(n, acc):
+ *     entry:
+ *       t0 = cmp le n 1
+ *       branch t0 → base_case, recurse
+ *     base_case:
+ *       return acc
+ *     recurse:
+ *       t1 = mul acc n
+ *       t2 = sub n 1
+ *       t3 = call factorial(t2, t1)   ← tail call
+ *       return t3
+ *
+ * We:
+ *   1. Create a new "__tco_entry" preamble block that copies original params
+ *      into "loop parameter" temps (__lp0, __lp1, ...) and jumps to the
+ *      original entry block.
+ *   2. In all blocks (including entry), substitute uses of original param
+ *      temps with loop params, so subsequent iterations use updated values.
+ *   3. In tail-call blocks: evaluate call args (to avoid aliasing), assign
+ *      results to loop params, and jump back to original entry — no call emitted.
+ */
+import type { MIRFunction, BlockId } from '../mir/types';
+/**
+ * Attempt to apply TCO to a single function.
+ * Returns the transformed function if any tail calls were optimized,
+ * or the original function unchanged if no self-tail-calls were found.
+ */
+export declare function tailCallOptimize(fn: MIRFunction): MIRFunction;
+/**
+ * Returns a list of tail-call block descriptors for every block that contains
+ * a self-tail-call: the last non-terminator instruction is a `call` to the
+ * same function, and the block terminator is `return` of that call's result.
+ */
+export declare function findTailCallBlocks(fn: MIRFunction): Array<{
+    blockId: BlockId;
+    callIdx: number;
+    argCount: number;
+}>;