@asmlift/core 0.4.0 → 0.6.0

package/src/raise/struct-arrays.ts

@@ -18,7 +18,9 @@
 // UNAMBIGUOUS here (the scaled operand is the index, read from the machine code) — the unscaled
 // `add(x, y)` byte form stays out of scope (genuinely ambiguous without types).
 import { Fn, Op, Value, defOpMap, mkOp } from '../ir/core';
+import { nextStructIndex } from '../ir/struct-names';
 import { IrType, StructField, T, scalarTypeForAccess } from '../ir/types';
+import { collectStructs } from './structs';
 
 interface Scaled {
   base: Value;
@@ -87,12 +89,22 @@ function withPadding(dataFields: StructField[], stride: number): StructField[] {
  *  rematerializes the same element address (several `add(base, i*stride)` ops for one logical
  *  array), and recovering them one-by-one would let the first claim the base and force its
  *  twins to decline — a mixed spelling that is worse than either pure form (found live on
- *  pokeemerald:GetGender, whose address is materialized twice). A base whose element pointers
+ *  pokeemerald:GetGenderFromSpeciesAndPersonality, whose address is materialized twice). A base
+ *  whose element pointers
  *  disagree on stride declines entirely: two strides over one base is a reinterpreted view or
  *  a 2D layout, genuinely ambiguous — decline over guess. */
 export function recognizeStructArrays(fn: Fn): number {
   const defs = defOpMap(fn);
   let count = 0;
+  // The NAME index is not the recognition count: `count` is this function's return value — how
+  // many groups it recognized — and seeding it would report the wrong number. The index starts
+  // past every `Elem<N>` the graph already mentions; over the corpus that scan returns 0 every
+  // time, because this pass runs once per function and nothing else mints the prefix, and
+  // ir/struct-names.ts states why the computed 0 is kept over the assumed one.
+  let name = nextStructIndex(
+    [...collectStructs(fn)].map((s) => s.name),
+    'Elem',
+  );
 
   // group candidate element pointers by base, tracking each add's own index and stride
   const byBase = new Map<Value, { add: Op; index: Value; stride: number }[]>();
@@ -221,7 +233,7 @@ export function recognizeStructArrays(fn: Fn): number {
       type: scalarTypeForAccess(width, loadSigned ?? width === 4),
       name: `field_${off}`,
     }));
-    const elemStruct = T.struct(`Elem${count}`, withPadding(dataFields, stride), stride);
+    const elemStruct = T.struct(`Elem${name++}`, withPadding(dataFields, stride), stride);
     base.type = T.ptr(elemStruct);
 
     // Rewrite each field load/store into an aload/astore carrying base, ITS elem's index,
