@asmlift/core 0.9.0 → 0.10.0

package/src/structure/hazards.ts

@@ -4,9 +4,9 @@
 //   • may this loop's updates be emitted before its condition/exit/post-loop reads, or would some
 //     read then see a clobbered (post-update) value that the original IR read PRE-update — and
 //     which of those reads can be REPAIRED by moving the copy into the body (`sinkable…`);
-//   • is a value the emitted form DROPS redundant — `sameAtEntry`, which reads an expression on
-//     the loop's entry state so a guard about to be fused away can be checked against the test
-//     that replaces it.
+//   • is a value the emitted form DROPS redundant — `sameAtEntry` (ir/entry.ts, shared with the
+//     raise re-roll), which reads an expression on the loop's entry state so a guard about to be
+//     fused away can be checked against the test that replaces it.
 //
 // WHAT MAKES A SUNK COPY LEGAL. The exit edge's value is not moved, it is REBUILT: the copy spells
 // the arg's def-tree again inside the body, at the point that tree was already computed at
@@ -50,7 +50,7 @@
 // exist at CALL time (emission runs after naming completes). Snapshotting them would break this.
 import { Block, Op, Value, successorsOf } from '../ir/core';
 import { effectful, orderSensitive, reevalUnsafe } from '../ir/discipline';
-import { NEGATED_ICMP } from '../ir/opcodes';
+import { sameAtEntry } from '../ir/entry';
 import { Expr, Stmt } from '../l3/ast';
 import { type Gate, firstRejection } from '../l3/gates';
 import type { UseSite } from './analysis';
@@ -120,7 +120,15 @@ export interface LoopHazards {
     gates?: readonly Gate<SinkCandidate>[],
     staleOnZeroTrip?: (slot: number) => boolean,
   ): Map<number, Op | null>;
-  sameAtEntry(a: Value, b: Value, entry: Map<Value, Value>, negated?: boolean): boolean;
+  /** `through`: the values whose defining op may be read through (ir/entry.ts `EntryReading`);
+   *  every value when absent. */
+  sameAtEntry(
+    a: Value,
+    b: Value,
+    entry: Map<Value, Value>,
+    negated?: boolean,
+    through?: (v: Value) => boolean,
+  ): boolean;
   loopWriteSet(updates: Stmt[], bodyBlocks: Iterable<Block>, header: Block): Set<string>;
   loopWriteSetAhead(ahead: Iterable<Block>, incoming: (b: Block) => Value[][], header: Block): Set<string>;
 }
