@asmlift/core 0.9.0 → 0.10.0

package/src/rank-variations.ts

@@ -27,7 +27,7 @@ import {
 import type { Gate } from './l3/gates';
 import type { HoistPlacement } from './l3/hoist';
 import { initFirstGuards } from './l3/initfirst';
-import { narrowDeclarations, narrowReadDeclarations } from './l3/narrowdecl';
+import { narrowDeclarations, narrowLoadDeclarations, narrowReadDeclarations } from './l3/narrowdecl';
 import { pollGuards, pollReads } from './l3/pollguard';
 import { unmergeJoins } from './l3/unmerge';
 // TYPE-ONLY, and deliberately: the structure-variation table types its `options` as
@@ -71,7 +71,7 @@ export interface StructureVariation {
     | 'derivedHome'
     | 'mergeHome'
     | 'escapeHome'
-    | 'unsCmp'
+    | 'signedCmp'
     | 'freshMerge'
     | 'copyDefPos'
     | 'siteSense';
@@ -225,17 +225,22 @@ export const STRUCTURE_VARIATIONS: readonly StructureVariation[] = [
     perLiftGate: hasEscapingExtension,
     strip: true,
   },
-  // `/uns-cmp` — spell unsigned compares unsigned (structure.ts unsignedCompareSpelling): an
-  // icmp_u* operand takes a (u32) cast where the rendered operands do not guarantee the
-  // unsignedness, and a mixed-claimant declaration reconciles to u32 when nothing under the
-  // name needs signed. Which side the source spelled is genuinely ambiguous: a signed spelling
-  // that byte-matched was PROVED non-negative by the compiler (only then does it emit the
-  // unsigned branch from a signed compare), and emission's provable set is smaller than the
-  // compiler's. Gated on the function having an unsigned compare at all.
+  // `/signed-cmp` — spell an unsigned compare SIGNED (structure.ts unsignedCompareSpelling OFF): no
+  // `(u32)` cast at an icmp_u* and no u32 reconciliation of a mixed-claimant declaration. The
+  // default is the one spelling value-faithful without a proof; this one is a real source where the
+  // compiler PROVED both sides non-negative (only then does it emit the unsigned branch from a
+  // signed compare), which emission cannot always repeat. Where the proof does not hold it is a
+  // different program, so rank.ts judges every emitted tree (`signedOverUnsignedCompare`) and makes
+  // a signed rendering `Candidate.matchOnly`, whichever setting or respell spelled it. A tie or a
+  // better nonmatch score is no evidence for it (`synthetic:selloop:gcc2.7.2kmc`).
+  // KNOWN GAP, in the safe direction: the judgment reads the tree's declarations, and globals are
+  // not among them, so a compare that renders unsigned only through a `void *` global the backend
+  // declares (ptrcell.test.ts KR1, `g >= gLimit`) is still withheld on a nonmatch.
+  // Gated on the function having an unsigned compare at all.
   {
-    flag: 'unsCmp',
-    name: 'uns-cmp',
-    options: (on) => ({ unsignedCompareSpelling: on }),
+    flag: 'signedCmp',
+    name: 'signed-cmp',
+    options: (on) => ({ unsignedCompareSpelling: !on }),
     sharedGate: (sharedLift) => sharedLift.blocks.some((b) => b.ops.some((op) => op.opcode.startsWith('icmp_u'))),
     strip: true,
   },
@@ -373,24 +378,31 @@ export const STRUCTURE_VARIATIONS: readonly StructureVariation[] = [
   },
 ];
 
-/** The STACKED variations (sanctioned in the POLICY note at rank.ts's respell site): each entry is
- *  a statement-order/shape or declaration-width respell variation orthogonal to every respell
- *  variation outside this table, derived onto every source. Two members need not commute
- *  (`/narrow-decl` and `/narrow-read` compete for one cast), and table order then decides which one
- *  takes it in the all-together candidate. Each fires alone, plus
- *  all of them together in table order — not the full subset lattice; the pairs question is
- *  settled by applyStacked' skip-on-decline below, and a row demanding a true EXCLUSION pair —
- *  every member fires, the match needs a strict subset of them — is what would earn the lattice.
- *  So a member appended here also changes the all-together candidate wherever it fires beside two
- *  or more of the others. */
-export const STACKED_VARIATIONS: { name: VariationName; apply: (sfn: SFn) => SFn | null }[] = [
+/** The statement-order/shape members. */
+const STACKED_SHAPES: { name: VariationName; apply: (sfn: SFn) => SFn | null }[] = [
   { name: 'initfirst', apply: initFirstGuards },
   { name: 'pollguard', apply: pollGuards },
   { name: 'pollread', apply: pollReads },
+];
+
+/** The declaration-width members: one dimension, the width each kind of local is declared at
+ *  (l3/narrowdecl.ts). A function holding a cast-written local,
+ *  load-written locals and call-result locals may need any combination of the three kinds narrow
+ *  while all three fire (the matching suite compiles all eight), so every subset is offered. */
+const STACKED_WIDTHS: { name: VariationName; apply: (sfn: SFn) => SFn | null }[] = [
   { name: 'narrow-decl', apply: narrowDeclarations },
+  { name: 'narrow-load', apply: narrowLoadDeclarations },
   { name: 'narrow-read', apply: narrowReadDeclarations },
 ];
 
+/** The STACKED variations (sanctioned in the POLICY note at rank.ts's respell site): each entry is
+ *  a statement-order/shape or declaration-width respell variation orthogonal to every respell
+ *  variation outside this table, derived onto every source. Two members need not commute
+ *  (`/narrow-decl` and `/narrow-read` compete for one cast, `/narrow-load` and `/narrow-read` for
+ *  one local), and table order then decides which one takes it in a candidate holding both. Which
+ *  of them a candidate applies is STACKED_SUBSETS. */
+export const STACKED_VARIATIONS = [...STACKED_SHAPES, ...STACKED_WIDTHS];
+
 /** The PRE-RESPELL variations (sanctioned in the POLICY note at rank.ts's respell site): a tree
  *  rewrite applied BEFORE the respell set, so the whole set derives from its output instead of
  *  composing onto it. Same record type as STACKED_VARIATIONS above, and deliberately so — the only difference is
@@ -458,17 +470,47 @@ export const STACKED_VARIATIONS: { name: VariationName; apply: (sfn: SFn) => SFn
  *  method are in `apps/benchmark/dataset/synthetic.ts`'s `/unmerge` block. */
 export const PRE_RESPELL_VARIATIONS: typeof STACKED_VARIATIONS = [{ name: 'unmerge', apply: unmergeJoins }];
 
-export const STACKED_SUBSETS: (typeof STACKED_VARIATIONS)[number][][] = [
-  ...STACKED_VARIATIONS.map((x) => [x]),
-  ...(STACKED_VARIATIONS.length > 1 ? [STACKED_VARIATIONS] : []),
-];
+/** Every subset of `xs`, the empty one first, each in `xs`' order. */
+const subsets = <X>(xs: readonly X[]): X[][] =>
+  xs.reduce<X[][]>((acc, x) => [...acc, ...acc.map((s) => [...s, x])], [[]]);
+
+/** The stacked members a candidate applies: the table's two dimensions crossed, a shape choice
+ *  (none, each shape alone, or every shape) by a width choice (any subset of the widths, none
+ *  included), the shapes first. A product, because a function may need a shape AND a strict subset
+ *  of the widths that fire: `initfirst` beside a narrow cast-written local and wide load-written
+ *  ones (the matching suite compiles that pair both ways). The shapes are not a lattice of their own:
+ *  applyStacked's skip-on-decline makes "every shape" each pair of them wherever the third declines,
+ *  and a row demanding a strict subset of the shapes while all fire is what would earn one. Fewest
+ *  members first, so where everything else ties the smaller set is enumerated first and wins. */
+export const STACKED_SUBSETS: (typeof STACKED_VARIATIONS)[number][][] = subsets(STACKED_WIDTHS)
+  .flatMap((widths) =>
+    [[], ...STACKED_SHAPES.map((x) => [x]), ...(STACKED_SHAPES.length > 1 ? [STACKED_SHAPES] : [])].map((shapes) => [
+      ...shapes,
+      ...widths,
+    ]),
+  )
+  .filter((subset) => subset.length > 0)
+  .sort((a, b) => a.length - b.length);
+
+/** A stacked member that threw, named by the members that fired before it and then itself: the
+ *  step that threw, which every subset reaching it shares. Reported under that name rather than
+ *  the whole subset's, so a consumer deduping on the step prints one broken member once and not
+ *  once per subset holding it. */
+export class StackedMemberThrew extends Error {
+  constructor(
+    readonly variations: readonly VariationName[],
+    cause: unknown,
+  ) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+  }
+}
 
 /** The subset applied in table order, SKIP-ON-DECLINE: a member that declines contributes
  *  nothing rather than killing the combination — the all-shapes candidate is "everything that
  *  fires", so a pair is reachable whenever the third declines. The variations are the members that
- *  actually FIRED, so they never name a variation that declined; a fired-set that
- *  duplicates a smaller subset emits identical source and the dedup collapses it. Null when
- *  nothing fired. */
+ *  actually FIRED, so they never name a variation that declined; a fired set that
+ *  duplicates a smaller subset's derives the same tree, which the caller emits once
+ *  (`firstFired`). Null when nothing fired. A member that throws throws StackedMemberThrew. */
 export const applyStacked = (
   subset: readonly (typeof STACKED_VARIATIONS)[number][],
   from: SFn,
@@ -476,7 +518,12 @@ export const applyStacked = (
   let cur = from;
   const fired: VariationName[] = [];
   for (const sp of subset) {
-    const r = sp.apply(cur);
+    let r: SFn | null;
+    try {
+      r = sp.apply(cur);
+    } catch (e) {
+      throw new StackedMemberThrew([...fired, sp.name], e);
+    }
     if (r) {
       cur = r;
       fired.push(sp.name);
@@ -485,6 +532,17 @@ export const applyStacked = (
   return fired.length > 0 ? { out: cur, variations: fired } : null;
 };
 
+/** Whether `fired` is a fired set not yet in `seen`, recording it. Two subsets that fire the same
+ *  members derive the same tree, so a caller emits only the first. */
+export const firstFired = (seen: Set<string>, fired: readonly VariationName[]): boolean => {
+  const key = fired.join('/');
+  if (seen.has(key)) {
+    return false;
+  }
+  seen.add(key);
+  return true;
+};
+
 /** The locals a variation added — a NAME diff rather than a positional slice, so a pass that ever
  *  reorders locals cannot silently empty the set. It is what scopes `/volatile` to the pointers
  *  the variation itself created (volatilePtrLocals' `only`), leaving the tree's own locals alone. */