@asmlift/core 0.10.0 → 0.11.0

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;

package/src/l3/constinit.ts

@@ -338,17 +338,45 @@ export function constantImageRefusal(sfn: SFn): { image: string; refused: string
  *  signedness keeps its cast, which is the element type it spells. */
 function asElement(e: Expr, by: ReadonlyMap<string, Fold>): Expr {
   const inner = mapExprChildren(e, (c) => asElement(c, by));
-  if (inner.k !== 'index' || (inner.lead?.length ?? 0) > 0 || inner.baseElem !== undefined) {
+  // …and a read of the element's BYTES at the other signedness, converted to the element's own
+  // type, IS the element: `(s8)((u8 *)a)[i]` is `a[i]` on `s8 a[16]`. agbcc has no `ldrsb` with an
+  // immediate offset, so a signed byte read through the frame base is `ldrb` and `lsl #24; asr #24`,
+  // which the lift reads as the unsigned byte sign-extended; C extends the element itself the same
+  // way. Only a conversion to exactly the element type: a wider or a narrower one is another value.
+  // A DECLARED array's byte (a map global's, a proven frame part's) is read signed before this, by
+  // the structurer (structure.ts `declaredExtendedRead`); the type this pass gives a local exists
+  // only here, so for those the identity is applied here.
+  if (inner.k === 'cast' && inner.to.kind === 'int' && inner.volatile !== true && inner.e.k === 'index') {
+    const read = inner.e;
+    const elem = elementOf(read, by);
+    if (elem !== undefined && elem.width === inner.to.width && elem.signed === inner.to.signed) {
+      return asElement({ ...read, signed: elem.signed }, by);
+    }
+  }
+  if (inner.k !== 'index') {
     return inner;
   }
+  const elem = elementOf(inner, by);
+  if (elem === undefined || elem.signed !== inner.signed) {
+    return inner;
+  }
+  return { ...inner, base: { k: 'var', name: wholeObject(inner.base)! }, subscript: true };
+}
+
+/** The element type of the folded local `read` reads one element of — at the element's width,
+ *  whatever its signedness — or undefined for any other access. */
+function elementOf(
+  read: Extract<Expr, { k: 'index' }>,
+  by: ReadonlyMap<string, Fold>,
+): Extract<IrType, { kind: 'int' }> | undefined {
+  if ((read.lead?.length ?? 0) > 0 || read.baseElem !== undefined) {
+    return undefined;
+  }
   // the object the base names whole, as the fold's own census of element accesses reads it (`uses`)
-  const name = wholeObject(inner.base);
+  const name = wholeObject(read.base);
   const fold = name === null ? undefined : by.get(name);
   const elem = fold?.type.kind === 'array' ? fold.type.elem : undefined;
-  if (elem?.kind !== 'int' || elem.width !== inner.width * 8 || elem.signed !== inner.signed) {
-    return inner;
-  }
-  return { ...inner, base: { k: 'var', name: name! }, subscript: true };
+  return elem?.kind === 'int' && elem.width === read.width * 8 ? elem : undefined;
 }
 
 /** `sfn` with every anonymous image folded into the initializer of each local its copies fill,

package/src/l3/dce.ts

@@ -25,7 +25,7 @@
 // unresolved `?` value trips the contract first and never reaches DCE; `mustKeep` treating `?` as
 // keep is defense-in-depth for any future caller that skips that check.
 import type { Expr, SFn, Stmt } from './ast';
-import { exprChildren, keepsHelperRel, negateCond, stmtChildren, stmtExprs } from './ast';
+import { caseEndGotoLeaves, exprChildren, keepsHelperRel, negateCond, stmtChildren, stmtExprs } from './ast';
 
 /** Accumulate every LOCAL-eligible `var` name read anywhere in `e` (recurses all sub-exprs). An
  *  `addr` name counts too: taking a local's address makes every store to it observable through the
@@ -106,6 +106,24 @@ function allAddrNamesInto(stmts: Stmt[], out: Set<string>): void {
 interface JumpLive {
   brk: ReadonlySet<string>;
   cont?: ReadonlySet<string>; // absent in a switch no loop encloses
+  /** live at a case label of the innermost switch: what its `goto` (l3/ast.ts) lands on — absent
+   *  where no switch encloses the statement, or a loop stands between it and the switch */
+  caseLabel?: ReadonlySet<string>;
+  /** live at the end of the innermost switch arm around the statement, loops between included: what
+   *  a case-end `goto` lands on — absent where no switch encloses it */
+  caseEnd?: ReadonlySet<string>;
+}
+
+/** The conservative set live throughout a loop: what is live after it and every read in it, and,
+ *  where a case-end `goto` in its body leaves it, what is live at the arm's end that goto lands on —
+ *  a later iteration may take it. */
+function loopLiveOf(s: Stmt & { body: Stmt[] }, live: ReadonlySet<string>, jumps: JumpLive | null): Set<string> {
+  const loopLive = new Set(live);
+  allReadsInto([s], loopLive);
+  if (jumps?.caseEnd && caseEndGotoLeaves(s.body)) {
+    jumps.caseEnd.forEach((n) => loopLive.add(n));
+  }
+  return loopLive;
 }
 
 /** Backward live-variable walk over one block. `liveOut` is the set of locals live on exit;
@@ -165,6 +183,26 @@ function dceBlock(
         rev.push(s);
         break;
       }
+      // The jump lands on the `break;` that ends its arm (l3/ast.ts, contracts.ts
+      // `assertCaseGotosNarrow`), whose every read the switch below already counts live.
+      case 'caseEndGoto': {
+        if (!jumps?.caseEnd) {
+          throw new Error('dce: a case-end goto outside a switch arm');
+        }
+        setLive(new Set(jumps.caseEnd));
+        rev.push(s);
+        break;
+      }
+      case 'goto': {
+        // The jump lands on a case label of the switch it sits in (l3/ast.ts, contracts.ts
+        // `assertCaseGotosNarrow`), whose every read the switch below already counts live.
+        if (!jumps?.caseLabel) {
+          throw new Error('dce: a goto outside the switch whose case it names');
+        }
+        setLive(new Set(jumps.caseLabel));
+        rev.push(s);
+        break;
+      }
       case 'break':
       case 'continue': {
         // A mid-body `if (c) { v = x; break; }` carries the loop's exit value in `v`, while the
@@ -207,9 +245,12 @@ function dceBlock(
       case 'dowhile': {
         // Conservative: any local read anywhere in the loop is live throughout it, so a
         // loop-carried store is never cut. Body DCE removes only what is dead on EVERY path.
-        const loopLive = new Set(live);
-        allReadsInto([s], loopLive);
-        const b = dceBlock(s.body, loopLive, locals, volatiles, { brk: loopLive, cont: loopLive });
+        const loopLive = loopLiveOf(s, live, jumps);
+        const b = dceBlock(s.body, loopLive, locals, volatiles, {
+          brk: loopLive,
+          cont: loopLive,
+          caseEnd: jumps?.caseEnd,
+        });
         const nlive = new Set(loopLive);
         for (const r of b.liveIn) {
           nlive.add(r);
@@ -219,9 +260,12 @@ function dceBlock(
         break;
       }
       case 'for': {
-        const loopLive = new Set(live);
-        allReadsInto([s], loopLive);
-        const b = dceBlock(s.body, loopLive, locals, volatiles, { brk: loopLive, cont: loopLive });
+        const loopLive = loopLiveOf(s, live, jumps);
+        const b = dceBlock(s.body, loopLive, locals, volatiles, {
+          brk: loopLive,
+          cont: loopLive,
+          caseEnd: jumps?.caseEnd,
+        });
         const nlive = new Set(loopLive);
         for (const r of b.liveIn) {
           nlive.add(r);
@@ -235,7 +279,7 @@ function dceBlock(
         // read anywhere in the switch as live throughout — no case-body store is ever cut.
         const swLive = new Set(live);
         allReadsInto([s], swLive);
-        const inSwitch: JumpLive = { brk: swLive, cont: jumps?.cont };
+        const inSwitch: JumpLive = { brk: swLive, cont: jumps?.cont, caseLabel: swLive, caseEnd: swLive };
         const cases = s.cases.map((c) => ({ ...c, body: dceBlock(c.body, swLive, locals, volatiles, inSwitch).out }));
         const def = s.default ? dceBlock(s.default, swLive, locals, volatiles, inSwitch).out : s.default;
         const nlive = new Set(swLive);

package/src/l3/ptrcell.ts

@@ -227,6 +227,8 @@ function mapIntegerSlots(sfn: SFn, cells: ReadonlySet<string>, rules: SlotRules)
         };
       case 'break':
       case 'continue':
+      case 'goto':
+      case 'caseEndGoto':
         return s;
     }
   };

package/src/l3/regspell.ts

@@ -101,6 +101,8 @@ function renameInStmt(s: Stmt, from: string, to: string): Stmt {
       };
     case 'break':
     case 'continue':
+    case 'goto':
+    case 'caseEndGoto':
       return s;
   }
 }

package/src/l3/reindex.ts

@@ -93,6 +93,8 @@ import {
   Expr,
   SFn,
   Stmt,
+  SwitchCase,
+  caseEndGotoLeaves,
   mapExprChildren,
   mapStmtExprs,
   mentionedName,
@@ -303,8 +305,13 @@ export const COUNTDOWN_GATES: readonly Gate<CountdownCtx>[] = [
 
 /** A `break`/`continue` that would target the ENCLOSING loop: found at if/switch depth, but not
  *  inside a nested loop (whose own exits target itself). A switch's own `break` (`ofSwitch`)
- *  leaves only its switch, and the loop's tail still runs after it, so it is not one. */
+ *  leaves only its switch, and the loop's tail still runs after it, so it is not one. A case-end
+ *  `goto` whose label lies outside `stmts` leaves every loop it sits in, at any depth. */
 function hasLoopExit(stmts: Stmt[]): boolean {
+  return caseEndGotoLeaves(stmts) || hasShallowLoopExit(stmts);
+}
+
+function hasShallowLoopExit(stmts: Stmt[]): boolean {
   return stmts.some((s) => {
     switch (s.k) {
       case 'break':
@@ -312,9 +319,9 @@ function hasLoopExit(stmts: Stmt[]): boolean {
       case 'continue':
         return true;
       case 'if':
-        return hasLoopExit(s.then) || hasLoopExit(s.else);
+        return hasShallowLoopExit(s.then) || hasShallowLoopExit(s.else);
       case 'switch':
-        return s.cases.some((c) => hasLoopExit(c.body)) || hasLoopExit(s.default ?? []);
+        return s.cases.some((c) => hasShallowLoopExit(c.body)) || hasShallowLoopExit(s.default ?? []);
       default:
         return false;
     }
@@ -502,12 +509,14 @@ function reindexStmt(s: Stmt, walk: WalkLoop, iv: string): Stmt | null {
       return {
         ...s,
         scrutinee,
-        cases: cases as { values: number[]; body: Stmt[]; fallsThrough: boolean }[],
+        cases: cases as SwitchCase[],
         default: dflt ?? undefined,
       };
     }
     case 'break':
     case 'continue':
+    case 'goto':
+    case 'caseEndGoto':
       return s;
   }
 }

package/src/l3/scopebase.ts

@@ -855,6 +855,8 @@ export function applyScopedBasePlan(sfn: SFn, { entries: plan, repoint, compound
         };
       case 'break':
       case 'continue':
+      case 'goto':
+      case 'caseEndGoto':
         return s;
     }
   };

package/src/l3/tailmerge.ts

@@ -118,6 +118,8 @@ function rewrite(s: Stmt): Stmt[] {
     case 'return':
     case 'break':
     case 'continue':
+    case 'goto':
+    case 'caseEndGoto':
       return [s];
   }
 }