@asmlift/core 0.5.0 → 0.6.0

package/src/ir/verify.ts

@@ -3,7 +3,9 @@
 //   1. every block ends in exactly one terminator (and it is the last op)
 //   2. operands well-formed: opcode registered, correct arity/attrs
 //   3. SSA: each value defined once; every use is defined; def dominates use
-import { Block, Fn, Value, predecessors } from './core';
+//   4. side data: a fn that carries a write-order record carries one for EVERY block, with every
+//      ordinal inside that block's own write count (ir/core.ts `WriteOrder`)
+import { Block, Fn, Value, dominators } from './core';
 import { opSig } from './opcodes';
 
 export class VerifyError extends Error {}
@@ -133,42 +135,8 @@ export function verify(fn: Fn): void {
     );
   }
 
-  // --- dominance (iterative dominators over the CFG) ---
-  const entry = fn.blocks[0];
-  const preds = predecessors(fn);
-  const dom = new Map<Block, Set<Block>>();
-  const allBlocks = new Set(fn.blocks);
-  for (const b of fn.blocks) {
-    dom.set(b, b === entry ? new Set([entry]) : new Set(allBlocks));
-  }
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const b of fn.blocks) {
-      if (b === entry) {
-        continue;
-      }
-      let inter: Set<Block> | null = null;
-      for (const p of preds.get(b)!) {
-        const dp = dom.get(p)!;
-        if (inter === null) {
-          inter = new Set(dp);
-          continue;
-        }
-        for (const x of inter) {
-          if (!dp.has(x)) {
-            inter.delete(x);
-          }
-        } // intersect in place (spec-safe delete-in-iter)
-      }
-      const next = new Set<Block>(inter ?? []);
-      next.add(b);
-      if (!setEq(next, dom.get(b)!)) {
-        dom.set(b, next);
-        changed = true;
-      }
-    }
-  }
+  // --- dominance: def must dominate every use (ir/core.ts owns the analysis) ---
+  const dom = dominators(fn);
   const dominates = (a: Block, b: Block) => dom.get(b)!.has(a);
 
   for (const b of fn.blocks) {
@@ -193,6 +161,44 @@ export function verify(fn: Fn): void {
       ),
     );
   }
