@asmlift/core 0.9.0 → 0.11.0

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,21 +247,41 @@ 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);
   }
 }
 
-/** Rewrite every `index`-of-hoistable-base whose key is hoisted so its base becomes the hoist local. */
-function rewrite(e: Expr, localFor: Map<string, string>): Expr {
+/** Rewrite every `index`-of-hoistable-base whose key is hoisted so its base becomes the hoist local.
+ *
+ *  A `volatile` cast over a hoisted LEAF keeps its cast and takes the local under it:
+ *  `((volatile s32 *)0x40000D4)[2]` beside a hoisted `p0 = (s32 *)0x40000D4` becomes
+ *  `((volatile s32 *)p0)[2]`. The cast is never hoisted itself (`isHoistableBase`), since the local
+ *  would drop its qualifier; under it the local is the same address, so the access keeps its
+ *  qualifier and its cell, and reads the register the compiler already holds the base in. Inline, a
+ *  qualified access at a nonzero offset makes agbcc materialize a second literal with the offset
+ *  folded in (`.word 0x40000dc` + `ldr r0, [r0]`) where the source read `[r4, #0x8]` off the base
+ *  it had loaded — the `dmaRegs[2];` that ends a DMA macro. `leafLocal` maps a hoisted leaf to its
+ *  local, whichever key hoisted it. */
+function rewrite(e: Expr, localFor: Map<string, string>, leafLocal: ReadonlyMap<string, string>): Expr {
   if (e.k === 'index' && isHoistableBase(e.base)) {
     const nm = localFor.get(keyOf(e.base, e.width, e.signed));
     if (nm) {
-      return { ...e, base: { k: 'var', name: nm }, idx: rewrite(e.idx, localFor) };
+      return { ...e, base: { k: 'var', name: nm }, idx: rewrite(e.idx, localFor, leafLocal) };
     }
   }
-  return mapExprChildren(e, (c) => rewrite(c, localFor));
+  if (e.k === 'index' && e.base.k === 'cast' && e.base.volatile === true && isHoistableLeaf(e.base.e)) {
+    const nm = leafLocal.get(leafId(e.base.e));
+    if (nm) {
+      return {
+        ...e,
+        base: { ...e.base, e: { k: 'var', name: nm } },
+        idx: rewrite(e.idx, localFor, leafLocal),
+      };
+    }
+  }
+  return mapExprChildren(e, (c) => rewrite(c, localFor, leafLocal));
 }
 
 /** One base under consideration, keyed as `(base, width, signedness)`. */
@@ -360,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:
@@ -421,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
@@ -453,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
@@ -705,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;
@@ -725,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
     );
   });
@@ -784,7 +829,15 @@ export function hoistBaseLocals(
     });
   }
 
-  const rewritten = sfn.body.map((s) => mapStmtExprs(s, (e) => rewrite(e, localFor)));
+  const leafLocal = new Map<string, string>();
+  for (const k of hoisted) {
+    const b = meta.get(k)!.base;
+    const leaf = leafId(b.k === 'cast' ? b.e : b);
+    if (!leafLocal.has(leaf)) {
+      leafLocal.set(leaf, localFor.get(k)!);
+    }
+  }
+  const rewritten = sfn.body.map((s) => mapStmtExprs(s, (e) => rewrite(e, localFor, leafLocal)));
   // The new inits join the tree's LEADING run of base inits rather than being prepended above it:
   // when rank's /livebase re-runs this pass the head already carries the default run's, and
   // blindly prepending would spell the new base's pool load above locals the compiler loads first.

package/src/l3/caseendgoto.ts

