@asmlift/core 0.10.0 → 0.11.0

package/src/l3/ast.ts

@@ -229,7 +229,7 @@ export type Expr =
        *  *u.half;` returns stale (`mov r0, #0x1`) where the subscript reloads. Set on a view of a
        *  frame union (structure.ts `frameUnionAccess`), the one access that rests on that set,
        *  and on an element of a frame array, where it only keeps the element spelling at index 0
-       *  (structure.ts `frameArrayElement`, l3/constinit.ts `asElement`). */
+       *  (structure.ts `bareArrayIndex`, l3/constinit.ts `asElement`). */
       subscript?: true;
     }
   // A named struct-field access `base->name` (raise/structs.ts recovered `base` as a struct
@@ -352,8 +352,36 @@ export type Stmt =
   // would bind it to the other kind — a plain one between `case` labels, this one in a loop body
   // (backend/cfamily.ts `refuseMisboundBreak`). A pass that reads `break` as a loop exit must skip
   // this one (l3/reindex.ts `hasLoopExit`).
-  | { k: 'break'; ofSwitch?: true }
+  //
+  // `label` names a switch-scoped `break` a case-end `goto` lands on (`L: break;`, see `goto`).
+  | { k: 'break'; ofSwitch?: true; label?: string }
   | { k: 'continue' }
+  // `goto <label>;` — L3 HOLDS TWO GOTOS, both narrow (docs/asmlift-101.md §2.7).
+  //
+  // A CASE-LABEL goto jumps to a case label of the switch it sits in, written where two or more arms
+  // enter one sibling arm's body and only one of them can reach it by falling through (`case 1: if
+  // (c) continue; goto L; case 2: … case 3: L: …`). `label` names the target arm's
+  // `SwitchCase.label`. It is the LAST statement of a case or default body, at that body's top
+  // level, and its label is a case of THAT switch — so no loop or nested switch stands between the
+  // jump and its target, and the jump runs exactly what a fall-through into that arm would run.
+  //
+  // A CASE-END goto is the next kind, `caseEndGoto`. Both are checked by `caseGotoViolation`
+  // (contracts.ts `assertCaseGotosNarrow`, which every structured and respelled tree passes). Any
+  // other goto is not representable. A goto ends its path like `break` and `continue`. SGI/IDO
+  // Pascal has no goto into a `case-of` arm, so its backend loud-fails it.
+  | { k: 'goto'; label: string }
+  // `goto <label>;` — THE CASE-END GOTO, the second goto L3 holds, a jump to the end of the arm it
+  // sits in: `label` names a labelled switch-scoped `break` (`L: break;`) that is an element of a
+  // statement list enclosing the goto, later in that list than the statement holding it, with no
+  // switch between the two and no loop around the label inside the arm — so the jump leaves every
+  // loop it sits in and then the switch, and runs nothing on the way. It is the source's `for (j…)
+  // { if (hit) { …; goto L; } } k(i); L: break;`, which agbcc threads past the loop around the
+  // switch (jump.c `follow_jumps`). Its own kind, not a flag on `goto`, so every pass that reads a
+  // `goto` as the jump into a case arm (`switchArmSuccessors`, `switchJumpsBack`) never meets one,
+  // and every exhaustive switch over `Stmt` decides it. It ends its path, and leaves the innermost
+  // switch around it. Written only by l3/caseendgoto.ts. SGI/IDO Pascal has no `break`, so its
+  // backend loud-fails it.
+  | { k: 'caseEndGoto'; label: string }
   // A multi-way `switch` over an integer scrutinee (recovered from a comparison tree — Regime A — or
   // a jump-table `switch_br` — Regime B). `cases` are emitted IN ARRAY ORDER; `default` (if present)
   // is emitted after `defaultAt` of them, or after all of them when that is absent.
