@asmlift/core 0.8.0 → 0.9.0

package/src/declare.ts

@@ -19,8 +19,10 @@
 //     ldrb+lsl+asr where u8 is ldrb alone, so a guessed signedness is a wrong-bytes decl;
 //   • `volatile` is load-bearing (a non-volatile MMIO decl lets the compiler fold/reorder
 //     accesses), `const` is the ROM-table spelling;
-//   • code symbols get `void Name(void);` ONLY when value-referenced — call targets are never
-//     in `symbolRefs` (core excludes them: prototyping a called symbol is C89 poison);
+//   • code symbols get `void Name(void);` when value-referenced, and a CALL TARGET gets its own
+//     prototype re-spelled from the project's `FnProto` — only where that states both a typed
+//     parameter list and a `returns`, because `void Name(void);` over a call that passes
+//     arguments is C89 poison (core decides it: `spellableProto`);
 //   • nothing guesses, with TWO documented exceptions: a SHAPED symbol without the facts to
 //     declare faithfully is SKIPPED — the candidate then fails to compile LOUDLY and is
 //     dropped by rankBy. Exception one is the 4-byte signless-non-pointer cell (see
@@ -51,6 +53,7 @@
 import { type StructFieldDecl, renderStructDecl } from './backend/cfamily';
 import { T } from './ir/types';
 import type { SymbolRef } from './l3/symbol-refs';
+import { type AggregateLayout, type AggregateMember, declaredWidth, spellableType } from './proto';
 import {
   ENUM_IS_SIGNED,
   type SymbolInfo,
@@ -134,6 +137,43 @@ function structDecl(tag: string, layout: SymbolStructField[] | undefined, size:
   return renderStructDecl(tag, fields);
 }
 
+/** A struct the project's headers define, transcribed from their declaration so the compiler lays
+ *  it out as it lays out theirs: each member in order with its extents and bit width, a nested
+ *  struct or union inline, and every type spelled so that it needs nothing else declared — a
+ *  pointer as `void *`, an enum as an inline enum of its own, a scalar the prelude does not name
+ *  as the prelude's type of its width and signedness. Its members are what size it, not what is
+ *  read of it: no emitted expression names one (aggregate.ts `aggregateType`). */
+function declaredStructDecl(tag: string, layout: AggregateLayout): string {
+  let enums = 0;
+  const scalar = (spelling: string): string => {
+    const s = spelling
+      .replace(/\b(?:const|volatile)\b/g, ' ')
+      .trim()
+      .replace(/\s+/g, ' ');
+    if (s.endsWith('*')) {
+      return 'void *';
+    }
+    if (/^enum\b/.test(s)) {
+      return `enum { asmlift_${tag}_enum${enums++} }`;
+    }
+    if (s === 'float' || s === 'double' || spellableType(s)) {
+      return s;
+    }
+    const bits = declaredWidth(s);
+    return `${/^u\d|\bunsigned\b/.test(s) ? 'u' : 's'}${bits}`;
+  };
+  const body = (members: readonly AggregateMember[]): string =>
+    members
+      .map((m) => {
+        const type = typeof m.type === 'string' ? scalar(m.type) : `${m.type.kind} { ${body(m.type.members!)} }`;
+        const declarator = `${m.name}${(m.dims ?? []).map((n) => `[${n}]`).join('')}`;
+        const bits = m.bits !== undefined ? ` : ${m.bits}` : '';
+        return `${type}${type.endsWith('*') || declarator === '' ? '' : ' '}${declarator}${bits};`;
+      })
+      .join(' ');
+  return `struct ${tag} { ${body(layout.members!)} };`;
+}
+
 /**
  * Render the declaration block for a candidate's recorded symbol references. Deterministic
  * (refs arrive name-sorted from core; struct decls dedupe by tag). The block is prepended by
@@ -144,7 +184,8 @@ function structDecl(tag: string, layout: SymbolStructField[] | undefined, size:
 export function renderDeclarations(refs: SymbolRef[]): string {
   const lines: string[] = [];
   const declaredTags = new Set<string>();
-  for (const { name, info, access } of refs) {
+  const declaredTypedefs = new Set<string>();
+  for (const { name, info, access, proto, returned, holdsPointer } of refs) {
     // An address-cast macro declares itself: the header's own body, verbatim. It must NOT become
     // an `extern` — that is the whole point of the fact (an extern emits a relocated pool word
     // where the macro emits the numeric one the target shows).
@@ -152,10 +193,33 @@ export function renderDeclarations(refs: SymbolRef[]): string {
       lines.push(`#define ${name} ${info.macroBody}`);
       continue;
     }
+    // A CALL TARGET the project declared completely — its own prototype, re-spelled from the
+    // parameter and return type texts the project wrote. This is the one declaration here that
+    // is load-bearing for the CALL and not only for the name: an implicit declaration is `int`,
+    // which narrows a 64-bit return and adds the sign-extension the target does not have. A
+    // parameterless list is spelled `(void)`, never `()`, because `()` declares nothing about
+    // the arguments and gcc-2.9 then promotes them.
+    if (proto !== undefined) {
+      // A STRUCT IT RETURNS THROUGH MEMORY is the headers' type, spelled as they spell it, so it is
+      // defined here with the rest of what they own: by its tag, once, whoever else declares that
+      // tag — and a typedef name is bound to it on top.
+      if (returned?.declared !== undefined) {
+        if (!declaredTags.has(returned.name)) {
+          declaredTags.add(returned.name);
+          lines.push(declaredStructDecl(returned.name, returned.layout));
+        }
+        if (!/^(?:struct|union)\s/.test(returned.declared) && !declaredTypedefs.has(returned.declared)) {
+          declaredTypedefs.add(returned.declared);
+          lines.push(`typedef struct ${returned.name} ${returned.declared};`);
+        }
+      }
+      lines.push(`${proto.returns} ${name}(${proto.params.length > 0 ? proto.params.join(', ') : 'void'});`);
+      continue;
+    }
     if (info.kind === 'code') {
       // value-referenced code symbol ((u32)Func): any prototype makes the name visible, and
-      // the address is arity-independent. Call targets never reach this module (core excludes
-      // them from symbolRefs — see collectSymbolRefs).
+      // the address is arity-independent. A call target reaches this module only with a complete
+      // prototype, which the branch above already printed — see collectSymbolRefs.
       lines.push(`void ${name}(void);`);
       continue;
     }
@@ -247,6 +311,12 @@ export function renderDeclarations(refs: SymbolRef[]): string {
         // argument applies. For a `synthesized` one it does not — the width came from the
         // target's own asm, so this line is a hypothesis fitted to the bytes; see the module
         // note's "WHERE THE ONLY-LOSES-SCORE ARGUMENT STOPS".
+        // A global that holds a pointer (ref.holdsPointer) is `void *`, the type every object
+        // pointer converts to without a cast; the qualifiers bind to the cell.
+        if (holdsPointer) {
+          lines.push(`extern void *${info.volatile ? 'volatile ' : ''}${info.const ? 'const ' : ''}${name};`);
+          break;
+        }
         const t = access ? intType(access.width, access.signed) : null;
         lines.push(`extern ${quals(info)}${t ?? 'u32'} ${name};`);
         break;

package/src/frontend/asmdata.ts

@@ -29,10 +29,22 @@ export interface Reloc {
 export interface AsmData {
   sections: Map<string, Uint8Array>; // section name → raw bytes (file order)
   relocs: Reloc[];
-  symbols: Map<string, { section: string; value: number }>; // symbol name → {section, offset-in-section}
+  symbols: Map<string, AsmSymbol>;
+  /** how many symbols the `objdump -t` listing printed — the symbol table's entries past its null one */
+  symbolCount: number;
   bigEndian: boolean;
 }
 
