@asmlift/core 0.9.0 → 0.10.0

package/src/frontend/local-object.ts

@@ -16,8 +16,12 @@
 // static — when:
 //   • the target does not carry the definition (the symbol is absent, or its label heads no data);
 //   • the object sits in a section that is not read-only data, initialized data or bss;
-//   • a relocation falls inside its bytes — the initializer holds an address, which is a
-//     declaration of another object this reader does not make;
+//   • a relocation falls inside its bytes that is no pointer-width absolute address of an ordinary
+//     global: one narrower or wider than a pointer, or off the object's words, or of another type,
+//     or naming what no declaration outside the function can (a section, the compiler's anonymous
+//     constant, another function-scope static — reloc-symbol.ts's kinds). Such an address is
+//     RECORDED (`LocalObject.relocs`) and left to the reader of the object to spell or refuse
+//     (structure/local-statics.ts);
 //   • its extent cannot be read: a directive inside its data run this reader does not parse, a
 //     size that disagrees with the bytes under the label, or an empty object;
 //   • its alignment cannot be read: an `.align` form this reader does not parse, or an object file
@@ -28,9 +32,14 @@
 //     re-declaring it inside one of them would split one object in two. Only the functions this
 //     input shows can be checked, which is the limit of this refusal: a single-function input
 //     cannot show a second referrer, and one that ends at this function cannot show a later one.
-import type { LocalObject, LocalObjects } from '../ir/core';
+import {
+  type LocalObject,
+  type LocalObjectReloc,
+  type LocalObjects,
+  LOCAL_OBJECT_ADDRESS_BYTES as POINTER_BYTES,
+} from '../ir/core';
 import type { AsmData } from './asmdata';
-import { localStaticName } from './reloc-symbol';
+import { classifyRelocSymbol, localStaticName, unspellableReason } from './reloc-symbol';
 
 /** A definition, or why there is none: the tail of a refusal sentence the caller opens with
  *  "names a function-scope static ('<symbol>')", so every refusal of the kind reads the same. */
@@ -38,6 +47,14 @@ export type LocalObjectRead = LocalObject | { refused: string };
 
 const refused = (why: string): { refused: string } => ({ refused: why });
 
+/** Why an initializer's address of `symbol` cannot be recorded, as the tail of the refusal
+ *  sentence — or null for an ordinary global's, which a declaration outside the function names.
+ *  Every other kind is the naming policy's own (reloc-symbol.ts), with its own sentence. */
+function addressRefusal(symbol: string): string | null {
+  const why = unspellableReason(symbol);
+  return why === null ? null : `whose initializer holds an address that ${why}`;
+}
+
 // ── GNU as text (agbcc) ──────────────────────────────────────────────────────────────────────────
 
 /** A line without its `@` comment, where the `@` is not inside a string literal. */
@@ -112,18 +129,22 @@ const le = (value: number, width: number): number[] =>
   Array.from({ length: width }, (_, i) => (value >>> (8 * i)) & 0xff);
 
 /** What one data directive writes: its bytes, the width of each value it writes (null for
- *  padding, which writes none), whether one of those values is negative, and whether it writes a
- *  string. */
+ *  padding, which writes none), whether one of those values is negative, whether it writes a
+ *  string, and the addresses among its values, at their byte offsets in the directive. */
 interface DirectiveData {
   bytes: number[];
   width: number | null;
   negative: boolean;
   string: boolean;
+  relocs: LocalObjectReloc[];
 }
 