@@ -398,6 +426,10 @@ export interface SwitchCase {
   values: number[];
   body: Stmt[];
   fallsThrough: boolean;
+  /** The C label printed after this arm's `case` labels, present only where a `goto` of this same
+   *  switch names it (see the `goto` statement). A pass that merges, drops or reorders arms keeps it
+   *  on the arm it labels. */
+  label?: string;
 }
 
 export interface SFn {
@@ -579,6 +611,12 @@ export interface LanguageBackend {
    *  spells without one, by copying the code the arm meets at into each path, which Pascal prints.
    *  The structurer reads it through `StructureOptions.spellSwitchBreak`. */
   readonly spellsSwitchBreak: boolean;
+  /** Can this language spell a `return` before the end of the function? C and C++ can; Pascal
+   *  cannot, and its backend loud-fails one. Asked for the same reason again: the join past early
+   *  returns ends each arm that leaves early in a `return`, and the same branch also spells by
+   *  copying the code below it into each arm (the return-tail copies), which Pascal prints. The
+   *  structurer reads it through `StructureOptions.spellEarlyReturns`. */
+  readonly spellsEarlyReturn: boolean;
   emit(fn: SFn): string;
   // Spell ONE LINE of text as a comment in this language (C block comments, Pascal `(* … *)`).
   // Used by the annotate-mode stub path to carry the failure reason + the original asm
@@ -896,6 +934,8 @@ export function stmtExprs(s: Stmt): Expr[] {
       return [s.scrutinee];
     case 'break':
     case 'continue':
+    case 'goto':
+    case 'caseEndGoto':
       return [];
   }
 }
@@ -935,6 +975,8 @@ export function mapStmtExprs(s: Stmt, f: (e: Expr) => Expr): Stmt {
       };
     case 'break':
     case 'continue':
+    case 'goto':
+    case 'caseEndGoto':
       return s;
   }
 }
@@ -1091,6 +1133,8 @@ export function stmtChildren(s: Stmt): Stmt[] {
     case 'return':
     case 'break':
     case 'continue':
+    case 'goto':
+    case 'caseEndGoto':
       return [];
     case 'if':
       return [...s.then, ...s.else];
@@ -1141,10 +1185,254 @@ export function isLoop(s: Stmt): s is Loop {
     case 'return':
     case 'break':
     case 'continue':
+    case 'goto':
+    case 'caseEndGoto':
       return false;
   }
 }
 