+/** One `objdump -t` symbol: its section, offset in it and size, and `index`, its position in the
+ *  listing counting from 1 — its symbol-table index, which is what a per-symbol side table in the
+ *  object (mwcc's `.comment`, frontend/local-object.ts) is indexed by. */
+export interface AsmSymbol {
+  section: string;
+  value: number;
+  size: number;
+  index: number;
+}
+
 const readU32 = (b: Uint8Array, off: number, big: boolean): number =>
   big
     ? ((b[off] << 24) | (b[off + 1] << 16) | (b[off + 2] << 8) | b[off + 3]) >>> 0
@@ -112,7 +124,8 @@ export function parseAsmData(
   }
 
   // --- `objdump -t`: `VALUE FLAGS SECTION\tSIZE NAME` (section/size split by TAB) ---
-  const symbols = new Map<string, { section: string; value: number }>();
+  const symbols = new Map<string, AsmSymbol>();
+  let symbolCount = 0;
   for (const line of symbolsDump.split('\n')) {
     const tab = line.indexOf('\t');
     if (tab < 0) {
@@ -121,14 +134,15 @@ export function parseAsmData(
     const left = line.slice(0, tab),
       right = line.slice(tab + 1);
     const lm = left.match(/^([0-9a-f]+)\s+.{6,8}\s(\S+)\s*$/i); // value … flags(7) section
-    const rm = right.match(/^[0-9a-f]+\s+(.+?)\s*$/i); // size name
+    const rm = right.match(/^([0-9a-f]+)\s+(.+?)\s*$/i); // size name
     if (!lm || !rm) {
       continue;
     }
-    symbols.set(rm[1], { section: lm[2], value: parseInt(lm[1], 16) });
+    symbolCount++;
+    symbols.set(rm[2], { section: lm[2], value: parseInt(lm[1], 16), size: parseInt(rm[1], 16), index: symbolCount });
   }
 
-  return { sections, relocs, symbols, bigEndian };
+  return { sections, relocs, symbols, symbolCount, bigEndian };
 }
 
 /** Read a dense jump table's N target `.text` byte-offsets, or `null` if ANYTHING doesn't resolve