@@ -324,7 +332,7 @@ interface Reach {
 const ALWAYS: Reach = { onTrue: true, onFalse: true };
 
 /** The reach each operand of a SHORT-CIRCUIT op inherits. These two are the whole set: they are the
- *  ops `ARITH_TO_BIN` (structure.ts) renders as `&&`/`||` — a test holds the two lists together,
+ *  ops `ARITH_TO_BIN` (arith-ops.ts) renders as `&&`/`||` — a test holds the two lists together,
  *  since a connective missing from here is read as an ordinary op and its arms inherit a reach they
  *  do not have — and `Expr` has no conditional form besides them, no ternary, so every other op
  *  evaluates all of its operands whenever it is itself evaluated and they inherit its reach
@@ -363,63 +371,6 @@ function unitStep(value: Expr, name: string): 1 | -1 | null {
   return k === null ? null : ((value.op === '-' ? -k : k) as 1 | -1);
 }
 
-// `x + 0` / `x - 0` / `x | 0` are `x`. Substituting a loop variable by its init constant turns
-// ordinary index arithmetic into exactly these, and a guard that spells the same value without
-// the arithmetic would otherwise compare unequal.
-function fold(defs: Map<Value, Op>, v: Value): Value {
-  const d = defs.get(v);
-  if (!d || d.operands.length !== 2 || !['add', 'sub', 'or'].includes(d.opcode)) {
-    return v;
-  }
-  const z = defs.get(d.operands[1]);
-  return z?.opcode === 'const' && z.attrs?.value === 0 ? fold(defs, d.operands[0]) : v;
-}
-
-// Does `a`, read on a loop's ENTRY values, denote the same thing as `b`? `entry` maps each header
-// param and back-edge arg to the arg the forward edge passes, so substituting through it models
-// the FIRST iteration — the state a guard in front of the loop tested. `negated` compares against
-// b's logical opposite instead, for the usual case where a guard spells the loop's own test the
-// other way round (`beq` to the exit vs `bne` to the header).
-//
-// Structural, not semantic: distinct ops with the same opcode, attributes and operands compare
-// equal (two `const 0`s do), anything else does not. A false negative costs a loud decline, which
-// is the direction to be wrong in. Memoised like `readsClobbered`'s `seen`: a value its own
-// consumer reads twice would otherwise double the work at every level.
-function sameAtEntry(defs: Map<Value, Op>, a: Value, b: Value, entry: Map<Value, Value>, negated = false): boolean {
-  const memo = new Map<Value, Map<Value, boolean>>();
-  const sameOp = (da: Op, db: Op, opcodeOk: boolean): boolean =>
-    opcodeOk &&
-    da.operands.length === db.operands.length &&
-    JSON.stringify(da.attrs ?? null) === JSON.stringify(db.attrs ?? null) &&
-    da.operands.every((o, i) => same(o, db.operands[i]));
-  const same = (x0: Value, y0: Value): boolean => {
-    const x = fold(defs, entry.get(x0) ?? x0);
-    const y = fold(defs, y0);
-    if (x === y) {
-      return true;
-    }
-    let row = memo.get(x);
-    if (!row) {
-      memo.set(x, (row = new Map()));
-    }
-    const hit = row.get(y);
-    if (hit !== undefined) {
-      return hit;
-    }
-    const da = defs.get(x);
-    const db = defs.get(y);
-    const r = !!da && !!db && sameOp(da, db, da.opcode === db.opcode);
-    row.set(y, r);
-    return r;
-  };
-  if (!negated) {
-    return same(a, b);
-  }
-  const da = defs.get(fold(defs, entry.get(a) ?? a));
-  const db = defs.get(fold(defs, b));
-  return !!da && !!db && sameOp(da, db, NEGATED_ICMP[da.opcode] === db.opcode);
-}
-
 // WHERE A SUNK COPY IS REBUILT. The copy is not carried into the body, it is SPELLED AGAIN
 // there, so the point it belongs at is the one its value was computed at: the arg's own defining
 // op, when that op is one of `latch`'s — the block whose statements both loop emitters render
@@ -1068,7 +1019,8 @@ export function makeLoopHazards(deps: LoopHazardDeps): LoopHazards {
     testSkipsAnEffect,
     preUpdateCondFold,
     sinkablePreUpdateSlots,
-    sameAtEntry: (a, b, entry, negated = false) => sameAtEntry(defs, a, b, entry, negated),
+    sameAtEntry: (a, b, entry, negated = false, through = undefined) =>
+      sameAtEntry(defs, a, b, through ? { entry, through } : { entry }, negated),
     loopWriteSet,
     loopWriteSetAhead,
   };

package/src/structure/local-statics.ts

@@ -29,20 +29,38 @@
 // source's (`tide`) in one step, `nameLocalStatics`, which is where a clash between that name and
 // anything else the function names can first be seen whole.
 //
+// An element the target RELOCATES holds an address — a table of function pointers, of data
+// pointers, of `&arr[k]` — and is spelled as the address constant it is, `(u32)&sym` or
+// `(u32)((u8 *)&sym + k)`, in the integer element the rest of this typing picks: such an element
+// compiles to the same word and the same relocation as the pointer-typed source (agbcc and mwcc,
+// compiled), so the definition needs no pointer type to put the bytes where the target has them.
+//
 // REFUSES, naming the static, when the target's compiler declares no layout rules, when nothing
 // in the definition settles the width and the accesses disagree on it, when the width is no
 // integer type's or does not divide the size, when the loads disagree on the signedness, when the
 // definition is aligned narrower than its declaration here would be, when a bss static sits where
 // only a scalar initialized to zero is sure to land and it is no scalar (or the input does not
-// show where it sits);
+// show where it sits), when an element holding an address — a static's or the compiler's
+// anonymous image's — is no pointer's width;
 // and, at the rename, when two statics share a source name (one block cannot declare both) or
 // when the function names anything else by it — a global, a callee, a parameter, a local, itself —
-// which the block-scope static would hide.
-import { type Fn, type LocalObject, type LocalObjects, type Op, type Value, defOpMap } from '../ir/core';
+// which the block-scope static would hide — and when a global an initializer holds the address of
+// is hidden there by a static, parameter or local of its name.
+import {
+  type Fn,
+  LOCAL_OBJECT_ADDRESS_BYTES,
+  type LocalObject,
+  type LocalObjects,
+  type Op,
+  type Value,
+  defOpMap,
+} from '../ir/core';
 import { type IrType, T } from '../ir/types';
 import {
   type Expr,
+  type InitAddress,
   type SFn,
+  type SImage,
   type SStatic,
   type Stmt,
   mapExprChildren,
@@ -123,6 +141,8 @@ function zeroInitialized(
 export interface LocalStaticShapes {
   infos: Map<string, SymbolInfo>;
   statics: SStatic[];
+  /** the compiler's anonymous constant images, which no declaration spells (l3/constinit.ts) */
+  images: SImage[];
 }
 
 /** One access through a static's address: the width it reads or writes, and a load's extension. */
