@asmlift/core 0.8.0 → 0.9.0

package/src/pipeline.ts

@@ -6,6 +6,7 @@ import {
   assertDerefsTyped,
   assertEffectsPreserved,
   assertLocalsWritten,
+  assertPostIncrUnshared,
   assertResolved,
   assertTypesRecovered,
 } from './contracts';
@@ -23,10 +24,12 @@ import { eliminateDeadStores } from './l3/dce';
 import { mergeCommonTails } from './l3/tailmerge';
 import { dropUnspelledReturns } from './l3/tailret';
 import { DEFAULT_IDIOM_PATTERNS, RewritePattern, applyPattern, dce, patternApplies } from './pattern/engine';
-import { type FnProto, type Prototypes, prototypesFromSymbols } from './proto';
+import { type FnProto, type Prototypes, declaresVoidReturn, prototypesFromSymbols } from './proto';
+import { stampDeclaredVolatileUnder } from './raise/declared-volatile';
 import { RaiseUnsupportedError } from './raise/errors';
 import { assumedShapes, inferGlobalArrays, orderLicensedGlobals } from './raise/globalshape';
 import { foldEmptyLatches } from './raise/latch';
+import { OFFSET_NAME_PASS } from './raise/offsetnames';
 import { type PreRecoveryOptions, type PreRecoveryPass, runPreRecovery } from './raise/pre-recovery';
 import { recoverTypes } from './raise/recover';
 import { sinkReturns } from './raise/retsink';
@@ -109,6 +112,14 @@ export interface DecompileResult {
    *  bare, and every name the caller's own map described (raise/globalshape.ts `assumedShapes`
    *  computes that narrowing and names the corpus row behind each half). */
   assumedSymbols: SymbolInfo[];