@@ -241,7 +253,13 @@ export function recognizeStructArrays(fn: Fn): number {
           bb.ops[i] = mkOp('aload', {
             operands: [base, index],
             results: [op.results[0]],
-            attrs: { elemSize: stride, signed: op.attrs.signed as boolean, fieldOff: op.attrs.off as number },
+            // listOrder rides along: an ldmia-expanded load keeps its stream-order caveat as an aload
+            attrs: {
+              elemSize: stride,
+              signed: op.attrs.signed as boolean,
+              fieldOff: op.attrs.off as number,
+              ...(op.attrs.listOrder === true && { listOrder: true }),
+            },
           });
         } else if (op.opcode === 'store') {
           bb.ops[i] = mkOp('astore', {

package/src/raise/structs.ts

@@ -22,8 +22,22 @@
 //   base @ {off8 w4}           -> array  (single aligned access — no struct evidence)
 //   base @ aload(index)        -> array  (variable index — untouched)
 //
-// This recovery is BYTE-NEUTRAL — `->field_N` and `[idx]` compile identically, so it is a
-// representation upgrade driven by access evidence, not a scored lever. GAPS between accessed
+// This recovery is USUALLY BYTE-NEUTRAL — `->field_N` and `[idx]` mostly compile identically, so it
+// is a representation upgrade driven by access evidence rather than a scored lever. TWO
+// MEASUREMENTS SAY "USUALLY" IS THE RIGHT WORD, and both were made on agbcc against a real target
+// object, each pair differing in ONE token:
+//   • THE SPELLING. `synthetic:dmanest`'s reference compiles from `((struct Elem0 *)K)[a1].field_4`
+//     to a byte-exact match and from `((s32 *)((a1 << 3) + K))[1]` to a 2-point diff — a
+//     COMPONENT_REF keeps the offset in the load displacement, an index folds it into the pool
+//     literal. The row's own dataset entry carries the reproduction.
+//   • THE FIELD TYPE, which this file assigns from the ACCESS WIDTH alone. A word field declared
+//     `void *` rather than `s32` changes agbcc's alias set and lets a loop-invariant load leave the
+//     loop: `synthetic:dmaptrsrc` matches with the pointer declaration and diffs by 35 without it
+//     (its own fan: `/vol-store/unreduce/ptr-field` 0, `/vol-store/unreduce` 35).
+//     That is what `l3/ptrfield.ts` offers as a differ-ranked lever.
+// So the neutrality claim is CONDITIONAL, and nothing here says on what. Until it does, read it as
+// "no candidate is enumerated for this axis", not as "the differ could not referee one" — the
+// second reading is the one both measurements above falsify. GAPS between accessed
 // offsets (unaccessed leading/interior fields) are filled with `u8[N]` PAD fields so the declared
 // struct reproduces the observed offsets byte-for-byte and is self-describing (the same
 // discipline raise/struct-arrays.ts withPadding uses). Each accessed field must still be
@@ -31,6 +45,7 @@
 // at an offset natural C alignment could not place it at) is rejected LOUD, as is an
 // overlap/union.
 import { Fn, Op, Value } from '../ir/core';
+import { nextStructIndex } from '../ir/struct-names';
 import { IrType, StructField, T, scalarTypeForAccess } from '../ir/types';
 import type { StructType } from '../l3/ast';
 import { RaiseUnsupportedError } from './errors';
@@ -178,6 +193,21 @@ export function recognizeStructs(fn: Fn): number {
     }
   }
 
+  // Which values are the address of a NAMED global (`gaddr`)? Consulted only when synthesis
+  // DECLINES: see the catch below.
+  const namedGlobal = new Set<Value>();
+  for (const b of fn.blocks) {
+    for (const op of b.ops as Op[]) {
+      if (op.opcode === 'gaddr') {
+        namedGlobal.add(op.results[0]);
+      }
+    }
+  }
+
+  // The NAME counter is seeded from the names already in the graph, not from this pass's own
+  // success count: raise/memberarrays.ts runs first and mints `Struct<N>` types of its own, and two
+  // different layouts under one name would leave `collectStructs` declaring only one of them.
+  let name = firstFreeStructIndex(fn);
   let count = 0;
   for (const base of order) {
     if (arrayBases.has(base)) {
@@ -186,16 +216,44 @@ export function recognizeStructs(fn: Fn): number {
     if (base.type.kind !== 'unknown') {
       continue;
     } // already typed (not a bare recovery target)
+
     const accesses = accessesOf.get(base)!;
     if (isArray(accesses)) {
       continue;
     } // uniform stride / single aligned access → array
-    base.type = T.ptr(buildStruct(`Struct${count}`, accesses));
+    try {
+      base.type = T.ptr(buildStruct(`Struct${name}`, accesses));
+    } catch (e) {
+      // A NAMED global whose accesses synthesis cannot reconcile is not a reason to decline the
+      // function: its declaration belongs to the project's own headers, and its constant-offset
+      // accesses render at L3 through the symbol context (member spelling when the map knows the
+      // layout, the honest cast spelling when it does not). The inhabitant is agbcc FUSING two
+      // adjacent u8 compares into one ldrh — `s.level == 8 && s.world == 6` reads offset 12 at
+      // widths 1 AND 2, which is not a union, just two spellings of declared bytes. An ANONYMOUS
+      // base (a loaded pointer, a parameter) has no other source of truth, so for it the decline
+      // stands exactly as before — this catch narrows nothing for the shapes that already worked,
+      // because a base synthesis succeeds on takes the same path it always took.
+      if (e instanceof RaiseUnsupportedError && namedGlobal.has(base)) {
+        continue;
+      }
+      throw e;
+    }
+    name++;
     count++;
   }
   return count;
 }
 
+/** The next `Struct<N>` index past every one this function's graph already uses — the shared name
+ *  allocator for the two passes that synthesize a struct pointee. The scan itself is
+ *  `ir/struct-names.ts`, which the three struct minters share; this names the prefix. */
+export function firstFreeStructIndex(fn: Fn): number {
+  return nextStructIndex(
+    [...collectStructs(fn)].map((s) => s.name),
+    'Struct',
+  );
+}
+
 /** The distinct struct types this function's L2 GRAPH mentions (unwrapping struct pointers on every
  *  value), deduped by name and sorted, for the backend to declare above the function.
  *