@@ -206,8 +226,11 @@ function elements(obj: LocalObject, width: number, signed: boolean): number[] {
 }
 
 /** The width of `obj`'s element: the one its definition's directives write, else the one every
- *  access agrees on; with no access either, the whole object where it is aligned below the
- *  compiler's aggregate floor, as only a scalar is, and a byte where it is not. */
+ *  access agrees on; with no access either, a pointer's where the target relocates a word of it (an
+ *  address table only handed to a callee, on a compiler that writes no directives: mwcc), else the
+ *  whole object where it is aligned below the compiler's aggregate floor, as only a scalar is, and
+ *  a byte where it is not. A relocation the pointer width does not seat is still refused, by the
+ *  caller's check of every relocation's offset. */
 function elementWidth(
   obj: LocalObject,
   accesses: readonly Access[],
@@ -220,9 +243,15 @@ function elementWidth(
   if (widths.length > 1) {
     return { refused: `whose accesses disagree on its element width (${widths.sort().join(' and ')} bytes)` };
   }
+  if (widths.length === 1) {
+    return widths[0];
+  }
+  if ((obj.relocs?.length ?? 0) > 0 && obj.size % LOCAL_OBJECT_ADDRESS_BYTES === 0) {
+    return LOCAL_OBJECT_ADDRESS_BYTES;
+  }
   const shown = obj.directives?.align ?? obj.placement?.align;
   const scalarOnly = shown !== undefined && shown < layout.aggregateAlign;
-  return widths[0] ?? (scalarOnly && [1, 2, 4].includes(obj.size) ? obj.size : 1);
+  return scalarOnly && [1, 2, 4].includes(obj.size) ? obj.size : 1;
 }
 
 /** The shape and definition of every static `fn` defines, or the refusal: the static's linker name
@@ -234,8 +263,9 @@ export function localStaticShapes(
   const objs = fn.localObjects;
   const infos = new Map<string, SymbolInfo>();
   const statics: SStatic[] = [];
+  const images: SImage[] = [];
   if (objs === undefined) {
-    return { infos, statics };
+    return { infos, statics, images };
   }
   if (layout === undefined) {
     const [first] = objs.keys();
@@ -262,6 +292,75 @@ export function localStaticShapes(
   // it places in the order it first uses them: the candidate's code decides that, no declaration.
   for (const obj of [...objs.values()].sort((a, b) => a.order - b.order)) {
     const say = (why: string) => ({ symbol: obj.symbol, refused: why });
+    if (obj.anonymous) {
+      // The compiler's own image of a local aggregate's initializer: typed by its directives alone,
+      // since nothing but the copy reads it, and never declared where it sits — l3/constinit.ts
+      // folds it into the local the copy fills, which is the declaration that placed it.
+      const unit = obj.directives?.unit;
+      if (unit === undefined || obj.bytes === undefined) {
+        return say('whose image writes no one element width — a struct, or padding alone');
+      }
+      if (![1, 2, 4].includes(unit) || obj.size % unit !== 0) {
+        return say(`whose ${unit}-byte elements are no integer array of its ${obj.size} bytes`);
+      }
+      const signed = obj.directives!.negative;
+      const count = obj.size / unit;
+      infos.set(obj.symbol, {
+        name: obj.symbol,
+        kind: 'data',
+        size: obj.size,
+        shape: 'array',
+        elemSize: unit,
+        elemSigned: signed,
+        dims: [count],
+        const: true,
+      });
+      // Only the elements the source spelled: an element it left out is a hole, and the holes after
+      // the last value are dropped. Spelled out as zeros, the initializer is a different one to the
+      // compiler, which clears and stores where most of one is zero rather than copy an image
+      // (expr.c `mostly_zeros_p`) — so the printer spells the element after a hole by designator,
+      // where the compiler parses one (`SFn.designators`).
+      const init: (number | InitAddress | null)[] = elements(obj, unit, signed);
+      for (const [from, n] of obj.directives!.gaps ?? []) {
+        if (from % unit !== 0 || n % unit !== 0) {
+          return say(`whose padding at byte ${from} does not fall on its ${unit}-byte elements`);
+        }
+        init.fill(null, from / unit, (from + n) / unit);
+      }
+      // An element the image relocates holds an address, as a static's does — an array of pointers
+      // (agbcc copies one with memcpy from 16 words, compiled).
+      for (const r of obj.relocs ?? []) {
+        if (unit !== LOCAL_OBJECT_ADDRESS_BYTES || r.offset % unit !== 0) {
+          return say(
+            `whose image holds the address '${r.symbol}', which its ${unit}-byte elements cannot — ` +
+              `an address is ${LOCAL_OBJECT_ADDRESS_BYTES}`,
+          );
+        }
+        init[r.offset / unit] = { symbol: r.symbol, addend: r.addend };
+      }
+      // A string literal's image is placed at the compiler's string alignment, which a brace list of
+      // strings is not (agbcc: `.align 2, 0` ahead of a STRING_CST's label, none ahead of
+      // `{"abcde"}`'s) — the same bytes, but spelled as a literal the image moves to a stricter
+      // alignment and shifts the unit's `.rodata`. Nor has it a padding run: one shorter than its
+      // array is copied at the literal's length and the tail cleared (`char a[16] = "abc…hijklm"` is
+      // memcpy 15 + memset 1), so a `.space` after the `.ascii` is a brace list's image copied whole.
+      // So the test is asked before the trailing holes are dropped, not after.
+      const string =
+        obj.directives!.string === true &&
+        unit === 1 &&
+        obj.directives!.align >= layout.stringAlign &&
+        !init.includes(null);
+      while (init.length > 0 && init[init.length - 1] === null) {
+        init.pop();
+      }
+      images.push({
+        name: obj.symbol,
+        type: T.array(T.int(unit * 8, signed), count),
+        init,
+        ...(string ? { string: true as const } : {}),
+      });
+      continue;
+    }
     const accesses = access.get(obj.symbol) ?? [];
     const dir = obj.directives;
     // the alignment the target shows
@@ -284,7 +383,22 @@ export function localStaticShapes(
     const signed = signs.size > 0 ? signs.has(true) : dir?.negative === true;
     const count = obj.size / width;
     const elem = T.int(width * 8, signed);
-    const init = zeroed.has(obj.symbol) ? [0] : obj.bytes === undefined ? undefined : elements(obj, width, signed);
+    const init: (number | InitAddress)[] | undefined = zeroed.has(obj.symbol)
+      ? [0]
+      : obj.bytes === undefined
+        ? undefined
+        : elements(obj, width, signed);
+    // An element the target relocates holds an address, which only an element of a pointer's width
+    // can: the relocation fills exactly that many bytes.
+    for (const r of obj.relocs ?? []) {
+      if (width !== LOCAL_OBJECT_ADDRESS_BYTES || r.offset % width !== 0) {
+        return say(
+          `whose initializer holds the address '${r.symbol}', which its ${width}-byte elements cannot — ` +
+            `an address is ${LOCAL_OBJECT_ADDRESS_BYTES}`,
+        );
+      }
+      init![r.offset / width] = { symbol: r.symbol, addend: r.addend };
+    }
     if (zeroed.has(obj.symbol) && count !== 1) {
       return say(`laid out where only a scalar initialized to zero is, but of ${count} elements`);
     }
@@ -320,7 +434,7 @@ export function localStaticShapes(
       ...(string ? { string: true as const } : {}),
     });
   }
-  return { infos, statics };
+  return { infos, statics, images };
 }
 
 /** `sfn` with each static's linker name replaced by its source name — every reference, assignment
@@ -332,7 +446,26 @@ export function nameLocalStatics(sfn: SFn, objs: LocalObjects): SFn | { symbol:
   for (const g of sfn.globals ?? []) {
     taken.add(g.name);
   }
+  // The globals an initializer holds the address of are named here as much as the body's: a static
+  // of the same name is in scope from its own declarator on, its initializer included.
+  const addressed = new Map<string, string>();
+  for (const obj of objs.values()) {
+    for (const r of obj.relocs ?? []) {
+      taken.add(r.symbol);
+      addressed.set(r.symbol, obj.symbol);
+    }
+  }
   const bound = new Set([...sfn.params, ...sfn.locals].map((x) => x.name));
+  // …and the function's own parameters hide one too: a static's initializer is read in their scope.
+  // A local is declared after every static and hides none, but its name is the emitter's to move.
+  for (const [name, holder] of addressed) {
+    if (bound.has(name)) {
+      return {
+        symbol: holder,
+        refused: `whose initializer holds the address of '${name}', which a parameter or local here also names — it would hide that global`,
+      };
+    }
+  }
   const callees = new Set<string>([sfn.name]);
   for (const e of walkExprs(sfn.body)) {
     if (e.k === 'call' && typeof e.fn === 'string') {
@@ -342,6 +475,9 @@ export function nameLocalStatics(sfn: SFn, objs: LocalObjects): SFn | { symbol:
   const rename = new Map<string, string>();
   const bySource = new Map<string, string>();
   for (const obj of objs.values()) {
+    if (obj.anonymous) {
+      continue; // no source name: folded into a local's initializer at emission (l3/constinit.ts)
+    }
     const say = (why: string) => ({ symbol: obj.symbol, refused: `whose source name '${obj.name}' ${why}` });
     const other = bySource.get(obj.name);
     if (other !== undefined) {

package/src/structure/namecoalesce.ts

@@ -133,7 +133,7 @@ export interface NameCoalesceDeps {
   varName: ReadonlyMap<Value, string>;
   /** name → the type it is declared with */
   varType: ReadonlyMap<string, IrType>;
-  /** every natural loop, as its header and the blocks its body contains (structure/loops.ts) */
+  /** every natural loop, as its header and the blocks its body contains (ir/loops.ts) */
   loops: readonly { header: Block; body: ReadonlySet<Block> }[];
 }