+
+  checkWriteOrder(fn);
+}
+
+/** THE WRITE-ORDER RECORD'S CROSS-PASS OBLIGATION, checked rather than trusted (ir/core.ts
+ *  `WriteOrder`, `foldWriteOrder`), because the consequence of missing it is silent: an unmeasured
+ *  block's edge copies sort with no records at all, changing the order the structurer emits them in
+ *  and, on a cycle, which register it spills. No decline, no marker.
+ *
+ *  WHAT IT CATCHES: a pass that MINTS a block into a measured fn, or drops a block's entry, leaving
+ *  a hole indistinguishable from a fn nobody measured. Also an ordinal outside its block's own
+ *  write count — a `foldWriteOrder` that moved records without growing the count. WHAT IT CANNOT:
+ *  ops moved from one MEASURED block into another with the fold forgotten, since both blocks still
+ *  have entries and no snapshot of the IR shows the move. That half stays a review obligation until
+ *  the record hangs on `Successor` itself.
+ *
+ *  A fn is "measured" iff it has any entry at all; one with none is parsed or hand-built IR, whose
+ *  edges take the def-position proxy by design. */
+function checkWriteOrder(fn: Fn): void {
+  const order = fn.writeOrder;
+  if (order === undefined || order.writes.size === 0) {
+    return;
+  }
+  for (const b of fn.blocks) {
+    const writes = order.writes.get(b);
+    if (writes === undefined) {
+      throw new VerifyError(
+        `fn '${fn.name}': block ^bb${fn.blocks.indexOf(b)} carries no write-order entry, but the fn is measured`,
+      );
+    }
+    for (const at of order.lastWrite.get(b)?.values() ?? []) {
+      if (at < 0 || at >= writes) {
+        throw new VerifyError(
+          `fn '${fn.name}': write-order ordinal ${at} on block ^bb${fn.blocks.indexOf(b)} is outside its ${writes} writes`,
+        );
+      }
+    }
+  }
 }
 
 /** Run a check body; a VerifyError it throws is re-thrown with the op's location appended —
@@ -207,15 +213,3 @@ function locate(body: () => void, where: () => string): void {
     throw e;
   }
 }
-
-function setEq(a: Set<Block>, b: Set<Block>): boolean {
-  if (a.size !== b.size) {
-    return false;
-  }
-  for (const x of a) {
-    if (!b.has(x)) {
-      return false;
-    }
-  }
-  return true;
-}

package/src/l3/address.ts

@@ -0,0 +1,62 @@
+// asmlift — THE THREE READINGS OF A CONSTANT ADDRESS, in one place because they are three and not
+// one, and because the same four lines had been re-typed into five files at three strengths.
+//
+// A raw address reaches L3 as a cast chain over a `const`, and "which numeric cell is this" has
+// three different right answers depending on what the caller intends to DO with the answer. The
+// readings are deliberately not merged; what this module supplies is names for them, so a pass
+// declares which one it means instead of restating four lines and drifting.
+//
+//   • baseConst   — a deref BASE, through SCALAR pointer casts only. A cast to a STRUCT pointer is
+//     the dot-form's base and is refused, because a lever that re-spells THROUGH it collapses the
+//     stride (`((struct S *)K)[i].f` is not `((u8 *)K)[…]`). This is the reading a lever that
+//     REWRITES the base needs: l3/nearbase.ts's clusters, l3/volstore.ts's qualifier.
+//   • addrConst   — the address an expression IS, through ANY pointer cast. Wider, and safe
+//     because nothing re-spells through it: l3/volatileptr.ts counts volatility claims with it.
+//   • rootConst   — the constant an ACCESS CHAIN is rooted at, through any cast and any number of
+//     subscripts and field selections. Wide enough to place an object whose element is not known,
+//     which is what a read with a runtime subscript needs (l3/unreduce.ts's aliasing gate).
+//
+// And `cellAddress`, which is not a fourth reading of a base but the WHOLE address an `index`
+// denotes — base plus subscript × width — or null when any part of it is not constant.
+//
+// A CAUTION THE HISTORY EARNED: `rootConst` and `cellAddress` disagree, and a predicate that uses
+// one on its write side and the other on its read side is not the same predicate on both. A read
+// rooted at 0x03FFFFF0 whose element is `[8]` denotes 0x04000010 — a device register the root
+// reports as EWRAM. Ask for both where both can be had.
+import type { Expr } from './ast';
+
+/** the numeric address behind a deref base, through SCALAR pointer casts only */
+export const baseConst = (e: Expr): number | null =>
+  e.k === 'const'
+    ? e.value
+    : e.k === 'cast' && !(e.to.kind === 'ptr' && e.to.to.kind === 'struct')
+      ? baseConst(e.e)
+      : null;
+
+/** the numeric address an expression IS, through any number of pointer casts */
+export const addrConst = (e: Expr): number | null =>
+  e.k === 'const' ? e.value : e.k === 'cast' && e.to.kind === 'ptr' ? addrConst(e.e) : null;
+
+/** the constant an ACCESS CHAIN is rooted at, through any cast, subscript and field selection */
+export const rootConst = (e: Expr): number | null =>
+  e.k === 'const'
+    ? e.value
+    : e.k === 'cast'
+      ? rootConst(e.e)
+      : e.k === 'index' || e.k === 'field'
+        ? rootConst(e.base)
+        : null;
+
+/** The WHOLE address an `index` access denotes, or null when any part of it is not constant. A
+ *  `field` never resolves here: its offset is the struct's, which this module has no layout for. */
+export function cellAddress(e: Expr): number | null {
+  if (e.k !== 'index' || e.lead !== undefined || e.idx.k !== 'const') {
+    return null; // a `lead` is a multidimensional global's leading dimension, not a numeric address
+  }
+  const base = baseConst(e.base);
+  return base === null ? null : base + e.idx.value * e.width;
+}
+
+/** is `a` inside the half-open range `w`? A null address, or no declared range, is never inside. */
+export const inRange = (a: number | null, w?: readonly [number, number]): boolean =>
+  w !== undefined && a !== null && a >= w[0] && a < w[1];

package/src/l3/argbase.ts

@@ -41,6 +41,7 @@ import { type IrType, T, scalarTypeForAccess } from '../ir/types';
 import type { Expr, SFn, Stmt } from './ast';
 import { mapExprChildren, stmtExprs } from './ast';
 import { nameAllocator } from './hoist';
+import { declaredGlobals } from './storage';
 
 /** A base this pass may evaluate early: pure, and not something a store can change under us.
  *
@@ -103,7 +104,7 @@ function baseKey(n: Extract<Expr, { k: 'index' }>): string {
  * candidate at all rather than a duplicate of the primary).
  */
 export function materializeArgBases(sfn: SFn): SFn | null {
-  const globals = new Set((sfn.globals ?? []).map((g) => g.name));
+  const globals = declaredGlobals(sfn);
   const fresh = nameAllocator(sfn);
   const newLocals: { name: string; type: IrType }[] = [];
   let fired = false;