@@ -0,0 +1,223 @@
+// L3 respell variation `/case-end-goto`: a search loop's hit flag, read once after its loop where the
+// code after the loop ends the switch arm the loop sits in, rewritten as the source's `goto` to that
+// arm's end — the case-end goto (l3/ast.ts `caseEndGoto`, docs/asmlift-101.md §2.7):
+//
+//     f = 0;                                      for (j…) {
+//     for (j…) {                                      if (hit) { s(j); goto case_end; }
+//         if (hit) { s(j); f = 1; break; }        }
+//     }                                    →      k(i);
+//     if (f == 0) { k(i); }                       case_end:
+//     break;                                      break;
+//
+// The structurer writes the flag where a two-level exit's second target lies past the code after
+// the loop (structure.ts `TwoLevelExit`, `emitForeverExit`). Where that target is the end of the
+// switch arm, agbcc threads the source's goto past the loop around the switch (jump.c
+// `follow_jumps`), and on agbcc, KMC, gcc 2.7.2 and IDO the goto compiles to the source's bytes
+// where the flag never does (`synthetic:sw_hitexit`); but inside asmlift's own candidates the flag
+// can still score closer (gcc 2.7.2), so both are emitted, the differ referees, and a tie goes to
+// the candidate without the goto (rank.ts `gotoCount`).
+//
+// The structurer is not the only writer the rewrite reaches: it reads the tree, not who built it,
+// so a flag the source declared and the compiler kept is rewritten too where it has the same shape
+// (IDO keeps a `u8 found` a source sets to 2 in a case arm, and lifts it as that flag). That is
+// sound for the reason below, which reads only the tree, and ranked like the rest.
+//
+// SOUND OVER THE TREE ALONE. `f` is a local mentioned only by `f = 0;` right before the loop, by
+// each hit's `f = c; break;` (c a nonzero constant, the `break` the loop's own: reached from the
+// loop's body through `if`s only) and by the test right after the loop (`CASE_END_GOTO_GATES`
+// `flag-elsewhere`). So after the loop `f == 0` exactly when it left by any other way than a hit,
+// and `X` runs exactly then — which is what `goto L;` at each hit and `X` unguarded after the loop
+// run. After `X` both spellings go on to whatever follows the `if`, and that is the arm's end with
+// nothing run on the way (`target-not-arm-end`): a switch `break;` right after the `if`, which takes
+// the label, or the `if` last in a list whose falling off runs nothing before leaving the switch,
+// which gets a labelled `break;` appended. `L: break;` leaves the switch as falling off the arm
+// does. The label sits in the loop's own list, no loop between it and its arm, and
+// the hits' `break`s are reached through `if`s only, so no switch stands between them and it: the
+// form `caseGotoViolation` holds every case-end goto to.
+//
+// A RESPELL, NOT A STRUCTURE VARIATION — the third fork of docs/level-tower.md. The rewrite reads
+// nothing but the flag's tree, so asked of the structured tree it reaches every site a structure
+// option inside `emitForeverExit` would. A structure variation doubles the settings every
+// enumeration walks even where it changes no tree, which level-tower.md measures on this one; the
+// respell costs one walk of each structured tree, and nothing more where no flag is read after its
+// loop. What it gives up is composition with the other pre-respell variation (`/unmerge` runs on
+// the structured tree beside it, not on its output); no row has asked for both.
+//
+// Outer sites first, and an inner site whose `if` the outer rewrite leaves right before the outer
+// label takes that label, so two search loops in sequence into one case end share one `L:`.
+import { type Expr, type Loop, type SFn, type Stmt, type SwitchCase, isLoop, mapStmtLists, stmtChildren } from './ast';
+import { type Gate, firstRejection } from './gates';
+import { localMentions, readsOf } from './mentions';
+
+/** A flag read after its loop that the rewrite would replace (`CASE_END_GOTO_GATES`). */
+export interface CaseEndSite {
+  /** what runs after the `if (f == 0)` is not the arm's end: no switch `break;` follows it, and it
+   *  is not last in a list whose falling off leaves the switch with nothing run. Outside a switch
+   *  arm, or in a loop inside one, neither can hold (a switch `break;` sits only in an arm with no
+   *  loop between, `refuseMisboundBreak`), so this is also the rule that keeps such a flag */
+  readonly targetNotArmEnd: boolean;
+  /** `f` is a param or global, or mentioned anywhere but its `f = 0;`, its hits and its one test */
+  readonly flagElsewhere: boolean;
+}
+
+/** When a flag read after its loop is rewritten as a case-end goto. The argument is the file's. */
+export const CASE_END_GOTO_GATES: readonly Gate<CaseEndSite>[] = [
+  {
+    id: 'target-not-arm-end',
+    why: 'the goto skips only the guarded code, so what follows it must leave the switch with nothing run',
+    sound: true,
+    guardedBy: [
+      'case-end-goto.test.ts: a hit whose target is a join running code keeps its flag',
+      'case-end-goto.test.ts: a flag read outside a switch arm, or in a loop inside one, keeps its flag',
+    ],
+    rejects: (c) => c.targetNotArmEnd,
+  },
+  {
+    id: 'flag-elsewhere',
+    why: 'the flag is zero after the loop exactly when no hit ran only if nothing else writes or reads it',
+    sound: true,
+    guardedBy: 'case-end-goto.test.ts: a flag read or written anywhere else keeps its flag',
+    rejects: (c) => c.flagElsewhere,
+  },
+];
+
+/** `f == 0`, the structurer's test of a flag (structure.ts `emitForeverExit`) */
+const flagTest = (e: Expr): string | null =>
+  e.k === 'bin' && e.op === '==' && e.l.k === 'var' && e.r.k === 'const' && e.r.value === 0 ? e.l.name : null;
+
+/** The hits in `body`, a loop's body: each `f = c; break;` (c a nonzero constant) reached through
+ *  `if`s only, so the `break` is that loop's own. */
+function hitsIn(body: readonly Stmt[], flag: string): number {
+  return body.reduce((n, s, i) => {
+    const next = body[i + 1];
+    if (
+      s.k === 'assign' &&
+      s.name === flag &&
+      s.value.k === 'const' &&
+      s.value.value !== 0 &&
+      next?.k === 'break' &&
+      next.ofSwitch !== true &&
+      next.label === undefined
+    ) {
+      return n + 1;
+    }
+    return s.k === 'if' ? n + hitsIn(s.then, flag) + hitsIn(s.else, flag) : n;
+  }, 0);
+}
+
+/** `body` with each hit `hitsIn` counts written `goto label;` */
+function jumpHits(body: readonly Stmt[], flag: string, label: string): Stmt[] {
+  return body.flatMap((s, i): Stmt[] => {
+    const prev = body[i - 1];
+    if (s.k === 'break' && prev?.k === 'assign' && prev.name === flag && s.ofSwitch !== true) {
+      return [];
+    }
+    if (s.k === 'assign' && s.name === flag) {
+      return [{ k: 'caseEndGoto', label }];
+    }
+    return s.k === 'if' ? [{ ...s, then: jumpHits(s.then, flag, label), else: jumpHits(s.else, flag, label) }] : [s];
+  });
+}
+
+/** `f = 0; LOOP; if (f == 0) { X }` starting at `list[i]`, the structurer's flag read after its loop */
+function siteAt(
+  list: readonly Stmt[],
+  i: number,
+): { flag: string; loop: Loop; test: Extract<Stmt, { k: 'if' }> } | null {
+  const [init, loop, test] = [list[i], list[i + 1], list[i + 2]];
+  if (
+    init?.k !== 'assign' ||
+    init.value.k !== 'const' ||
+    init.value.value !== 0 ||
+    loop === undefined ||
+    !isLoop(loop) ||
+    test?.k !== 'if' ||
+    test.else.length > 0 ||
+    flagTest(test.cond) !== init.name
+  ) {
+    return null;
+  }
+  return { flag: init.name, loop, test };
+}
+
+/** Every flag read after its loop where the code after the loop ends its switch arm, rewritten as
+ *  a case-end goto, or null where none is (the variation's decline). */
+export function jumpToCaseEnds(sfn: SFn, gates: readonly Gate<CaseEndSite>[] = CASE_END_GOTO_GATES): SFn | null {
+  const mentions = localMentions(sfn);
+  const labels = new Set<string>();
+  const collect = (s: Stmt): void => {
+    if (s.k === 'switch') {
+      s.cases.forEach((c) => c.label !== undefined && labels.add(c.label));
+    } else if (s.k === 'break' && s.label !== undefined) {
+      labels.add(s.label);
+    }
+    stmtChildren(s).forEach(collect);
+  };
+  sfn.body.forEach(collect);
+  const fresh = (): string => {
+    let label = 'case_end';
+    for (let n = 2; labels.has(label); n++) {
+      label = `case_end_${n}`;
+    }
+    labels.add(label);
+    return label;
+  };
+  const dropped = new Set<string>();
+
+  /** `inArm`: the list is inside a switch arm with no loop between; `leaves`: falling off its end
+   *  leaves that switch with nothing run on the way. */
+  const rewrite = (list: readonly Stmt[], inArm: boolean, leaves: boolean): Stmt[] => {
+    const out = [...list];
+    for (let i = 0; i < out.length; i++) {
+      const site = siteAt(out, i);
+      if (site !== null) {
+        const { flag, loop, test } = site;
+        const after = out[i + 3];
+        const end = after?.k === 'break' && after.ofSwitch === true ? after : undefined;
+        const m = mentions.get(flag);
+        const hits = hitsIn(loop.body, flag);
+        const refused = firstRejection(gates, {
+          targetNotArmEnd: end === undefined && !(after === undefined && leaves),
+          flagElsewhere:
+            m === undefined || hits === 0 || m.assigns !== hits + 1 || readsOf(m) !== 1 || m.addrTaken !== 0,
+        });
+        if (refused === null) {
+          const label = end?.label ?? fresh();
+          const jumped: Stmt = { ...loop, body: jumpHits(loop.body, flag, label) };
+          out.splice(i, end ? 4 : 3, descend(jumped, false, undefined, false), ...test.then, {
+            k: 'break',
+            ofSwitch: true,
+            label,
+          });
+          dropped.add(flag);
+          // `X` is visited next, in this list, so a site inside it whose `if` now sits right before
+          // the label takes that label
+          continue;
+        }
+      }
+      out[i] = descend(out[i], inArm, out[i + 1], i === out.length - 1 && leaves);
+    }
+    return out;
+  };
+  /** `s` with its lists rewritten; `next` follows it in its list, and `last` says it ends a list
+   *  whose falling off leaves the switch */
+  const descend = (s: Stmt, inArm: boolean, next: Stmt | undefined, last: boolean): Stmt => {
+    if (s.k === 'switch') {
+      const arm = (c: SwitchCase): SwitchCase => ({ ...c, body: rewrite(c.body, true, !c.fallsThrough) });
+      return { ...s, cases: s.cases.map(arm), ...(s.default ? { default: rewrite(s.default, true, true) } : {}) };
+    }
+    if (isLoop(s)) {
+      return mapStmtLists(s, (l) => rewrite(l, false, false));
+    }
+    if (s.k === 'if') {
+      const leaves = inArm && ((next?.k === 'break' && next.ofSwitch === true) || (next === undefined && last));
+      return { ...s, then: rewrite(s.then, inArm, leaves), else: rewrite(s.else, inArm, leaves) };
+    }
+    return s;
+  };
+  const body = rewrite(sfn.body, false, false);
+  if (dropped.size === 0) {
+    return null;
+  }
+  return { ...sfn, body, locals: sfn.locals.filter((l) => !dropped.has(l.name)) };
+}

