@asmlift/core 0.8.1 → 0.10.0

package/src/ir/alias.ts

@@ -86,6 +86,35 @@ export function globalCellOf(defs: Map<Value, Op>, addr: Value, off: number): Gl
   return null;
 }
 
+/**
+ * The named global an address value is DERIVED FROM, through defs alone — `gaddr`, an `add` where
+ * exactly one side reaches a name, and the LEFT side of a `sub`, whose right side is a distance and
+ * never a second object. Where {@link globalCellOf} asks which CELL an
+ * address denotes and answers null the moment a runtime term enters, this asks only which OBJECT
+ * it reaches, which a runtime index does not change: `gVolArr[i]` names no cell and one object.
+ *
+ * So it answers a DECLARATION question — volatile, const, the qualifiers that hold for every byte
+ * of the object — and never an aliasing one: two accesses this gives the same name are not thereby
+ * the same cell. Null when nothing reaches a name, and when two sides do (a sum of two `gaddr`s is
+ * a base the defs cannot tell apart); null is UNKNOWN rather than "no global", so a caller that
+ * refuses on a declared property must read it as "the map cannot say".
+ */
+export function globalBaseOf(defs: Map<Value, Op>, addr: Value): string | null {
+  const d = defs.get(addr);
+  if (d?.opcode === 'gaddr') {
+    return d.attrs.sym as string;
+  }
+  if (d?.opcode === 'add' && d.operands.length === 2) {
+    const a = globalBaseOf(defs, d.operands[0]);
+    const b = globalBaseOf(defs, d.operands[1]);
+    return a !== null && b !== null ? null : (a ?? b);
+  }
+  if (d?.opcode === 'sub' && d.operands.length === 2) {
+    return globalBaseOf(defs, d.operands[0]);
+  }
+  return null;
+}
+
 /**
  * The NUMERIC address an access denotes, resolved through defs alone — a literal base, or the sum
  * of two literals — plus the access's own `off`. Null when the address
@@ -110,6 +139,48 @@ export function constAddressOf(defs: Map<Value, Op>, addr: Value, off: number):
   return null;
 }
 
+/**
+ * A constant DISPLACEMENT off a root, read through defs alone: `add(p, K)`, `add(K, p)`, `sub(p, K)`,
+ * or a chain of them, as the root `p`, the summed `K`, and the chain's values from `addr` toward
+ * `p`. Null when `addr` is not such a link. `sub` is not commutative, so `K - p` stops the walk; a
+ * link whose two operands are both constants stops it too (that is a literal address,
+ * {@link constAddressOf}'s question). The one reading of address arithmetic that raise/structs.ts
+ * (which accesses share a base) and raise/offsetnames.ts (which named global an address stands on)
+ * both ask, so the two cannot disagree about where a chain ends.
+ */
+export function constDisplacementOf(
+  defs: Map<Value, Op>,
+  addr: Value,
+): { root: Value; k: number; chain: Value[] } | null {
+  const constOf = (x: Value): number | null => {
+    const d = defs.get(x);
+    return d?.opcode === 'const' && typeof d.attrs.value === 'number' ? d.attrs.value : null;
+  };
+  let k = 0;
+  const chain: Value[] = [];
+  let cur = addr;
+  for (;;) {
+    const d = defs.get(cur);
+    if (!d || (d.opcode !== 'add' && d.opcode !== 'sub') || d.operands.length !== 2) {
+      break;
+    }
+    const [x, y] = d.operands;
+    const ky = constOf(y);
+    const kx = d.opcode === 'add' ? constOf(x) : null;
+    if (ky !== null && kx === null) {
+      k += d.opcode === 'add' ? ky : -ky;
+      cur = x;
+    } else if (kx !== null && ky === null) {
+      k += kx;
+      cur = y;
+    } else {
+      break;
+    }
+    chain.push(d.results[0]);
+  }
+  return chain.length === 0 ? null : { root: cur, k, chain };
+}
+
 /**
  * Are these two accesses through ONE base provably different byte cells — same base value, both at
  * a constant offset and width, ranges non-overlapping? The everyday struct interleave