@asmlift/core 0.5.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;
@@ -94,6 +96,15 @@ function withPadding(dataFields: StructField[], stride: number): StructField[] {
 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 }[]>();
@@ -222,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,
@@ -242,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';
@@ -189,6 +204,10 @@ export function recognizeStructs(fn: Fn): number {
     }
   }
 
+  // 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)) {
@@ -203,7 +222,7 @@ export function recognizeStructs(fn: Fn): number {
       continue;
     } // uniform stride / single aligned access → array
     try {
-      base.type = T.ptr(buildStruct(`Struct${count}`, accesses));
+      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
@@ -219,11 +238,22 @@ export function recognizeStructs(fn: Fn): number {
       }
       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.
  *