@asmlift/core 0.8.0 → 0.9.0

package/src/frontend/reloc-symbol.ts

@@ -12,10 +12,18 @@
 // be wrong in a way that reads as right. So the decision is made here, once, by the shape of the
 // name, and every refusing kind gets its own sentence naming what was seen.
 //
-// Consumed by frontend/ppc.ts, which refuses before it recovers. A kind is listed only when it
-// behaves differently: the decomp projects' generated labels (`lbl_1_bss_2464`, `fn_1_458`) are
-// ordinary identifiers that the project's own headers declare and its own sources spell, so they
-// are `plain` and get no entry of their own.
+// Consumed by frontend/ppc.ts, which refuses before it recovers, and by frontend/thumb.ts's
+// literal-pool reader. A function-scope static is the one kind neither refuses by name: the
+// function DEFINES it, so both read its definition out of the target (frontend/local-object.ts) and
+// the lift writes it in the body under the name `localStaticName` takes apart, refusing only where
+// the definition cannot be read. Thumb asks about that kind and the predefined names alone rather
+// than taking `unspellableReason`'s answer for every kind, because a pool word is not a relocation:
+// agbcc packs `.L` labels into pools, and this policy calls a leading dot `section-local` — an
+// offset into a section, not an object — which is false about a code label in the same file.
+//
+// A kind is listed only when it behaves differently: the decomp projects' generated labels
+// (`lbl_1_bss_2464`, `fn_1_458`) are ordinary identifiers that the project's own headers declare
+// and its own sources spell, so they are `plain` and get no entry of their own.
 //
 // THE SCOPE OF THIS POLICY IS THE NAME, AND ONLY ON A DATA RELOCATION.
 //  • Not the TYPE. A name this passes is still rendered at the width the asm implies, which is a
@@ -32,12 +40,31 @@
 
 /** What sort of name a relocation carries. Everything but `plain` is unspellable in C. */
 export type RelocSymbolKind =
-  'plain' | 'anon-pool' | 'section-local' | 'local-static' | 'cpp-vtable' | 'cpp-mangled' | 'not-an-identifier';
+  | 'plain'
+  | 'anon-pool'
+  | 'section-local'
+  | 'local-static'
+  | 'inline-local-static'
+  | 'predefined-identifier'
+  | 'cpp-vtable'
+  | 'cpp-mangled'
+  | 'not-an-identifier';
+
+/** `ident$N` (mwcc) or `ident.N` (gcc, and so agbcc): a static declared inside a function, whose
+ *  SOURCE name is `ident`. Anchored whole, one numeric suffix: see the ordering note in
+ *  {@link classifyRelocSymbol}. */
+const LOCAL_STATIC = /^([A-Za-z_][A-Za-z0-9_]*)[.$](\d+)$/;
 
