@scriptc/compiler 0.4.3 → 0.4.5

package/dist/backend/llvm/speculative-integers.js

@@ -1,7 +1,292 @@
-import { everyExprChild, everyStmtChild } from "../../ir/traverse.js";
+import { everyExpr, everyExprChild, everyStmtChild } from "../../ir/traverse.js";
+import { InternalCompilerError } from "../../errors.js";
 import { f64Lit } from "./common.js";
 import { exactInteger, widenInteger } from "./integer-values.js";
 import { withinInt32 } from "../../ir/integer-ranges.js";
+/** `s` (a speculated write) writing `value` instead. */
+export function withSpeculativeValue(s, value) {
+    switch (s.kind) {
+        case "assign":
+            return { ...s, value };
+        case "varDecl":
+            return { ...s, init: value };
+        case "exprStmt":
+            if (s.expr.kind === "assignExpr")
+                return { ...s, expr: { ...s.expr, value } };
+            break;
+        default:
+            break;
+    }
+    throw new InternalCompilerError(`llvm emitter bug: speculated ${s.kind} with a rewritten value`);
+}
+/** Calls nest at most this deep in one expansion. */
+const MAX_INLINE_DEPTH = 4;
+/** An expansion larger than this stays a call. */
+const MAX_INLINE_NODES = 64;
+/** A function that only returns arithmetic over its number parameters:
+ * `function trim(v, n) { return v - Math.floor(v / Math.pow(2, n)) * Math.pow(2, n); }`.
+ * Its call evaluates nothing but its arguments, so a speculated write may
+ * expand it in place. A call in its body must be of another such function
+ * (`resolve`): any other call could change what the expansion reads. */
+export function inlinableNumberFunction(fn, resolve) {
+    if (fn.async ||
+        fn.generator ||
+        (fn.captures?.length ?? 0) > 0 ||
+        (fn.classCaptures?.length ?? 0) > 0 ||
+        fn.returnType.kind !== "f64" ||
+        fn.params.some((p) => p.type.kind !== "f64" && p.type.kind !== "union") ||
+        fn.body.length !== 1 ||
+        fn.body[0].kind !== "return" ||
+        fn.body[0].value === undefined)
+        return undefined;
+    const params = fn.params.map((p) => p.localId);
+    const known = new Set(params);
+    let nodes = 0;
+    // A parameter of a union type (`number | undefined`) is read only
+    // through its tag test and narrowing, which a wrapped argument folds.
+    const union = (e) => e.kind === "varRef" && known.has(e.localId);
+    const pure = (e) => {
+        if (++nodes > MAX_INLINE_NODES)
+            return false;
+        if (e.kind === "boolLit")
+            return true;
+        if (e.kind === "unionIsTag")
+            return union(e.value);
+        if (e.kind === "unionNarrow")
+            return e.type.kind === "f64" && union(e.value);
+        if (e.type.kind !== "f64")
+            return false;
+        switch (e.kind) {
+            case "numLit":
+                return true;
+            case "varRef":
+                return known.has(e.localId);
+            case "ternary":
+                return pure(e.cond) && pure(e.then) && pure(e.else_);
+            case "bin":
+                return (INTEGER_OPS.has(e.op) || e.op === "/") && pure(e.left) && pure(e.right);
+            case "unary":
+                return e.op === "-" && pure(e.operand);
+            case "libCall":
+                return (e.fn === "math.floor" || e.fn === "math.pow") && e.args.every(pure);
+            case "call":
+                return resolve?.(e.callee) !== undefined && e.args.every(pure);
+            default:
+                return false;
+        }
+    };
+    const body = fn.body[0].value;
+    return pure(body) ? { params, body } : undefined;
+}
+/** `e` with each parameter reference replaced by its argument. A tag test
+ * or narrowing of a wrapped argument folds, and so does a ternary over a
+ * folded test. */
+function substitute(e, args) {
+    switch (e.kind) {
+        case "varRef":
+            return args.get(e.localId) ?? e;
+        case "unionIsTag": {
+            const value = substitute(e.value, args);
+            if (value.kind !== "unionWrap" || value.unionId !== e.unionId)
+                return { ...e, value };
+            return {
+                kind: "boolLit",
+                value: (value.tag === e.tag) !== (e.negated === true),
+                type: e.type,
+                loc: e.loc,
+            };
+        }
+        case "unionNarrow": {
+            const value = substitute(e.value, args);
+            return value.kind === "unionWrap" && value.unionId === e.unionId && value.tag === e.tag
+                ? value.value
+                : { ...e, value };
+        }
+        case "ternary": {
+            const cond = substitute(e.cond, args);
+            if (cond.kind === "boolLit")
+                return substitute(cond.value ? e.then : e.else_, args);
+            return { ...e, cond, then: substitute(e.then, args), else_: substitute(e.else_, args) };
+        }
+        case "bin":
+            return { ...e, left: substitute(e.left, args), right: substitute(e.right, args) };
+        case "unary":
+            return { ...e, operand: substitute(e.operand, args) };
+        case "libCall":
+        case "call":
+            return { ...e, args: e.args.map((a) => substitute(a, args)) };
+        default:
+            return e;
+    }
+}
+/** k when `value` is exactly 2^k with k in [0, 52], else null.
+ * Math.log2 rounds: 2^52 + 1 gives 52, so the power is compared back. */
+function exactPowerOfTwo(value) {
+    if (!(value >= 1))
+        return null;
+    const k = Math.round(Math.log2(value));
+    return k >= 0 && k <= 52 && 2 ** k === value ? k : null;
+}
+/** The same speculated operand written twice: a local, a literal, or a
+ * power of two of the same exponent. */
+function sameOperand(a, b) {
+    if (a.kind === "varRef")
+        return b.kind === "varRef" && a.localId === b.localId;
+    if (a.kind === "numLit")
+        return b.kind === "numLit" && Object.is(a.value, b.value);
+    return (a.kind === "libCall" &&
+        b.kind === "libCall" &&
+        a.fn === "math.pow" &&
+        b.fn === "math.pow" &&
+        powerOfTwo(a) &&
+        powerOfTwo(b) &&
+        sameOperand(a.args[1], b.args[1]));
+}
+/** `a - Math.floor(a / p) * p` (either factor order) with p a power of two
+ * and `a` a local or literal: the floor-mod of `a` by p. */
+function floorModPowerOfTwo(e) {
+    if (e.kind !== "bin" || e.op !== "-" || e.right.kind !== "bin" || e.right.op !== "*")
+        return null;
+    const { left, right } = e.right;
+    const [floor, power] = left.kind === "libCall" && left.fn === "math.floor" ? [left, right] : [right, left];
+    if (floor.kind !== "libCall" || floor.fn !== "math.floor" || floor.args.length !== 1)
+        return null;
+    const quotient = floor.args[0];
+    if (quotient.kind !== "bin" || quotient.op !== "/")
+        return null;
+    if (!powerOfTwo(power) || !sameOperand(quotient.right, power))
+        return null;
+    if (e.left.kind !== "varRef" && e.left.kind !== "numLit")
+        return null;
+    return sameOperand(quotient.left, e.left) ? { value: e.left, power } : null;
+}
+/** Whether `e` is a power of two speculation can shift by:
+ * `Math.pow(2, n)` or a literal 2^k with k in [0, 52]. */
+function powerOfTwo(e) {
+    if (e.kind === "numLit")
+        return exactPowerOfTwo(e.value) !== null;
+    return (e.kind === "libCall" &&
+        e.fn === "math.pow" &&
+        e.args.length === 2 &&
+        e.args[0].kind === "numLit" &&
+        e.args[0].value === 2);
+}
+/** Typed-array element kinds whose elements are integers. */
+const INTEGER_ELEMENTS = new Set(["u8", "u8c", "i8", "u16", "i16", "u32", "i32"]);
+/** A typed-array element read of an integer kind with no effect: an
+ * out-of-range read gives NaN, which fails its check. Float elements would
+ * only bail. */
+function isSpeculativeByteRead(e) {
+    return (e.kind === "bytesIntrinsic" &&
+        e.method === "get" &&
+        e.type.kind === "f64" &&
+        e.receiver.type.kind === "bytes" &&
+        INTEGER_ELEMENTS.has(e.receiver.type.elem) &&
+        e.args.length === 1 &&
+        isEffectFree(e.receiver) &&
+        isEffectFree(e.args[0]));
+}
+/** Whether evaluating `e` assigns no binding: no `++`/`--`, no assignment
+ * expression, and no statement inside it. */
+function writesNoLocal(e) {
+    return everyExpr(e, {
+        expr: (node) => node.kind !== "incDec" && node.kind !== "assignExpr",
+        stmt: () => false,
+    });
+}
+/** Rewrite a write's value that isSpeculableValue refuses into one it can
+ * speculate (SpeculativeValue), or null. Expansion and the new operations
+ * (`Math.pow(2, n)`, `Math.floor(a / 2^n)`, byte reads) evaluate nothing
+ * but numbers, so the fast copy may evaluate them in any order. Hoisted
+ * leaves run in the write's evaluation order before the arithmetic; that
+ * reorders nothing only when the write reads no heap and every local it
+ * reads is one no call can write. */
+export function rewriteSpeculable(value, context) {
+    const leaves = [];
+    let reads = false;
+    const locals = [];
+    const rewrite = (e, depth) => {
+        if (e.type.kind !== "f64")
+            return null;
+        switch (e.kind) {
+            case "numLit":
+                return Number.isSafeInteger(e.value) && !Object.is(e.value, -0) ? e : null;
+            case "varRef":
+                locals.push(e.localId);
+                return e;
+            case "bin": {
+                if (!ARITHMETIC_OPS.has(e.op))
+                    break;
+                const left = rewrite(e.left, depth);
+                const right = left && rewrite(e.right, depth);
+                return left && right ? { ...e, left, right } : null;
+            }
+            case "unary": {
+                if (e.op !== "-")
+                    break;
+                const operand = rewrite(e.operand, depth);
+                return operand ? { ...e, operand } : null;
+            }
+            case "libCall": {
+                if (powerOfTwo(e) && e.kind === "libCall") {
+                    const exponent = rewrite(e.args[1], depth);
+                    return exponent ? { ...e, args: [e.args[0], exponent] } : null;
+                }
+                const quotient = e.args[0];
+                if (e.fn === "math.floor" &&
+                    e.args.length === 1 &&
+                    quotient?.kind === "bin" &&
+                    quotient.op === "/" &&
+                    powerOfTwo(quotient.right)) {
+                    const left = rewrite(quotient.left, depth);
+                    const right = left && rewrite(quotient.right, depth);
+                    return left && right ? { ...e, args: [{ ...quotient, left, right }] } : null;
+                }
+                break;
+            }
+            case "call": {
+                const fn = depth < MAX_INLINE_DEPTH ? context.inlinable?.(e.callee) : undefined;
+                // Arguments are evaluated before the body: an expansion may read
+                // them in another order, or twice, only when they are pure.
+                const plain = (a) => isSpeculableValue(a, false) ||
+                    (a.kind === "unionWrap" && isSpeculableValue(a.value, false));
+                if (fn !== undefined && fn.params.length === e.args.length && e.args.every(plain)) {
+                    const args = new Map(fn.params.map((id, i) => [id, e.args[i]]));
+                    return rewrite(substitute(fn.body, args), depth + 1);
+                }
+                break;
+            }
+            default:
+                if (isSpeculativeRead(e) || isSpeculativeByteRead(e)) {
+                    reads = true;
+                    return e;
+                }
+                break;
+        }
+        // Only calls of program functions are hoisted: other leaves (a string's
+        // length, a Map read) are cheap where they stand, and would turn every
+        // loop that adds one into a second copy.
+        if (context.leafId === undefined || e.kind !== "call")
+            return null;
+        // Hoisting runs the arguments before the rest of the write: one that
+        // assigns a local would move that write ahead of the write's earlier
+        // reads of it.
+        if (!e.args.every(writesNoLocal))
+            return null;
+        const ref = { kind: "varRef", localId: context.leafId(), type: e.type, loc: e.loc };
+        leaves.push({ localId: ref.localId, expr: e, ref });
+        return ref;
+    };
+    const rewritten = rewrite(value, 0);
+    if (rewritten === null)
+        return null;
+    if (leaves.length > 0) {
+        const leafIds = new Set(leaves.map((leaf) => leaf.localId));
+        if (reads || !locals.every((id) => leafIds.has(id) || context.unaliased?.(id) === true))
+            return null;
+    }
+    return { value: rewritten, leaves };
+}
 /** The fast copy duplicates the loop; keep the duplicated code small. */
 export const MAX_LOOP_NODES = 400;
 /** Statements whose emission is plain control flow or a single write.
@@ -131,15 +416,19 @@ function isEffectFree(e) {
             return false;
     }
 }
-/** The speculative reads of a speculable value in evaluation order. */
+/** The speculative reads of a speculable value in evaluation order, those
+ * of a rewritten value (rewriteSpeculable) included. */
 export function speculativeReads(e, out = []) {
-    if (e.kind === "bin" && ARITHMETIC_OPS.has(e.op)) {
+    if (e.kind === "bin" && (ARITHMETIC_OPS.has(e.op) || e.op === "/")) {
         speculativeReads(e.left, out);
         speculativeReads(e.right, out);
     }
     else if (e.kind === "unary" && e.op === "-")
         speculativeReads(e.operand, out);
-    else if (isSpeculativeRead(e))
+    else if (e.kind === "libCall" && (e.fn === "math.floor" || e.fn === "math.pow"))
+        for (const arg of e.args)
+            speculativeReads(arg, out);
+    else if (isSpeculativeRead(e) || isSpeculativeByteRead(e))
         out.push(e);
     return out;
 }
@@ -159,6 +448,9 @@ function hasProduct(e) {
         return e.op === "*" || e.op === "%" || hasProduct(e.left) || hasProduct(e.right);
     if (e.kind === "unary")
         return hasProduct(e.operand);
+    // Math.floor(a / 2^n) and Math.pow(2, n) replace a division and a call.
+    if (e.kind === "libCall")
+        return e.fn === "math.floor" || e.fn === "math.pow";
     return false;
 }
 function hasArithmetic(e) {
@@ -166,6 +458,8 @@ function hasArithmetic(e) {
         return ARITHMETIC_OPS.has(e.op) || hasArithmetic(e.left) || hasArithmetic(e.right);
     if (e.kind === "unary")
         return e.op === "-" || hasArithmetic(e.operand);
+    if (e.kind === "libCall")
+        return e.fn === "math.floor" || e.fn === "math.pow";
     return false;
 }
 /** The written local and value of a statement-level write, or null. A
@@ -191,8 +485,10 @@ export function speculativeWriteTarget(s) {
  * expressions the static range analysis already proves integral. Static
  * proofs come first: a local whose reads are all proven is never shadowed
  * or checked, and a loop with nothing unproven is never duplicated. */
-export function planSpeculativeLoop(loop, eligible, integral = () => false, proven = () => false, invariantEligible = eligible) {
+export function planSpeculativeLoop(loop, eligible, integral = () => false, proven = () => false, invariantEligible = eligible, context = {}) {
     const writes = new Map();
+    const values = new Map();
+    const leafIds = new Set();
     const unspeculable = new Set();
     const reads = new Set();
     // Locals with at least one read the static analysis does not prove.
@@ -218,12 +514,9 @@ export function planSpeculativeLoop(loop, eligible, integral = () => false, prov
     // A product in the condition alone (`i < Math.floor(n * scale)`) does not
     // make the body's work integer.
     let inCondition = false;
-    const expr = (e) => {
-        if (rejected)
-            return false;
-        nodes++;
-        if (!OBSERVER_FREE_EXPRESSIONS.has(e.kind) || (e.kind === "bin" && e.left.type.kind !== "f64"))
-            observerFree = false;
+    // What the integer writes read and consume. A rewritten value is noted
+    // here alone: its original, which `expr` walks, has its effects.
+    const note = (e) => {
         if (e.kind === "varRef") {
             reads.add(e.localId);
             if (!proven(e))
@@ -243,6 +536,21 @@ export function planSpeculativeLoop(loop, eligible, integral = () => false, prov
             consume(e.index);
         else if (e.kind === "bytesIntrinsic" || e.kind === "strIntrinsic")
             e.args.forEach(consume);
+    };
+    // An expanded call is emitted in the fast copy: it counts toward the
+    // duplicated code.
+    const noteAll = (e) => {
+        nodes++;
+        note(e);
+        return everyExprChild(e, noteAll, () => true);
+    };
+    const expr = (e) => {
+        if (rejected)
+            return false;
+        nodes++;
+        if (!OBSERVER_FREE_EXPRESSIONS.has(e.kind) || (e.kind === "bin" && e.left.type.kind !== "f64"))
+            observerFree = false;
+        note(e);
         return everyExprChild(e, expr, nested);
     };
     // Statements inside expressions (sequence expressions) run mid-expression,
@@ -271,7 +579,10 @@ export function planSpeculativeLoop(loop, eligible, integral = () => false, prov
             consume(s.index);
         const target = speculativeWriteTarget(s);
         if (target) {
-            if (target.value === null || isSpeculableValue(target.value)) {
+            const rewritten = target.value === null || isSpeculableValue(target.value)
+                ? null
+                : rewriteSpeculable(target.value, context);
+            if (target.value === null || isSpeculableValue(target.value) || rewritten !== null) {
                 const list = writes.get(target.localId) ?? [];
                 list.push(s);
                 writes.set(target.localId, list);
@@ -282,6 +593,12 @@ export function planSpeculativeLoop(loop, eligible, integral = () => false, prov
                 }
                 else
                     expr(target.value);
+                if (rewritten !== null) {
+                    values.set(s, rewritten);
+                    for (const leaf of rewritten.leaves)
+                        leafIds.add(leaf.localId);
+                    noteAll(rewritten.value);
+                }
                 return !rejected;
             }
             unspeculable.add(target.localId);
@@ -310,15 +627,17 @@ export function planSpeculativeLoop(loop, eligible, integral = () => false, prov
     // write runs: speculated itself, already an integer, or loop-invariant
     // (checked on entry). A value computed from doubles the loop writes
     // would only fail its check on every entry.
+    const valueOf = (s) => values.get(s)?.value ?? speculativeWriteTarget(s).value;
     const grounded = (e) => {
         if (e.kind === "varRef") {
             const id = e.localId;
-            return (proven(e) ||
+            return (leafIds.has(id) ||
+                proven(e) ||
                 locals.has(id) ||
                 integral(id) ||
                 (!writes.has(id) && !unspeculable.has(id) && invariantEligible(id)));
         }
-        if (isSpeculativeRead(e))
+        if (isSpeculativeRead(e) || isSpeculativeByteRead(e))
             return true;
         return everyExprChild(e, grounded, () => false);
     };
@@ -326,8 +645,8 @@ export function planSpeculativeLoop(loop, eligible, integral = () => false, prov
         changed = false;
         for (const id of [...locals.keys()]) {
             for (const s of writes.get(id)) {
-                const target = speculativeWriteTarget(s);
-                if (target.value !== null && !grounded(target.value)) {
+                const value = valueOf(s);
+                if (value !== null && !grounded(value)) {
                     locals.delete(id);
                     changed = true;
                     break;
@@ -346,7 +665,8 @@ export function planSpeculativeLoop(loop, eligible, integral = () => false, prov
     const invariant = (e) => {
         if (e.kind === "varRef") {
             const id = e.localId;
-            if (!proven(e) &&
+            if (!leafIds.has(id) &&
+                !proven(e) &&
                 !locals.has(id) &&
                 !writes.has(id) &&
                 !unspeculable.has(id) &&
@@ -357,13 +677,13 @@ export function planSpeculativeLoop(loop, eligible, integral = () => false, prov
         return everyExprChild(e, invariant, () => true);
     };
     for (const s of speculated) {
-        const target = speculativeWriteTarget(s);
-        if (target.value === null)
+        const value = valueOf(s);
+        if (value === null)
             arithmetic = true;
         else {
-            if (hasArithmetic(target.value))
+            if (hasArithmetic(value))
                 arithmetic = true;
-            invariant(target.value);
+            invariant(value);
         }
     }
     if (!arithmetic)
@@ -373,12 +693,15 @@ export function planSpeculativeLoop(loop, eligible, integral = () => false, prov
     const heavy = [...locals.keys()].some((id) => multiplied.has(id)) ||
         [...speculated].some((s) => {
             const target = speculativeWriteTarget(s);
-            return (target.value !== null &&
-                (hasProduct(target.value) || isVariableStep(target.localId, target.value)));
+            const value = valueOf(s);
+            return value !== null && (hasProduct(value) || isVariableStep(target.localId, value));
         });
     if (!heavy)
         return null;
-    return { locals, writes: speculated, observerFree };
+    for (const s of values.keys())
+        if (!speculated.has(s))
+            values.delete(s);
+    return { locals, writes: speculated, observerFree, values };
 }
 /** Plan a proven integer loop. `cursors` are the loop's bounded bindings,
  * `eligible` the locals a shadow may stand for, `integral` those the emitter
@@ -568,6 +891,33 @@ export function emitSpeculativeInteger(host, e, bail, reads = new Map(), integra
         case "bin": {
             if (e.op !== "+" && e.op !== "-" && e.op !== "*" && e.op !== "%")
                 break;
+            // The floor-mod of a safe integer by 2^n (n in [0, 52]) is its low n
+            // bits, also for a negative value: in [0, 2^n), and never -0.
+            const mod = floorModPowerOfTwo(e);
+            if (mod) {
+                const value = emitSpeculativeInteger(host, mod.value, bail, reads, integral);
+                const n = exponentOf(host, mod.power, bail, reads, integral);
+                const mask = B.tmp(), low = B.tmp();
+                B.line(`${mask} = sub i64 ${shiftOne(host, n)}, 1`);
+                B.line(`${low} = and i64 ${value}, ${mask}`);
+                return low;
+            }
+            // A product with 2^n shifts: it is safe iff the other factor's
+            // magnitude is at most (2^53 - 1) >> n, and a zero product of a safe
+            // integer and a positive power is +0.
+            if (e.op === "*" && (powerOfTwo(e.right) || powerOfTwo(e.left))) {
+                const [factor, power] = powerOfTwo(e.right) ? [e.left, e.right] : [e.right, e.left];
+                const value = emitSpeculativeInteger(host, factor, bail, reads, integral);
+                const n = exponentOf(host, power, bail, reads, integral);
+                const limit = B.tmp(), magnitude = B.tmp(), outside = B.tmp(), product = B.tmp();
+                B.line(`${limit} = ashr i64 ${SAFE}, ${n}`);
+                host.declare("declare i64 @llvm.abs.i64(i64, i1)");
+                B.line(`${magnitude} = call i64 @llvm.abs.i64(i64 ${value}, i1 true)`);
+                B.line(`${outside} = icmp ugt i64 ${magnitude}, ${limit}`);
+                bail(outside);
+                B.line(`${product} = shl nsw i64 ${value}, ${n}`);
+                return product;
+            }
             const a = emitSpeculativeInteger(host, e.left, bail, reads, integral);
             const b = emitSpeculativeInteger(host, e.right, bail, reads, integral);
             const result = B.tmp();
@@ -619,6 +969,21 @@ export function emitSpeculativeInteger(host, e, bail, reads = new Map(), integra
             bail(negativeZero);
             return result;
         }
+        case "libCall": {
+            // A rewritten value's Math.pow(2, n) and Math.floor(a / 2^n)
+            // (rewriteSpeculable): with n an integer in [0, 52], 2^n is exact and
+            // so is a / 2^n for a safe integer a, whose floor the arithmetic shift
+            // computes, also for negative a. No result is -0.
+            if (e.fn === "math.pow")
+                return shiftOne(host, exponentOf(host, e, bail, reads, integral));
+            if (e.fn !== "math.floor" || e.args[0]?.kind !== "bin")
+                break;
+            const a = emitSpeculativeInteger(host, e.args[0].left, bail, reads, integral);
+            const n = exponentOf(host, e.args[0].right, bail, reads, integral);
+            const result = B.tmp();
+            B.line(`${result} = ashr i64 ${a}, ${n}`);
+            return result;
+        }
         case "unary": {
             if (e.op !== "-")
                 break;
@@ -635,6 +1000,28 @@ export function emitSpeculativeInteger(host, e, bail, reads = new Map(), integra
     }
     return speculativeLeaf(host, reads.get(e) ?? host.emitExpr(e), e, bail);
 }
+/** The exponent of a power of two (Math.pow(2, n) or a literal 2^k) as an
+ * i64 in [0, 52]; other exponents bail. */
+function exponentOf(host, e, bail, reads, integral) {
+    if (e.kind === "numLit") {
+        const k = exactPowerOfTwo(e.value);
+        if (k === null)
+            throw new InternalCompilerError("llvm emitter bug: speculative power of two");
+        return String(k);
+    }
+    if (e.kind !== "libCall")
+        throw new InternalCompilerError("llvm emitter bug: speculative power of two");
+    const n = emitSpeculativeInteger(host, e.args[1], bail, reads, integral);
+    const outside = host.B.tmp();
+    host.B.line(`${outside} = icmp ugt i64 ${n}, 52`);
+    bail(outside);
+    return n;
+}
+function shiftOne(host, n) {
+    const result = host.B.tmp();
+    host.B.line(`${result} = shl i64 1, ${n}`);
+    return result;
+}
 /** The safe i64 of an evaluated number: its proven integer, or a checked
  * conversion. */
 function speculativeLeaf(host, value, e, bail) {