+/** Why `body` breaks the two forms a `goto` may take in L3 (the `goto` statement's contract), or
+ *  null when every `goto` in it keeps one. A case-label goto is the LAST statement of a case or
+ *  default body, at that body's top level, naming a label one case of THAT switch carries. A
+ *  case-end goto (`caseEndGoto`) names a labelled switch-scoped `break` later in a statement list that
+ *  encloses it, inside the same switch arm, with no switch between them; ifs and loops may stand
+ *  between, but no loop may stand between the labelled `break` and its arm. Labels are unique
+ *  across the function, case labels and `break` labels together. Any other placement is refused:
+ *  a case-label goto under an `if`, in a loop body, in a nested switch's arm aimed at the outer
+ *  switch or before another statement; a case-end goto in a nested switch, in another arm, outside
+ *  the switch, or after its label; a labelled `break` that is not the switch's or sits in a loop.
+ *
+ *  Shared by contracts.ts `assertCaseGotosNarrow`, which every structured and respelled tree
+ *  passes, and the C-family printer, which asks it of every function it prints: a pass that moves
+ *  a statement across an arm boundary is caught at the one place the program is spelled. */
+export function caseGotoViolation(body: readonly Stmt[]): string | null {
+  const seen = new Set<string>();
+  const claim = (label: string): string | null => {
+    if (seen.has(label)) {
+      return `the label \`${label}\` is carried by two switch arms`;
+    }
+    seen.add(label);
+    return null;
+  };
+  /** `labels`: the case labels a case-label goto here may name (null outside an arm's top level's
+   *  reach); `ends`: the `break` labels a case-end goto here may name; `inArm`: inside a switch arm
+   *  with no loop entered since it began, where a labelled `break` may sit. */
+  type Scope = { labels: ReadonlySet<string> | null; armTop: boolean; ends: ReadonlySet<string>; inArm: boolean };
+  const walk = (list: readonly Stmt[], scope: Scope): string | null => {
+    // `after[i]`: the `break` labels later in this list than `i`, beside the enclosing ones — built
+    // only for a list holding one, so the walk allocates nothing per statement on a goto-free tree
+    const after = endsAfter(list, scope.ends);
+    for (const [i, s] of list.entries()) {
+      if (s.k === 'caseEndGoto') {
+        if (!scope.ends.has(s.label)) {
+          return `\`goto ${s.label};\` names no labelled \`break;\` that ends the switch arm it sits in`;
+        }
+        continue;
+      }
+      if (s.k === 'goto') {
+        if (scope.labels === null || !scope.armTop || i !== list.length - 1) {
+          return `\`goto ${s.label};\` is not the last statement of a switch arm's own body`;
+        }
+        if (!scope.labels.has(s.label)) {
+          return `\`goto ${s.label};\` names no case label of the switch it sits in`;
+        }
+        continue;
+      }
+      if (s.k === 'break' && s.label !== undefined) {
+        if (s.ofSwitch !== true || !scope.inArm) {
+          return `the label \`${s.label}\` is not on a \`break;\` that leaves a switch arm`;
+        }
+        const why = claim(s.label);
+        if (why !== null) {
+          return why;
+        }
+        continue;
+      }
+      if (s.k === 'switch') {
+        const own = new Set<string>();
+        for (const c of s.cases) {
+          if (c.label !== undefined) {
+            const why = claim(c.label);
+            if (why !== null) {
+              return why;
+            }
+            own.add(c.label);
+          }
+        }
+        for (const arm of [...s.cases.map((c) => c.body), s.default ?? []]) {
+          const why = walk(arm, { labels: own, armTop: true, ends: NO_ENDS, inArm: true });
+          if (why !== null) {
+            return why;
+          }
+        }
+        continue;
+      }
+      // The `break` labels later in this list are the ends a goto inside `s` may reach. Inside a
+      // loop the switch's case labels are out of reach (a case-label goto there would leave the
+      // loop) and no `break;` leaves the arm.
+      const ends = after?.[i] ?? scope.ends;
+      const loop = isLoop(s);
+      for (const inner of stmtLists(s)) {
+        const why = walk(inner, {
+          labels: loop ? null : scope.labels,
+          armTop: false,
+          ends,
+          inArm: scope.inArm && !loop,
+        });
+        if (why !== null) {
+          return why;
+        }
+      }
+      if (s.k === 'for') {
+        const why = walk([s.init, s.inc], { labels: null, armTop: false, ends: NO_ENDS, inArm: false });
+        if (why !== null) {
+          return why;
+        }
+      }
+    }
+    return null;
+  };
+  return walk(body, { labels: null, armTop: false, ends: NO_ENDS, inArm: false });
+}
+
+const NO_ENDS: ReadonlySet<string> = new Set();
+
+/** For each index of `list`, `outer` and the labels of the labelled `break`s that are elements of
+ *  `list` after it; undefined where `list` holds none, so every index reads `outer`. */
+function endsAfter(list: readonly Stmt[], outer: ReadonlySet<string>): ReadonlySet<string>[] | undefined {
+  if (!list.some((s) => s.k === 'break' && s.label !== undefined)) {
+    return undefined;
+  }
+  const out: ReadonlySet<string>[] = new Array(list.length);
+  let later: ReadonlySet<string> = outer;
+  for (let i = list.length - 1; i >= 0; i--) {
+    out[i] = later;
+    const s = list[i];
+    if (s.k === 'break' && s.label !== undefined) {
+      later = new Set([...later, s.label]);
+    }
+  }
+  return out;
+}
+
+/** Does a case-end `goto` in `list`, at any depth, name a labelled `break` that `list` does not
+ *  hold — so the jump leaves `list`, and every loop of it the goto sits in? A pass asking whether a
+ *  loop body leaves its loop asks this beside its `break`s (l3/reindex.ts `hasLoopExit`). */
+export function caseEndGotoLeaves(list: readonly Stmt[]): boolean {
+  const held = new Set<string>();
+  const named: string[] = [];
+  const visit = (s: Stmt): void => {
+    if (s.k === 'break' && s.label !== undefined) {
+      held.add(s.label);
+    } else if (s.k === 'caseEndGoto') {
+      named.push(s.label);
+    }
+    stmtChildren(s).forEach(visit);
+  };
+  list.forEach(visit);
+  return named.some((l) => !held.has(l));
+}
+
+/** Can control fall off the END of `list`? False only where every path through it is provably
+ *  left first — by `return`, `continue`, a loop's `break`, a `goto`, a switch-scoped `break` or a
+ *  case-end `goto` (which leave the arm they sit in), or an `if` or `switch` none of whose paths
+ *  reaches its own end. A loop is read as reaching its end (a decided exit is not looked for), so
+ *  the answer errs toward "reaches", which is the side a caller appending a jump after the list
+ *  can afford: the jump it then writes is one no path runs, dead code and never a path cut. */
+export function reachesEnd(list: readonly Stmt[]): boolean {
+  // `end`: some path falls off the list's last statement; `leaves`: some path takes a
+  // switch-scoped `break` out of it, which ends the innermost switch around it.
+  const flow = (ss: readonly Stmt[]): { end: boolean; leaves: boolean } => {
+    let leaves = false;
+    for (const s of ss) {
+      switch (s.k) {
+        case 'return':
+        case 'continue':
+        case 'goto':
+          return { end: false, leaves };
+        // a case-end goto leaves the innermost switch around it, as its labelled `break;` does
+        case 'caseEndGoto':
+          return { end: false, leaves: true };
+        case 'break':
+          return { end: false, leaves: leaves || s.ofSwitch === true };
+        case 'if': {
+          const t = flow(s.then);
+          const e = flow(s.else);
+          leaves ||= t.leaves || e.leaves;
+          if (!t.end && !e.end) {
+            return { end: false, leaves };
+          }
+          break;
+        }
+        case 'switch': {
+          // Its end is reached by a `break` out of an arm, by an arm that neither falls nor jumps
+          // on and reaches its own end, or — with no `default` — by a value no case names.
+          const next = switchArmSuccessors(s);
+          const ends =
+            s.default === undefined ||
+            [...s.cases.map((c) => c.body), s.default].some((body, i) => {
+              const f = flow(body);
+              return f.leaves || (f.end && next[i] === undefined);
+            });
+          if (!ends) {
+            return { end: false, leaves };
+          }
+          break;
+        }
+        case 'while':
+        case 'dowhile':
+        case 'for':
+        case 'assign':
+        case 'store':
+        case 'exprstmt':
+          break;
+      }
+    }
+    return { end: true, leaves };
+  };
+  return flow(list).end;
+}
+
+/** For each arm of a `switch` — its cases in order, then its `default` at index `cases.length` —
+ *  the arm control runs on into from that arm's end, or undefined where it leaves the switch: the
+ *  arm a trailing `goto` names (its last top-level statement, `caseGotoViolation`), else the next
+ *  arm where the case falls through (the last case into the `default`, or out where there is
+ *  none). The one reading of "arm `i` runs on into arm `j`" that contracts.ts's effect count and
+ *  l3/coalesce.ts's arm-disjointness both follow, transitively. */
+export function switchArmSuccessors(sw: Extract<Stmt, { k: 'switch' }>): (number | undefined)[] {
+  const labelled = new Map(sw.cases.flatMap((c, i) => (c.label === undefined ? [] : [[c.label, i] as const])));
+  const jumpOf = (body: readonly Stmt[]): number | undefined => {
+    const last = body[body.length - 1];
+    return last?.k === 'goto' ? labelled.get(last.label) : undefined;
+  };
+  const last = sw.cases.length;
+  return [
+    ...sw.cases.map(
+      (c, i) => jumpOf(c.body) ?? (c.fallsThrough && (i + 1 < last || sw.default !== undefined) ? i + 1 : undefined),
+    ),
+    sw.default === undefined ? undefined : jumpOf(sw.default),
+  ];
+}
+
+/** Does a case-label `goto` of this switch land on an arm LAID OUT AT OR ABOVE the arm it ends —
+ *  a BACK EDGE with no loop statement around it? Then the arm it lands on runs AFTER the jumping
+ *  arm, so preorder stops being execution order inside the switch's own range, exactly as it does
+ *  inside a loop body; a pass that reads preorder as liveness must count such a switch with the
+ *  loops (l3/coalesce.ts `spans`). Positions are the layout {@link stmtChildren} walks: the
+ *  `default` sits at `defaultAt`. A fall-through only ever runs on DOWNWARD, so only the jumps are
+ *  asked. */
+export function switchJumpsBack(sw: Extract<Stmt, { k: 'switch' }>): boolean {
+  const at = sw.defaultAt ?? sw.cases.length;
+  const laidOut = (arm: number): number => (arm === sw.cases.length ? at : arm < at ? arm : arm + 1);
+  const labelled = new Map(sw.cases.flatMap((c, i) => (c.label === undefined ? [] : [[c.label, i] as const])));
+  const bodies = [...sw.cases.map((c) => c.body), sw.default ?? []];
+  return bodies.some((body, i) => {
+    const last = body[body.length - 1];
+    const to = last?.k === 'goto' ? labelled.get(last.label) : undefined;
+    return to !== undefined && laidOut(to) <= laidOut(i);
+  });
+}
+
 /** The nested statement LISTS of a statement — the SCOPES it opens.
  *
  *  Deliberately not `stmtChildren`, which flattens a `for`'s `init`/`inc` in with its body: those
@@ -1172,6 +1460,8 @@ export function stmtLists(s: Stmt): Stmt[][] {
     case 'return':
     case 'break':
     case 'continue':
+    case 'goto':
+    case 'caseEndGoto':
       return [];
   }
 }
@@ -1201,6 +1491,8 @@ export function mapStmtLists(s: Stmt, f: (list: Stmt[]) => Stmt[]): Stmt {
     case 'return':
     case 'break':
     case 'continue':
+    case 'goto':
+    case 'caseEndGoto':
       return s;
   }
 }

package/src/l3/basecse.ts

@@ -203,13 +203,16 @@ interface Collected {
    *  pass has rebuilt one node and dropped the stamp, and requiring all of them makes that a
    *  refusal rather than a half-homed base. */
   ordered: Map<string, boolean>;
