@asmlift/core 0.8.1 → 0.10.0

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();