-/** Classify a relocation's symbol by its spelling. Order matters: the shapes that ARE valid C
- *  identifiers (`__vt__…`, a mangled class-scoped name) or contain characters a C identifier may
- *  not (`@`, `.`, `$`) are each recognised before the general identifier test, so the catch-all
- *  below can be exactly "a name of no kind this policy knows, and not an identifier either". */
+/** The identifiers a compiler defines inside every function, whose objects it names like a static. */
+const PREDEFINED = new Set(['__func__', '__FUNCTION__', '__PRETTY_FUNCTION__']);
+
+/** Classify a relocation's symbol by its spelling. Order matters twice over. The shapes that ARE
+ *  valid C identifiers (`__vt__…`, a mangled class-scoped name) or contain characters a C
+ *  identifier may not (`@`, `.`, `$`) are each recognised before the general identifier test, so
+ *  the catch-all below can be exactly "a name of no kind this policy knows, and not an identifier
+ *  either". And among themselves, the tests that look at a PREFIX come before the one that looks
+ *  at a SUFFIX: a compiler is free to hang its static counter off a name of any other kind, and
+ *  the kind is what picks the refusal sentence. */
 export function classifyRelocSymbol(sym: string): RelocSymbolKind {
   if (sym.startsWith('@')) {
     return 'anon-pool'; // `@193` — mwcc's anonymous string/constant pool entries
@@ -45,12 +72,17 @@ export function classifyRelocSymbol(sym: string): RelocSymbolKind {
   if (sym.startsWith('.')) {
     return 'section-local'; // `...bss.0`, `.rodata` — an offset into a section
   }
-  if (sym.includes('$')) {
-    return 'local-static'; // `sprHideTbl$797` — a function-scope static plus mwcc's TU-wide counter
-  }
   if (sym.startsWith('__vt__')) {
     return 'cpp-vtable'; // `__vt__6System` — a compiler-emitted virtual table
   }
+  // mwcc names a static of an inlined HEADER function `<name>$localstatic<N>$<function>`
+  // (`_half$localstatic3$sqrtf`, `…$sqrtf__Ff` in C++; weak, in every Animal Crossing target that
+  // includes the libm header). The object belongs to the inline function's definition, not to the
+  // function referencing it, so it is its own kind, and asked before the class-scope marker: the
+  // trailing function name is the one part of the symbol that may carry a mangling.
+  if (/^[A-Za-z_]\w*\$localstatic\d+\$/.test(sym)) {
+    return 'inline-local-static';
+  }
   // mwcc mangles a class-scoped name as `<name>__<length><Class>` (`statbuff__9CmdStream`) or,
   // for a nested scope, `<name>__Q<depth><…>` (`__ct__Q26Action5ChildFv`). The marker is the `__`
   // followed by that LENGTH or `Q<depth>`, never a double underscore on its own: a rule that fired
@@ -66,6 +98,28 @@ export function classifyRelocSymbol(sym: string): RelocSymbolKind {
   if (/__(?:\d|Q\d)/.test(sym)) {
     return 'cpp-mangled';
   }
+  // A function-scope static plus the counter its compiler assigned: `sprHideTbl$797` (mwcc),
+  // `tide.3` / `zeroes.13` (gcc, and so agbcc). Both counters are TRANSLATION-UNIT-wide rather
+  // than per-function, which is why neither is reconstructible from the source: three functions in
+  // one TU, compiled by this project's agbcc, give `pa.3`, `pb.7`, `pc.11` and `pc2.12` — the
+  // number counts declarations across the whole unit and skips.
+  //
+  // LAST of the named kinds, and anchored to a WHOLE identifier plus ONE numeric suffix, because
+  // `[.$]\d+$` alone is a suffix test and every other kind here can wear that suffix. Unanchored
+  // and placed first it claimed `__vt__6System.1` and `statbuff__9CmdStream.0` — each then refused
+  // with a sentence about a counter, for a name whose real problem is the class definition it
+  // comes from — and it claimed gcc's IPA clones (`foo.isra.0`, `foo.part.0`, `foo.cold.1`), which
+  // are not statics at all and fall to `not-an-identifier` where they belong. A `$` name of any
+  // other shape (`$L1`) is not a static either.
+  //
+  // The one static no source declares: the name the compiler predefines in every function body.
+  // mwcc emits `__FUNCTION__`, `__func__` and `__PRETTY_FUNCTION__` as `__FUNCTION__$2`,
+  // `__func__$1`, `__PRETTY_FUNCTION__$3` (compiled), and a definition under that name is a
+  // redefinition the compiler rejects.
+  const m = sym.match(LOCAL_STATIC);
+  if (m !== null) {
+    return PREDEFINED.has(m[1]) ? 'predefined-identifier' : 'local-static';
+  }
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(sym) ? 'plain' : 'not-an-identifier';
 }
 
@@ -89,7 +143,17 @@ export function unspellableReason(sym: string): string | null {
     case 'local-static':
       return (
         `names a function-scope static ('${sym}') — the suffix is a translation-unit-wide counter ` +
-        `the compiler assigned, which no source can spell`
+        `the compiler assigned, so no declaration elsewhere names the object; only its definition can`
+      );
+    case 'inline-local-static':
+      return (
+        `names a function-scope static of an inlined function ('${sym}') — the object belongs to ` +
+        `that function's definition, which a source reaches by calling it, never by naming the object`
+      );
+    case 'predefined-identifier':
+      return (
+        `names the function's predefined name ('${sym}') — the compiler declares it in every ` +
+        `function body, so a definition would redeclare it`
       );
     case 'cpp-vtable':
       return (
@@ -107,3 +171,20 @@ export function unspellableReason(sym: string): string | null {
       return `names '${sym}', which is not a C identifier`;
   }
 }
+
+/** A function-scope static's linker name taken apart: the name the source wrote, and the counter
+ *  the compiler appended (`tide.3` → `tide`, 3; `sprHideTbl$797` → `sprHideTbl`, 797) — or null
+ *  for a name of any other kind, a static of an inlined function among them.
+ *
+ *  The counter is file-wide and counts DECLARATIONS, so within one function it is the order the
+ *  source declared its statics in. agbcc names and emits each static in one call, made while it
+ *  parses the declaration (toplev.c:2515-2529 `rest_of_decl_compilation`: varasm.c:690-698
+ *  `make_decl_rtl` takes `var_labelno++`, then `assemble_variable` writes the data); mwcc numbers
+ *  `z$4 a$5` in declaration order whatever order the code first reads them in (compiled). */
+export function localStaticName(sym: string): { name: string; counter: number } | null {
+  if (classifyRelocSymbol(sym) !== 'local-static') {
+    return null;
+  }
+  const m = sym.match(LOCAL_STATIC)!;
+  return { name: m[1], counter: Number(m[2]) };
+}

package/src/frontend/splat.ts

@@ -210,13 +210,80 @@ function splitOperands(s: string): string[] {
   return out;
 }
 
+/** A COPROCESSOR-1 REGISTER, in every spelling either MIPS dialect writes. THE ONE COPY: this
+ *  reader decides which tokens keep the `$` sigil and `frontend/mips.ts` passes the same object as
+ *  `OpaquePolicy.fpReg`, so the two questions — "does this survive normalisation with its sigil?"
+ *  and "is this the FPU's file?" — are answered by one predicate. Two copies are sequenced rather
+ *  than merely duplicated: widening the frontend's alone changes nothing, because this one has
+ *  already stripped the token, and widening this one alone hands the frontend a sigil its own
+ *  predicate rejects. Each half is silent on its own and the result is an opaque on a register in
+ *  a file nothing models.
+ *
+ *  Why the sigil: objdump writes a GPR bare (`v0`) and an FPU register with the sigil (`$f12`), so
+ *  an FPU register is the one operand shape this reader must NOT strip, or the two dialects hand
+ *  the frontend two different spellings of the same register. It is REQUIRED rather than optional
+ *  because the bare form is indistinguishable from an objdump branch target, which is also bare
+ *  lower-case hex (`f4`, `fa0`).
+ *
+ *  The spellings, and all three are live in the trees: objdump's numbers (`$f12`), this dialect's
+ *  o32 ABI names (`$ft2`, `$fv0`, `$fa0`, `$fs0`), and the trailing `f` those names take for the
+ *  ODD HALF of a double-precision pair (`$ft0f`, `$fa1f`). `$fp` is the frame pointer and is
+ *  stripped like any GPR: the digit is what decides, and it is what excludes it.
+ *
+ *  Across every `$`-token in the three MIPS `asm/` trees this matches 52 tokens and every one is an
+ *  FPU register:
+ *  `grep -rhoE '\$[A-Za-z0-9_]+' apps/benchmark/checkouts/{af,marioparty3,snowboardkids2-decomp}/asm
+ *   | sort -u | grep -icE '^\$f[vats]?[0-9]+f?$'` */
+export const MIPS_FP_REG = /^\$f[vats]?\d+f?$/i;
+
+/** The o32 ABI names of the EVEN FPU registers, by register number — the only ones a
+ *  single-precision arithmetic instruction names under the FR=0 register model these compilers
+ *  target. Read off the instruction words, not a manual: over 9,981 `add.s`/`sub.s`/`mul.s`/`div.s`
+ *  lines in the `af` and `marioparty3` trees, decoding each word's `fd`/`fs`/`ft` fields gives every
+ *  name one number and no name two. */
+const O32_FP_NAMES: ReadonlyMap<string, number> = new Map([
+  ['fv0', 0],
+  ['fv1', 2],
+  ['ft0', 4],
+  ['ft1', 6],
+  ['ft2', 8],
+  ['ft3', 10],
+  ['fa0', 12],
+  ['fa1', 14],
+  ['ft4', 16],
+  ['ft5', 18],
+  ['fs0', 20],
+  ['fs1', 22],
+  ['fs2', 24],
+  ['fs3', 26],
+  ['fs4', 28],
+  ['fs5', 30],
+]);
+
+/** An FPU register token, in either dialect's spelling, as the ONE key both dialects share — the
+ *  objdump number (`$fa0` and `$f12` are both `$f12`) — or null for anything this does not name: a
+ *  GPR, or an ODD half (`$f13`, `$fa0f`), which only a double-precision value or a word move uses.
+ *  A key is what the SSA builder names a register by, so two spellings of one register that did
+ *  not meet here would be two variables. */
+export function mipsEvenFpKey(tok: string): string | null {
+  if (!MIPS_FP_REG.test(tok)) {
+    return null;
+  }
+  const bare = tok.slice(1).toLowerCase();
+  const num = /^f\d+$/.test(bare) ? Number(bare.slice(1)) : O32_FP_NAMES.get(bare);
+  return num !== undefined && num < 32 && num % 2 === 0 ? `$f${num}` : null;
+}
+
 // Rewrite one Splat operand into the canonical objdump spelling the frontend consumes: strip the
-// `$` register sigil, fold a memory operand's displacement expression, evaluate a bare constant
-// expression, split a `%hi`/`%lo` reference into an immediate plus its record, decline a PIC one.
+// `$` register sigil (except on an FPU register, where objdump keeps it), fold a memory operand's
+// displacement expression, evaluate a bare constant expression, split a `%hi`/`%lo` reference into
+// an immediate plus its record, decline a PIC one.
 function normalizeOperand(name: string, op: string): { op: string; reloc?: DisasmReloc } {
   // `%hi(SYM)` / `%lo(SYM + N)` / `%lo(SYM)(base)` — a global's address. Becomes the relocation
   // record an object file would carry plus the immediate the instruction really encodes, so the
   // frontend folds this dialect through the same path as objdump; NOT declined like the PIC relocs.
+  // The addend is a constant expression like any other here, so its RADIX is {@link evalConst}'s
+  // question rather than this pattern's — {@link refuseOctal} says why the placement is the rule.
   const hilo = op.match(
     /^%(hi|lo)\(\s*([A-Za-z_.$][\w.$]*)\s*(?:([+-])\s*(0x[0-9a-fA-F]+|\d+))?\s*\)(?:\((\$?[A-Za-z]\w*)\))?$/,
   );
@@ -235,8 +302,8 @@ function normalizeOperand(name: string, op: string): { op: string; reloc?: Disas
   if (HILO_OP.test(op)) {
     throw new FrontendUnsupportedError(
       `cannot lift '${name}': relocation operand '${op}' — this reader resolves a '%hi'/'%lo' half ` +
-        `only against a symbol ('SYM' or 'SYM ± <integer>'), and will not treat one it cannot resolve ` +
-        `as arithmetic`,
+        `only against a symbol ('SYM' or 'SYM ± <integer>'), and will not treat one it cannot ` +
+        `resolve as arithmetic`,
     );
   }
   if (RELOC_OP.test(op)) {
@@ -256,9 +323,42 @@ function normalizeOperand(name: string, op: string): { op: string; reloc?: Disas
   if (op.startsWith('(')) {
     return plain(String(evalConst(name, op)));
   }
-  return plain(op.replace(/^\$/, ''));
+  // The one path that hands an operand on UNREAD, to a reader somewhere else: `addiu`/`addi`'s
+  // re-sign above is one, the MIPS frontend's `parseImm` another, and neither is told the radix, so
+  // a leading-zero immediate stops here — `addiu $v0, $a0, 020` lifted as `a0 + 20` against the
+  // assembler's 16.
+  if (OCTAL_MAGNITUDE.test(op)) {
+    refuseOctal(name, op, op);
+  }
+  return plain(MIPS_FP_REG.test(op) ? op : op.replace(/^\$/, ''));
 }
 
+/** A magnitude with a LEADING ZERO is octal to the assembler and decimal to every `parseInt(…, 10)`
+ *  in this file. Both readings are measured rather than assumed: under `mips-linux-gnu-as` 2.45,
+ *  `.word 020` assembles to 0x10 and `.word 010` to 8 read back out of `.data`, and
+ *  `lw $v0, 020($a0)` encodes the displacement 16 — against the 20 and the 10 a decimal reader
+ *  answers. The difference reached the emitted C as a different ELEMENT: `%lo(gTab + 020)` lifted
+ *  as `((s32 *)&gTab)[5]` where the assembler's addend gives `[4]`, and `%lo(gTab + 010)` as the
+ *  fractional index `2.5`. A wrong address compiles and scores, so this is not something to guess.
+ *
+ *  This reader models hex and decimal, so the third radix REFUSES rather than being resolved:
+ *  nothing produces the shape — 0 operand occurrences carrying a leading-zero integer over the
+ *  4,200,524 operands of the 20,260 `.s` files that carry a `glabel` or a `.set noreorder` in the
+ *  nine benchmark checkouts (counted with python; a recursive `grep` here skips `build/`) — so a
+ *  reading for it would be a capability nothing could referee.
+ *
+ *  THE PLACEMENT IS THE POINT. The rule belongs to the readers that turn a digit string into a
+ *  value, not to the patterns that feed them: a guard on one caller's regex leaves the next caller
+ *  reading base 10, and the three readers that do — `evalConst`'s literal, {@link signExtend16} and
+ *  the shared `parseImm` — are not all in this file. */
+const OCTAL_MAGNITUDE = /^[-+]?0\d/;
+const refuseOctal = (name: string, tok: string, operand: string): never => {
+  throw new FrontendUnsupportedError(
+    `cannot lift '${name}': operand '${operand}' has a leading-zero magnitude ('${tok}'), which is ` +
+      `octal to the assembler and a radix this reader does not model`,
+  );
+};
+
 // Evaluate a constant integer expression (the assembler's hi/lo split: hex/dec literals with
 // `+ - * << >> & | ^ ~` and parentheses). Precedence-climbing; C-like precedence. A shift `>>` is
 // LOGICAL — Splat's operands are unsigned 32-bit constants. Anything unparsable declines LOUD
@@ -292,6 +392,9 @@ function evalConst(name: string, expr: string): number {
       return ~unary();
     }
     if (/^(0x[0-9a-fA-F]+|\d+)$/.test(t)) {
+      if (OCTAL_MAGNITUDE.test(t)) {
+        refuseOctal(name, t, expr);
+      }
       return t.toLowerCase().startsWith('0x') ? parseInt(t, 16) : parseInt(t, 10);
     }
     return fail();