+  /** THE NAMES THIS SOURCE REACHED BY ARITHMETIC, not by the map alone (raise/offsetnames.ts).
+   *  A pool-loaded `gaddr` is the map answering about an address the machine code carries; a
+   *  walked one is asmlift computing `addr(base) + K` and asking about THAT — so the base's own
+   *  address in the map is load-bearing for a name the reader sees spelled bare. Sibling of
+   *  `assumedSymbols` and reported beside it (`main.ts`'s `[walked]` block, the trace's
+   *  `stage:offsetnames`), and it is also the only thing in a result that says a walk spelling
+   *  stopped being enumerable here. Empty on every run with no symbol map. */
+  walkedNames: string[];
 }
 
 export function decompile(
@@ -144,8 +155,7 @@ function runTower(
   // CALLEES (a function still in assembly has none), which is what makes this transferable.
   const prototypes = prototypesFromSymbols(opts.symbols, opts.prototypes ?? {});
   // (1) lift: ISA frontend (resolved by target) → L1 with block-argument SSA
-  const fn = frontendFor(target).lift(name, asm, target, prototypes, opts.asmData, opts.symbols);
-  verify(fn);
+  const fn = liftStamped(name, asm, target, prototypes, opts.asmData, opts.symbols);
   // Every dump carries the write-order record (ir/print.ts `PrintOptions`): it decides the
   // edge-copy order and the raising folds mutate it, so two dumps compare whole program states.
   const raw = print(fn, { writeOrder: true });
@@ -157,6 +167,18 @@ function runTower(
   // …and the ORDER half of the same reading, which reaches names the shape derivation refuses (a
   // struct element among them). Read off the same lifted fn, for the same reason.
   const orderLicensed = orderLicensedGlobals(fn, target);
+  // (1.6) …and the NAMES the map holds for the addresses this function's machine code built by
+  // arithmetic off a named one (raise/offsetnames.ts). After the two readings above, which are
+  // about the lift as the frontend emitted it; before everything below, so the whole raising
+  // tower sees a walked-to cell as the named global it is.
+  //
+  // The two readings therefore attribute a walked access to the base rather than to the name this
+  // pass gives it, and that costs nothing either way: a SHAPE is a declaration, so a name the map
+  // describes — which every base here is, or the pass could not have fired — is dropped from
+  // `inferredSymbols`, and the ORDER licence only enables a cast spelling that is byte-correct
+  // under any declaration. Measured: with this call moved ABOVE both readings, the three corpus
+  // rows the pass fires on keep their fan size, their winner and their score exactly.
+  const walkedNames = opts.symbols ? OFFSET_NAME_PASS.run(fn, opts.symbols, target.compilerBehaviors) : [];
 
   // (2) idiom fold: apply serializable patterns on the IR (the AI-improvement surface),
   // gated generically by the Target's capabilities (not an `arch ==` branch).
@@ -172,7 +194,7 @@ function runTower(
   // every unresolved value spelled as a loud ASMLIFT_ERROR marker (annotate).
   const mapSymbols = opts.symbols ? symbolsByName(opts.symbols) : undefined;
   const sfn = structureChecked(fn, {
-    ...structureOptionsFor(target, prototypes[name]?.returnsVoid ?? false),
+    ...structureOptionsFor(target, declaresVoidReturn(prototypes[name]), prototypes),
     // What the EMITTED LANGUAGE can say is a structuring input wherever two recoveries of one
     // shape are behaviourally identical and only one of them is printable (switch fall-through
     // vs plain if-nesting): recovery must not mint a tree this backend would refuse.
@@ -196,9 +218,28 @@ function runTower(
     // spell bare, and a name the caller's own map described, are both obligations this reader
     // does not have (raise/globalshape.ts `assumedShapes`).
     assumedSymbols: assumedShapes(inferredSymbols, sfn, mapSymbols),
+    walkedNames,
   };
 }
 
+/** Stage 1 — lift: the target's ISA frontend → L1, verified, with every read of an object
+ *  `symbols` declares volatile stamped `declared` (raise/declared-volatile.ts) before any pass asks
+ *  whether it may be deleted. Every entry path lifts through here, each lift under the map its
+ *  structuring will be handed. */
+export function liftStamped(
+  name: string,
+  asm: string,
+  target: TargetDescription,
+  prototypes: Prototypes,
+  asmData: AsmData | undefined,
+  symbols: SymbolMap | undefined,
+): Fn {
+  const fn = frontendFor(target).lift(name, asm, target, prototypes, asmData, symbols);
+  verify(fn);
+  stampDeclaredVolatileUnder(fn, symbols, target.compilerBehaviors);
+  return fn;
+}
+
 // ── the shared raising tower ────────────────────────────────────────────────────────────────
 // decompile(), decompileTraced (trace.ts), rank.ts's decompileRanked and the cli's
 // decompileWithReport + its score probe (report.ts) all raise a lifted fn through the SAME stage
@@ -314,7 +355,7 @@ export function raiseRecovered(
 /** Run `body`; if it declines, name the unmodelled instructions the function carries.
  *
  *  An `opaque` degrades its own value AND makes its block impure, so a shape recognizer refuses:
- *  `headerPure` rejects a header holding one, and the loop declines with "unrecovered back-edge …".
+ *  a loop none of whose recognizers takes it declines with "unrecovered back-edge …".
  *  True and useless — the shape is fine, an instruction is missing — and the benchmark classifies
  *  declines by that text, so the round is filed as a loop-capability gap and the improvement loop
  *  builds the wrong thing.
@@ -331,20 +372,21 @@ function attributeOpaques<T>(fn: Fn, body: () => T): T {
       throw e;
     }
     const seen = reachableBlocks(fn);
-    const names = new Set<string>();
+    // THE REASONS, not the mnemonics: an `opaque` a recogniser left behind for a runtime helper it
+    // could not fold carries no mnemonic at all, and asking for one would attribute the decline to
+    // an instruction named `?`.
+    const reasons = new Set<string>();
     for (const b of seen) {
       for (const op of b.ops) {
         if (op.opcode === 'opaque') {
-          names.add(typeof op.attrs.mnemonic === 'string' ? op.attrs.mnemonic : '?');
+          reasons.add(gapReasonFor(op.attrs));
         }
       }
     }
-    if (!names.size || /unmodelled instruction/.test(e.message)) {
+    if (!reasons.size || /unmodelled instruction|no model for the runtime helper/.test(e.message)) {
       throw e;
     }
-    // Through `gapReasonFor`, so the classifier sees its canonical text — a hand-written spelling
-    // misses the mnemonic-anchored classes and every attributed decline lands in the generic bucket.
-    const list = [...names].sort().map(gapReasonFor).join(', ');
+    const list = [...reasons].sort().join(', ');
     throw new StructureError(`${e.message} — and the function carries ${list}, which is the more likely cause`);
   }
 }
@@ -382,11 +424,13 @@ export function structureChecked(
   assertResolved(raw);
   assertDerefsTyped(raw);
   assertLocalsWritten(raw);
+  assertPostIncrUnshared(raw);
   assertEffectsPreserved(fn, raw);
   // The hoist moves the deref cast from each `index` node onto the local's initializer, so
   // re-validate deref typing on the rewritten tree.
   const sfn = readabilityRewrites(raw);
   assertDerefsTyped(sfn);
+  assertPostIncrUnshared(sfn);
   // Re-checked after the readability rewrites for the same reason deref typing is: a pass that
   // merges arms or drops statements must not be able to lose or duplicate a call.
   assertEffectsPreserved(fn, sfn);
@@ -445,8 +489,9 @@ export function stubResult(name: string, asm: string, backend: LanguageBackend,
     ir: { raw: '', folded: '', recovered: '' },
     patternHits: 0,
     diagnostics: [{ stage, reason: msg }],
-    // A stub spells no global, so it assumes nothing about one.
+    // A stub spells no global, so it assumes nothing about one and walked to none.
     assumedSymbols: [],
+    walkedNames: [],
   };
 }