+  /** per key, whether EVERY access so far sits under some connective's right operand — `false`
+   *  once one access is under none (the input to `guardedOperand`) */
+  guard: Map<string, boolean>;
 }
 
 /** Every `index` node whose base is a hoistable leaf, tallied by key (the gates' use count) and in
  *  first-appearance order (so the hoisted assignments emit in the order the bases are first used,
  *  matching the compiler's pool-load order). `loop` marks uses nested in a while/do-while/for. */
 function collect(stmts: Stmt[], c: Collected, loop: boolean): void {
-  const visitExpr = (e: Expr, inLoop: boolean): void => {
+  const visitExpr = (e: Expr, inLoop: boolean, guard: boolean): void => {
     if (e.k === 'index' && isHoistableBase(e.base)) {
       const k = keyOf(e.base, e.width, e.signed);
       if (!c.count.has(k)) {
@@ -232,9 +235,11 @@ function collect(stmts: Stmt[], c: Collected, loop: boolean): void {
         c.operandOff.add(k);
       }
       c.ordered.set(k, (c.ordered.get(k) ?? true) && e.baseOrdered === true);
+      c.guard.set(k, (c.guard.get(k) ?? true) && guard);
     }
+    const rhs = e.k === 'bin' && (e.op === '&&' || e.op === '||') ? e.r : null;
     for (const ch of exprChildren(e)) {
-      visitExpr(ch, inLoop);
+      visitExpr(ch, inLoop, guard || ch === rhs);
     }
   };
   for (const s of stmts) {
@@ -242,7 +247,7 @@ function collect(stmts: Stmt[], c: Collected, loop: boolean): void {
     // there is loop-invariant just like a body use — visit it with `nested`, not the outer flag.
     const nested = loop || isLoop(s);
     for (const e of stmtExprs(s)) {
-      visitExpr(e, nested);
+      visitExpr(e, nested, false);
     }
     collect(stmtChildren(s), c, nested);
   }
@@ -380,6 +385,14 @@ export interface BaseKey {
    *  false for every base a compiler that has not opted in produced, which is what keeps the variation
    *  off those targets. */
   orderLicensed: boolean;
+  /** EVERY access sits in the right operand of some `&&`/`||` — the half C evaluates only when the
+   *  left one did not decide. A head hoist puts the base's load above that guard, where the compiler
+   *  loaded it inside the operand: `if (gY != 5 || (gS.a | gS.d | gS.c) != 0)` reads `&gS` into a
+   *  register after the `gY` test, while `p0 = &gS;` ahead of the `if` loads it first. Not one
+   *  operand: accesses under two different guards (`(gY != 5 || gS.a) && (gA != 1 || gS.c)`, or the
+   *  two in separate `if`s) are each loaded under their own, so a hoist above both moves every load
+   *  (agbcc 15/39 and 19/40 hoisted, 9/39 inline). */
+  guardedOperand: boolean;
 }
 
 /** The admission rules. NONE is sound, and that is a property of the pass rather than an oversight:
@@ -441,6 +454,16 @@ export const BASECSE_GATES: readonly Gate<BaseKey>[] = [
     sound: false,
     rejects: (c) => c.repeatedConstOffset,
   },
+  {
+    // `if (gY != 5 || (gS.a | gS.d | gS.c) != 0) { … }` on agbcc: the inline spelling MATCHES and
+    // `p0 = (u8 *)&gS;` above the `if` does not (7 points over 44), because the literal load moves
+    // ahead of the first test. A placement prediction like the two above, ablated with them for
+    // `/livebase`, so a hoisted base before a connective stays a candidate the differ can pick.
+    id: 'guarded-operand',
+    why: 'a base read only under the second half of a condition is loaded there, after the first half',
+    sound: false,
+    rejects: (c) => c.guardedOperand,
+  },
 ];
 
 /** `/basefold`'s admission (rank.ts): the default rules with `single-use` EXEMPTING a base whose
@@ -473,15 +496,15 @@ export const BASEFOLD_GATES: readonly Gate<BaseKey>[] = [
   ...ablateHeuristic(BASECSE_GATES, 'single-use'),
 ];
 
-/** The `/livebase` variation's admission (rank.ts): the default rules with both PLACEMENT heuristics
- *  ablated, keeping only `single-use`. `loop` and `repeated-const-offset` predict which spelling
- *  the compiler chose, and both predictions have a counterexample — an MMIO poll (`p[2] = go;
- *  while (p[2] & BUSY) {}`) stores and re-reads a fixed offset through ONE register the whole
- *  time. Neither gate is `sound`, so ablating them can only change which spelling wins, never
+/** The `/livebase` variation's admission (rank.ts): the default rules with the PLACEMENT heuristics
+ *  ablated, keeping only `single-use`. `loop`, `repeated-const-offset` and `guarded-operand` predict
+ *  which spelling the compiler chose, and the first two have a counterexample — an MMIO poll
+ *  (`p[2] = go; while (p[2] & BUSY) {}`) stores and re-reads a fixed offset through ONE register
+ *  the whole time. None of the three is `sound`, so ablating them can only change which spelling wins, never
  *  what a candidate means; the differ referees. */
 export const LIVEBASE_GATES: readonly Gate<BaseKey>[] = ablateHeuristic(
-  ablateHeuristic(BASECSE_GATES, 'loop'),
-  'repeated-const-offset',
+  ablateHeuristic(ablateHeuristic(BASECSE_GATES, 'loop'), 'repeated-const-offset'),
+  'guarded-operand',
 );
 
 /** `/livebase-block`'s admission (rank.ts): `/livebase` plus `single-cell`. The two tables differ
@@ -725,6 +748,7 @@ function collectFrom(sfn: SFn): Collected {
     varIndexed: new Set(),
     operandOff: new Set(),
     ordered: new Map(),
+    guard: new Map(),
   };
   collect(sfn.body, c, false);
   return c;
@@ -745,6 +769,7 @@ function admit(sfn: SFn, gates: readonly Gate<BaseKey>[]): { c: Collected; keys:
         unfoldedOffset: c.operandOff.has(k),
         castBase: c.meta.get(k)!.base.k === 'cast',
         orderLicensed: c.ordered.get(k) === true,
+        guardedOperand: c.guard.get(k) === true,
       }) === null
     );
   });