-/** One data directive's data; `{ address }` when an operand is not a number (a symbol — the word is
- *  relocated), null when the directive is not a data directive this reader parses. */
-function dataBytes(directive: string, operands: string): DirectiveData | { address: string } | null {
+/** `sym`, `sym+K` or `sym-K` — the operand GNU as relocates to a symbol's address plus a constant. */
+const GAS_ADDRESS = /^([A-Za-z_.$][\w.$]*)\s*(?:([+-])\s*(\S+))?$/;
+
+/** One data directive's data; `{ refused }` for an operand that is no number and no address this
+ *  reader records, null when the directive is not a data directive this reader parses. */
+function dataBytes(directive: string, operands: string): DirectiveData | { refused: string } | null {
   const width = /^(byte)$/.test(directive)
     ? 1
     : /^(short|hword|2byte)$/.test(directive)
@@ -133,29 +154,54 @@ function dataBytes(directive: string, operands: string): DirectiveData | { addre
         : 0;
   if (width > 0) {
     const out: number[] = [];
+    const relocs: LocalObjectReloc[] = [];
     let negative = false;
     for (const op of operands.split(',')) {
       const v = gasInteger(op);
-      if (v === null) {
-        return { address: op.trim() };
+      if (v !== null) {
+        negative ||= v < 0;
+        out.push(...le(v, width));
+        continue;
+      }
+      // Not a number, so the assembler relocates the value: an address, which the bytes do not hold.
+      const a = op.trim().match(GAS_ADDRESS);
+      // agbcc writes a negative addend `garr+-0x4` (compiled: `&garr[-1]`), so the constant keeps a sign
+      const k = a === null ? null : a[3] === undefined ? 0 : gasInteger(a[3]);
+      if (a === null || k === null) {
+        return refused(`whose initializer holds '${op.trim()}', an expression this reader does not read as an address`);
       }
-      negative ||= v < 0;
-      out.push(...le(v, width));
+      if (width !== POINTER_BYTES) {
+        return refused(
+          `whose initializer holds the address '${op.trim()}' in a ${width}-byte value — not a pointer's ${POINTER_BYTES}`,
+        );
+      }
+      const why = addressRefusal(a[1]);
+      if (why !== null) {
+        return refused(why);
+      }
+      relocs.push({ offset: out.length, symbol: a[1], addend: a[2] === '-' ? -k : k });
+      out.push(...le(0, width));
     }
-    return { bytes: out, width, negative, string: false };
+    return { bytes: out, width, negative, string: false, relocs };
   }
   if (/^(space|skip|zero)$/.test(directive)) {
     const [n, fill, ...rest] = operands.split(',').map((s) => gasInteger(s));
     return n === null || n < 0 || rest.length > 0 || fill === null
       ? null
-      : { bytes: new Array<number>(n).fill((fill ?? 0) & 0xff), width: null, negative: false, string: false };
+      : {
+          bytes: new Array<number>(n).fill((fill ?? 0) & 0xff),
+          width: null,
+          negative: false,
+          string: false,
+          relocs: [],
+        };
   }
   if (/^(ascii|asciz|string)$/.test(directive)) {
     const m = operands.trim().match(/^"((?:[^"\\]|\\.)*)"$/);
     const s = m ? gasString(m[1]) : null;
     return s === null
       ? null
-      : { bytes: directive === 'ascii' ? s : [...s, 0], width: 1, negative: false, string: true };
+      : { bytes: directive === 'ascii' ? s : [...s, 0], width: 1, negative: false, string: true, relocs: [] };
   }
   return null;
 }
@@ -212,6 +258,40 @@ export function readGasLocalObject(asm: string, symbol: string): LocalObjectRead
     return refused('whose name has no source spelling this reader knows');
   }
   const { name, counter: order } = parts;
