@asmlift/core 0.5.0 → 0.6.0

package/src/proto.ts

@@ -1,15 +1,22 @@
-import type { SymbolMap } from './symbols';
+import type { SymbolMap, SymbolTypeFacts } from './symbols';
 
 // asmlift — function prototypes: the single carrier for the caller-supplied facts a
-// matching-decomp project reads from its headers (arg counts, void-ness). One `Prototypes`
-// map, keyed by symbol, is threaded through every entry point and resolved at the point of
-// use — a callee's `params` gives its call-site arity, a function's own entry gives its
-// `returnsVoid`. It also keeps the frontend seam honest: a frontend receives prototypes,
-// not a grab-bag of ISA-specific options.
+// matching-decomp project reads from its headers (arg counts, parameter widths, void-ness). One
+// `Prototypes` map, keyed by symbol, is threaded through every entry point and resolved at the
+// point of use — a callee's `params` gives its call-site arity, a function's own entry gives its
+// `returnsVoid` and the widths raise/paramwidth.ts checks against. It also keeps the frontend seam
+// honest: a frontend receives prototypes, not a grab-bag of ISA-specific options.
 
-/** One declared parameter, as its C type text (`"u8"`, `"s32"`, `"void *"`). asmlift consumes
- *  only the COUNT today (call-site arity), but a project's header extraction naturally produces
- *  the typed list, and keeping it lets a later pass pin an argument's width/signedness. */
+/** One declared parameter, as its C type text (`"u8"`, `"s32"`, `"void *"`, `"int"`). Two facts
+ *  are read off it: the list's LENGTH is the call-site arity (`protoArity`), and one entry's WIDTH
+ *  (`declaredWidth`) is what raise/paramwidth.ts checks its inference against.
+ *
+ *  A DECLARED WIDTH ONLY VETOES, never pins. Where the asm carries a prologue extension the
+ *  declaration contradicts, the declaration wins — it is a fact from the project's headers, where
+ *  the extension is an inference off an encoding two different C sources produce. Where the asm
+ *  carries no extension, this list is NOT consulted: pinning there would type every parameter of
+ *  every row from the declaration, and a declared `u32` kills rank.ts's signed arm before the
+ *  differ ever sees it. That half is an axis question and is not answered here. */
 export type ParamType = string;
 
 /** What the headers know about one function. All fields optional: a partial table (only
@@ -17,10 +24,26 @@ export type ParamType = string;
 export interface FnProto {
   /** declared parameters — either a bare arity COUNT or the typed parameter list a header
    *  extraction produces (`["u8", "s32"]`). BOTH forms yield the call-site arity via
-   *  `protoArity`; omit to let the frontend fall back to its contiguous-arg-register heuristic. */
+   *  `protoArity`; only the typed form carries a width. Omit to let the frontend fall back to its
+   *  contiguous-arg-register heuristic. */
   params?: number | ParamType[];
-  /** the declared return type is `void`, so a trailing `bx lr` leaves a meaningless
-   *  return register that must not surface as a `return` value. */
+  /** The declared return type is `void`. Read for the function under decompilation, where a
+   *  trailing `bx lr` leaves a meaningless return register that must not surface as a `return`
+   *  value — and, since the out-parameter path landed, for a CALLEE, where it is the only thing
+   *  that tells an out-parameter frame from a hidden struct-return pointer.
+   *
+   *  THAT SECOND READER IS LOAD-BEARING AND THE FIELD IS UNCHECKED DATA, which is worth knowing
+   *  before authoring one. `validatePrototypes` type-checks the boolean and can check no more:
+   *  nothing in the assembly distinguishes the two frames, which is why the refusal exists. So a
+   *  callee wrongly declared `void` turns a loud decline into a compiling, plausible, wrong
+   *  program — measured on the shape the guard is for, `struct S4 mk(int); struct S4 s = mk(x);`
+   *  lifts as `mk(&sp0); return (u8)sp0;` when `mk` is declared `returnsVoid` — where a callee
+   *  wrongly declared NON-void, or left undeclared, only costs the lift. Under-declaring is the
+   *  safe direction and this project has already shipped one wrong entry (a dataset row declaring
+   *  `returnsVoid: true` for a function whose own reference returns `void *`).
+   *
+   *  Both readers see one field through two trust levels: caller-supplied on `--proto`, and
+   *  machine-derived from DWARF through `prototypesFromSymbols`. Neither is distinguished here. */
   returnsVoid?: boolean;
 }
 
@@ -43,10 +66,85 @@ export function protoArity(p: FnProto | undefined): number | undefined {
   return undefined;
 }
 