package/src/l3/coalesce.ts

@@ -12,7 +12,16 @@
 // and whether fall-through joins the two arms onto one path. `coalesceCandidates` offers both.
 import { typeToString } from '../ir/types';
 import type { Expr, SFn, Stmt } from './ast';
-import { exprChildren, isLoop, mapExprChildren, mentionedName, stmtChildren, stmtExprs } from './ast';
+import {
+  exprChildren,
+  isLoop,
+  mapExprChildren,
+  mentionedName,
+  stmtChildren,
+  stmtExprs,
+  switchArmSuccessors,
+  switchJumpsBack,
+} from './ast';
 import { type Gate, firstRejection } from './gates';
 
 function namesIn(e: Expr, out: Set<string>): void {
@@ -122,8 +131,12 @@ function spans(body: Stmt[]): Map<string, Span> {
   };
   /** the loop set a while/do-while's own condition and children run under — its own. A `for` is
    *  routed separately: `stmtChildren` hands back its init too, and the init is the one child its
-   *  loop does not re-run. */
-  const under = (s: Stmt, loops: readonly Stmt[]): readonly Stmt[] => (isLoop(s) ? [...loops, s] : loops);
+   *  loop does not re-run. A switch whose case-label `goto` lands on an arm laid out above it
+   *  (`switchJumpsBack`) counts too: that jump is a back edge with no loop statement, and the arm
+   *  it lands on runs after the one that jumps, so a local the lower arm writes can clobber one the
+   *  upper arm still reads. */
+  const under = (s: Stmt, loops: readonly Stmt[]): readonly Stmt[] =>
+    isLoop(s) || (s.k === 'switch' && switchJumpsBack(s)) ? [...loops, s] : loops;
   const walk = (list: Stmt[], loops: readonly Stmt[]): void => {
     for (const s of list) {
       // A `for`'s INIT runs ONCE, ahead of the condition and outside the loop; its cond, inc and
@@ -208,9 +221,11 @@ export interface MergePair {
  *  earlier one — and a back edge returns only to the head of its OWN loop, whose body is one
  *  contiguous preorder range. So the reordering can reach a PAIR only when some loop holds a
  *  mention of both locals: there the survivor's write can be followed, on the next iteration, by
- *  the absorbed local's read. Where no loop holds both — two sibling loops, or one local living
- *  before the loop the other lives in — no back edge connects the two ranges and preorder IS
- *  execution order. The ancestor chain is what the span records, not the innermost loop: an outer
+ *  the absorbed local's read. The one other back edge L3 holds is a case-label `goto` aimed at an
+ *  arm laid out above it, which returns into its own switch's range the same way, so `spans`
+ *  records such a switch as a loop and this rule covers it. Where no loop holds both — two sibling
+ *  loops, or one local living before the loop the other lives in — no back edge connects the two
+ *  ranges and preorder IS execution order. The ancestor chain is what the span records, not the innermost loop: an outer
  *  loop re-runs an inner one's statements, so it can reorder a pair that no inner loop shares.
  *
  *  `first-is-write` AND `const-fed` ARE INDEPENDENT, and neither masks the other: a survivor whose
@@ -332,8 +347,9 @@ export interface ArmPair {
   b: string;
   /** the confining branch has a loop ancestor, so it can run more than once */
   ifInLoop: boolean;
-  /** control can run from one of the two arms INTO the other — `switch` fall-through, the one
-   *  way two arms of a branch land on a single path. Always false for an `if`. */
+  /** control can run from one of the two arms INTO the other — `switch` fall-through or a
+   *  case-label `goto`, the two ways two arms of a branch land on a single path. Always false for
+   *  an `if`. */
   armsJoined: boolean;
   sameType: boolean;
   /** either local is object-volatile or carries a pointee-volatile qualifier (see MergePair) */
@@ -498,9 +514,10 @@ function mentionIndex(): {
  *  `switch` are one rule here rather than two walkers.
  *
  *  An `if` has exactly two arms and no way to reach one from the other. A `switch`'s arms are its
- *  `case` bodies, and FALL-THROUGH is the one way two of them land on a single path: arm `i` runs
- *  into arm `j` exactly when every arm from `i` up to `j` falls through, so the reach is the
- *  TRANSITIVE chain and not merely the adjacent pair.
+ *  `case` bodies, and two of them land on a single path where one runs on into the other: by
+ *  FALL-THROUGH, or by the case-label `goto` that ends an arm (l3/ast.ts), which lands where a
+ *  fall-through into its target would. The reach is the TRANSITIVE chain of both and not merely
+ *  the adjacent pair.
  *
  *  ITS REACH, MEASURED, because a soundness argument with no corpus witness should say so. Counted
  *  2026-09-19 with a throwaway counter in this walk, over `pnpm bench sweep --fan --map-modes
@@ -522,10 +539,21 @@ const branchArms = (st: Stmt): { arms: Stmt[][]; joined: (i: number, j: number)
     return { arms: [st.then, st.else], joined: () => false };
   }
   if (st.k === 'switch') {
-    const { cases } = st;
+    // Arm `i` runs on into the arms `switchArmSuccessors` chains it to, by falling through or by the
+    // `goto` that ends it (l3/ast.ts) — two arms on one path either way — so `reach[i]` is that
+    // chain, the `default` included as a node (a case falling into it and jumping out of it puts
+    // both on the path), though never offered as an arm itself.
+    const next = switchArmSuccessors(st);
+    const reach = next.map((_, i) => {
+      const seen = new Set<number>();
+      for (let at = next[i]; at !== undefined && !seen.has(at); at = next[at]) {
+        seen.add(at);
+      }
+      return seen;
+    });
     return {
-      arms: cases.map((c) => c.body),
-      joined: (i, j) => cases.slice(Math.min(i, j), Math.max(i, j)).every((c) => c.fallsThrough),
+      arms: st.cases.map((c) => c.body),
+      joined: (i, j) => reach[i].has(j) || reach[j].has(i),
     };
   }
   return null;