+  const read = readGasDefinition(asm, symbol);
+  return 'refused' in read ? read : { name, symbol, order, ...read };
+}
+
+/** Read an ANONYMOUS constant out of GNU as text: the data run under a compiler-generated `.L`
+ *  label (agbcc's `.LC0`), which is how agbcc 2.9 places the image a local aggregate's constant
+ *  initializer is copied from (`u8 a[16] = {…}` is `ldr r1,=.LC0; mov r0,sp; mov r2,#16; bl memcpy`,
+ *  varasm.c `output_constant_def`). Nothing in the source names it, so no declaration can spell it:
+ *  the object is carried {@link LocalObject.anonymous} and spelled only as the initializer of the
+ *  local it is copied into (l3/constinit.ts), or refused there.
+ *
+ *  Read-only data only, with the same refusals as a static's definition: a `.L` label anywhere else
+ *  is code, or data this reader has no reason to believe is a constant image. That gate is agbcc's
+ *  placement, not every compiler's: IDO 7.1 places the same image in `.data` (compiled). Which
+ *  names are anonymous is reloc-symbol.ts's decision (`anon-pool`). */
+export function readGasAnonymousObject(asm: string, label: string): LocalObjectRead {
+  if (classifyRelocSymbol(label) !== 'anon-pool') {
+    return refused('whose label is not a compiler-generated `.L` label');
+  }
+  const read = readGasDefinition(asm, label);
+  if ('refused' in read) {
+    return read;
+  }
+  if (read.section !== 'rodata') {
+    return refused(`defined in ${read.section}, which is not the read-only data a constant image sits in`);
+  }
+  return { name: label, symbol: label, order: -1, anonymous: true, ...read };
+}
+
+/** A definition's section, size, bytes and directives, read from the label down. */
+function readGasDefinition(
+  asm: string,
+  symbol: string,
+): Omit<LocalObject, 'name' | 'symbol' | 'order'> | { refused: string } {
   const lines = asm.split('\n').map(code);
   let declaredSize: number | null = null;
   let section: string | null = null;
@@ -225,7 +305,7 @@ export function readGasLocalObject(asm: string, symbol: string): LocalObjectRead
       if (size === null || size <= 0) {
         return refused(`whose '.lcomm' size '${lcomm[2]}' is not a positive number`);
       }
-      return { name, symbol, order, section: 'bss', size, bigEndian: false };
+      return { section: 'bss', size, bigEndian: false };
     }
     const sz = line.match(/^\.size\s+([^\s,]+)\s*,\s*(\S+)$/);
     if (sz && sz[1] === symbol) {
@@ -255,6 +335,8 @@ export function readGasLocalObject(asm: string, symbol: string): LocalObjectRead
   const widths = new Set<number>();
   let negative = false;
   const strings = new Set<boolean>();
+  const gaps: [number, number][] = [];
+  const relocs: LocalObjectReloc[] = [];
   const first = lines[at].replace(/^[A-Za-z_.$][\w.$]*:\s*/, '');
   for (let i = at; i < lines.length; i++) {
     const line = i === at ? first : lines[i];
@@ -275,8 +357,22 @@ export function readGasLocalObject(asm: string, symbol: string): LocalObjectRead
     if (b === null) {
       return refused(`whose data run holds '.${d[1]}', a directive this reader does not read as bytes`);
     }
-    if ('address' in b) {
-      return refused(`whose initializer holds the address '${b.address}' — a relocation inside the object`);
+    if ('refused' in b) {
+      return b;
+    }
+    // A word lands wherever the run has reached: agbcc aligns an object's words, never one word
+    // inside it, so one off a pointer boundary is no pointer of the object's.
+    if (b.relocs.length > 0 && bytes.length % POINTER_BYTES !== 0) {
+      return refused(`whose initializer holds the address '${b.relocs[0].symbol}' off its ${POINTER_BYTES}-byte words`);
+    }
+    relocs.push(...b.relocs.map((r) => ({ ...r, offset: r.offset + bytes.length })));
+    if (b.width === null && b.bytes.length > 0 && b.bytes.every((x) => x === 0)) {
+      const last = gaps[gaps.length - 1];
+      if (last !== undefined && last[0] + last[1] === bytes.length) {
+        last[1] += b.bytes.length;
+      } else {
+        gaps.push([bytes.length, b.bytes.length]);
+      }
     }
     bytes.push(...b.bytes);
     if (b.width !== null) {
@@ -292,8 +388,8 @@ export function readGasLocalObject(asm: string, symbol: string): LocalObjectRead
     return refused(`whose '.size' (${declaredSize}) disagrees with the ${bytes.length} bytes under its label`);
   }
   if (kind === 'bss') {
-    return bytes.every((b) => b === 0)
-      ? { name, symbol, order, section: 'bss', size: bytes.length, bigEndian: false }
+    return bytes.every((b) => b === 0) && relocs.length === 0
+      ? { section: 'bss', size: bytes.length, bigEndian: false }
       : refused('defined in bss with non-zero bytes');
   }
   const align = alignAhead(lines, at);
@@ -307,9 +403,6 @@ export function readGasLocalObject(asm: string, symbol: string): LocalObjectRead
   // struct's mixed directives a negative belongs to one field, which says nothing of another.
   const unit = widths.size === 1 && bytes.length % [...widths][0] === 0 ? [...widths][0] : undefined;
   return {
-    name,
-    symbol,
-    order,
     section: kind,
     size: bytes.length,
     bytes: Uint8Array.from(bytes),
@@ -319,7 +412,9 @@ export function readGasLocalObject(asm: string, symbol: string): LocalObjectRead
       ...(unit !== undefined ? { unit } : {}),
       negative: unit !== undefined && negative,
       string: strings.size === 1 && strings.has(true),
+      ...(widths.size > 0 && gaps.length > 0 ? { gaps } : {}),
     },
+    ...(relocs.length > 0 ? { relocs } : {}),
   };
 }
 
@@ -382,15 +477,24 @@ const OBJECT_SECTIONS: Readonly<Record<string, LocalObject['section']>> = {
   '.sbss': 'bss',
 };
 
+/** The relocations that fill a pointer-width word with a symbol's absolute address — the only kind
+ *  an initializer's address constant is. Each is listed where a frontend reads its objects through
+ *  this reader: mwcc's (frontend/ppc.ts); MIPS addresses a function-scope static section-relative
+ *  and does not reach it. RELA types only: the addend is read off the relocation entry alone, and a
+ *  REL type (whose addend is the word it fills) joins only with a reader of that word. */
+const ABSOLUTE_WORD: ReadonlySet<string> = new Set(['R_PPC_ADDR32']);
+
 /** Sections whose relocations describe the program for a debugger, not for the machine. */
 const isDebugSection = (s: string): boolean => /^\.(debug|line)/.test(s);
 
-/** mwcc's `.comment` section: `CodeWarrior\n`, a header to 0x2c, then one 8-byte record per
- *  symbol-table entry, the null one first, whose first word is the alignment mwcc gave that symbol
- *  (compiled: `s64` records 8 and lands at 8 after an `s32`, `aligned(32)` records 32, a scalar
- *  `u8` 1). No section header or symbol value says the same: a section's alignment is its widest
- *  object's, and an object at offset 0 of one is aligned to anything. */
-const MW_COMMENT_MAGIC = 'CodeWarrior\n';
+/** mwcc's `.comment` section: `CodeWarrior`, a version byte (0x0a from 2.4.2 and 2.4.7, 0x08 from
+ *  2.3.3), a header to 0x2c, then one 8-byte record per symbol-table entry, the null one first,
+ *  whose first word is the alignment mwcc gave that symbol (compiled on all three builds: `s64`
+ *  records 8 and lands at 8 after an `s32`, `aligned(32)` records 32, a scalar `u8` 1). No section
+ *  header or symbol value says the same: a section's alignment is its widest object's, and an
+ *  object at offset 0 of one is aligned to anything. The magic is the eleven letters alone, so the
+ *  version byte never decides whether the records are read. */
+const MW_COMMENT_MAGIC = 'CodeWarrior';
 const MW_COMMENT_RECORDS = 0x2c;
 
 /** The alignment mwcc's `.comment` records for the symbol at `index`, or null when the section is
@@ -432,9 +536,10 @@ export function readObjectLocalObject(ad: AsmData, symbol: string, fn: string):
     return refused('whose symbol-table size is 0, so its extent is unknown');
   }
   const self = ad.symbols.get(fn);
+  const inside: typeof ad.relocs = [];
   for (const r of ad.relocs) {
     if (r.section === sym.section && r.offset >= sym.value && r.offset < sym.value + sym.size) {
-      return refused(`whose initializer holds the address '${r.sym}' — a relocation inside the object`);
+      inside.push(r);
     }
     if (r.sym !== symbol || isDebugSection(r.section)) {
       continue;
@@ -451,12 +556,32 @@ export function readObjectLocalObject(ad: AsmData, symbol: string, fn: string):
   }
   const placement = { align, section: sym.section, offset: sym.value };
   if (kind === 'bss') {
-    return { name, symbol, order, section: 'bss', size: sym.size, bigEndian: ad.bigEndian, placement };
+    return inside.length === 0
+      ? { name, symbol, order, section: 'bss', size: sym.size, bigEndian: ad.bigEndian, placement }
+      : refused('defined in bss with a relocation inside it');
   }
   const contents = ad.sections.get(sym.section);
   if (contents === undefined || sym.value + sym.size > contents.length) {
     return refused(`whose bytes the side table's '${sym.section}' contents do not hold`);
   }
+  const relocs: LocalObjectReloc[] = [];
+  for (const r of inside.sort((a, b) => a.offset - b.offset)) {
+    const at = r.offset - sym.value;
+    if (!ABSOLUTE_WORD.has(r.type)) {
+      return refused(
+        `whose initializer holds the address '${r.sym}' by a ${r.type} relocation — no pointer's absolute address`,
+      );
+    }
+    if (at % POINTER_BYTES !== 0 || at + POINTER_BYTES > sym.size) {
+      return refused(`whose initializer holds the address '${r.sym}' off its ${POINTER_BYTES}-byte words`);
+    }
+    const why = addressRefusal(r.sym);
+    if (why !== null) {
+      return refused(why);
+    }
+    // a RELA relocation (ABSOLUTE_WORD): the linker replaces the word, so its bytes add nothing
+    relocs.push({ offset: at, symbol: r.sym, addend: r.addend | 0 });
+  }
   return {
     name,
     symbol,
@@ -466,6 +591,7 @@ export function readObjectLocalObject(ad: AsmData, symbol: string, fn: string):
     bytes: contents.slice(sym.value, sym.value + sym.size),
     bigEndian: ad.bigEndian,
     placement,
+    ...(relocs.length > 0 ? { relocs } : {}),
   };
 }