+/** Bit width per C89 base type on every target asmlift lifts (all ILP32). `long` is 32 here and
+ *  would not be on an LP64 host, so it is a target fact rather than a language one. */
+const BASE_WIDTHS: ReadonlyMap<string, number> = new Map([
+  ['char', 8],
+  ['short', 16],
+  ['short int', 16],
+  ['int', 32],
+  ['long', 32],
+  ['long int', 32],
+]);
+
+/** The bit width one declared parameter type spells, or `undefined` for a spelling this does not
+ *  read — a project typedef, a struct, a `float`. UNDEFINED IS "NO OPINION", never "wide": the one
+ *  consumer treats a width it can read as authority and a width it cannot as absence, so an
+ *  unrecognized spelling leaves the asm's own inference standing.
+ *
+ *  A pointer is register-wide whatever it points at, which is the fact the `*` test carries. */
+export function declaredWidth(t: ParamType): number | undefined {
+  const s = t
+    .replace(/\b(?:const|volatile)\b/g, ' ')
+    .trim()
+    .replace(/\s+/g, ' ');
+  if (s.endsWith('*')) {
+    return 32;
+  }
+  const own = /^([su])(8|16|32)$/.exec(s);
+  if (own) {
+    return Number(own[2]);
+  }
+  // `unsigned`/`signed` alone is `unsigned int`/`signed int`; the signedness itself is not a width.
+  const base = s
+    .replace(/\b(?:signed|unsigned)\b/g, ' ')
+    .trim()
+    .replace(/\s+/g, ' ');
+  return BASE_WIDTHS.get(base === '' && s !== '' ? 'int' : base);
+}
+
+/** Problems with a HAND-WRITTEN prototype table — empty when it is well formed.
+ *
+ *  `protoArity` above falls back to the arg-register heuristic on a `params` it cannot read, which
+ *  is right when `params` is omitted and silent when it is mistyped: `params: "2"` then decompiles
+ *  at a guessed arity, and a misspelled `returnsVoid` does nothing at all. Neither is visible in
+ *  the output, so a table that came from outside is checked before it reaches either. */
+export function validatePrototypes(value: unknown): string[] {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return ['must be an object mapping a symbol name to its prototype'];
+  }
+  const problems: string[] = [];
+  for (const [sym, proto] of Object.entries(value)) {
+    if (typeof proto !== 'object' || proto === null || Array.isArray(proto)) {
+      problems.push(`${sym}: must be an object, e.g. {"params": 2}`);
+      continue;
+    }
+    for (const key of Object.keys(proto)) {
+      if (key !== 'params' && key !== 'returnsVoid') {
+        problems.push(`${sym}: unknown key "${key}" (expected "params" or "returnsVoid")`);
+      }
+    }
+    const { params, returnsVoid } = proto as { params?: unknown; returnsVoid?: unknown };
+    if (params !== undefined) {
+      const countOk = typeof params === 'number' && Number.isInteger(params) && params >= 0;
+      const listOk = Array.isArray(params) && params.every((t) => typeof t === 'string');
+      if (!countOk && !listOk) {
+        problems.push(`${sym}: "params" must be a non-negative integer or a list of type strings`);
+      }
+    }
+    if (returnsVoid !== undefined && typeof returnsVoid !== 'boolean') {
+      problems.push(`${sym}: "returnsVoid" must be a boolean`);
+    }
+  }
+  return problems;
+}
+
 /** The C type spelling for one declared parameter/return, or null when the facts do not
  *  determine one. A pointer is `void *` — address-identical to any object pointer, and asmlift
- *  makes every stride explicit — so nothing is guessed about what it points at. */
-function typeSpelling(t: { size: number | null; signed: boolean | null; pointer?: boolean }): ParamType | null {
+ *  makes every stride explicit — so nothing is guessed about what it points at. A richer spelling
+ *  would also be INERT: `declaredWidth` answers 32 for every `*`, and a CALLEE's parameter types
+ *  are read for the list's length alone (test/param-pointee-axis.test.ts). */
+function typeSpelling(t: SymbolTypeFacts): ParamType | null {
   if (t.pointer) {
     return 'void *';
   }

package/src/raise/arrays.ts

@@ -61,7 +61,12 @@ export function recognizeArrays(fn: Fn): number {
         b.ops[i] = mkOp('aload', {
           operands: [m.base, m.index],
           results: [res],
-          attrs: { elemSize: op.attrs.width as number, signed: op.attrs.signed as boolean },
+          // listOrder rides along: an ldmia-expanded load keeps its stream-order caveat as an aload
+          attrs: {
+            elemSize: op.attrs.width as number,
+            signed: op.attrs.signed as boolean,
+            ...(op.attrs.listOrder === true && { listOrder: true }),
+          },
         });
         replaceAllUsesWith(fn, op.results[0], res);
         count++;

package/src/raise/divpow2.ts

@@ -41,7 +41,7 @@
 // the biased arm must be the negative one — the consistency check m2c's `49b5d87` also adds),
 // because every one of those is a way for a superficially similar diamond to mean something else.
 import { Block, Fn, Op, Value, defOpMap, mkOp, mkValue, predecessors, replaceAllUsesWith } from '../ir/core';
-import { HOIST_UNSAFE_OPS } from '../ir/opcodes';
+import { EFFECTFUL_OPS } from '../ir/opcodes';
 import { T } from '../ir/types';
 
 /** `shr_s v {imm=k}` → k, else null. */
@@ -110,7 +110,7 @@ export function recognizeDivPow2(fn: Fn): boolean {
           continue;
         }
         const bp = preds.get(bias) ?? [];
-        if (bp.length !== 1 || bias.ops.some((op) => HOIST_UNSAFE_OPS.has(op.opcode))) {
+        if (bp.length !== 1 || bias.ops.some((op) => EFFECTFUL_OPS.has(op.opcode))) {
           continue;
         }
         const h = bp[0];