@asmlift/core 0.8.1 → 0.10.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,37 @@ 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>();
+  const defineStruct = (s: { readonly name: string; readonly declared: string; readonly layout: AggregateLayout }) => {
+    if (!declaredTags.has(s.name)) {
+      declaredTags.add(s.name);
+      lines.push(declaredStructDecl(s.name, s.layout));
+    }
+    if (!/^(?:struct|union)\s/.test(s.declared) && !declaredTypedefs.has(s.declared)) {
+      declaredTypedefs.add(s.declared);
+      lines.push(`typedef struct ${s.name} ${s.declared};`);
+    }
+  };
+  for (const {
+    name,
+    info,
+    access,
+    proto,
+    returned,
+    passed,
+    passedAs,
+    holdsPointer,
+    implicitCall,
+    definesReturn,
+  } of refs) {
+    // THE FUNCTION'S OWN STRUCT RETURN, defined as a callee's is; the function itself is declared
+    // by its definition
+    if (definesReturn) {
+      if (returned !== undefined) {
+        defineStruct(returned);
+      }
+      continue;
+    }
     // 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 +222,42 @@ export function renderDeclarations(refs: SymbolRef[]): string {
       lines.push(`#define ${name} ${info.macroBody}`);
       continue;
     }
+    // A GLOBAL REGISTER VARIABLE declares itself in its register (SymbolInfo.globalRegister), typed
+    // as a name-only global is: a pointer where the body stores or meets one, else the word the
+    // body accesses.
+    if (info.globalRegister !== undefined) {
+      const t = holdsPointer ? 'void *' : `${intType(access?.width ?? 4, access?.signed ?? true) ?? 's32'} `;
+      lines.push(`register ${t}${name} __asm__("${info.globalRegister}");`);
+      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.
+      // …and so is a struct it is passed by value, the same way.
+      for (const s of [...(returned?.declared !== undefined ? [returned] : []), ...(passed ?? [])]) {
+        defineStruct(s);
+      }
+      lines.push(`${proto.returns} ${name}(${proto.params.length > 0 ? proto.params.join(', ') : 'void'});`);
+      continue;
+    }
+    // A CALL TARGET no prototype spells, named ahead of its first call by an initializer — C's
+    // implicit declaration, `int F();`, written where the initializer can see it. No parameter
+    // list, so the call binds to it exactly as it bound to the implicit one (see collectSymbolRefs).
+    if (implicitCall) {
+      lines.push(`int ${name}();`);
+      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 here only with a complete
+      // prototype or as an initializer's implicit call, which the branches above printed.
       lines.push(`void ${name}(void);`);
       continue;
     }
@@ -247,6 +349,18 @@ 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;
+        }
+        // A global passed bare as a struct by value is that struct, which its callee's prototype
+        // defines (`passed`); a declaration of an incomplete tag is completed by that definition.
+        if (passedAs !== undefined) {
+          lines.push(`extern ${quals(info)}${passedAs} ${name};`);
+          break;
+        }
         const t = access ? intType(access.width, access.signed) : null;
         lines.push(`extern ${quals(info)}${t ?? 'u32'} ${name};`);
         break;
@@ -256,18 +370,23 @@ export function renderDeclarations(refs: SymbolRef[]): string {
   return lines.length ? lines.join('\n') + '\n' : '';
 }
 
-/** The object-like `#define`s out of a rendered declaration block.
+/** THE LINES OF A RENDERED DECLARATION BLOCK THAT THE HEADERS WORLD KEEPS: its object-like
+ *  `#define`s and its global register variables. Everything else there is owned by the injected
+ *  headers (a duplicate typedef or struct definition is a C89 hard error), and these two are not:
+ *
+ *  - an address-cast macro, because a duplicate `#define` with an identical body is legal — and a
+ *    PREPROCESSED project context has no macros left at all, so dropping these turns a macro-named
+ *    candidate into an `undeclared identifier` rather than a spelling choice;
+ *  - a global register variable (`register T greg_r8 __asm__("r8");`, SymbolInfo.globalRegister),
+ *    because no header declares the name the lift made up for it.
  *
- *  Address-cast macro defines are the one part of a synthesized block that must survive into the
- *  HEADERS world too. Everything else there is owned by the injected headers (a duplicate typedef
- *  or struct definition is a C89 hard error), but a duplicate `#define` with an identical body is
- *  legal — and a PREPROCESSED project context has no macros left at all, so dropping these turns a
- *  macro-named candidate into an `undeclared identifier` rather than a spelling choice. */
-export function macroDefinesOf(declarations: string | undefined): string {
+ *  Chosen by each line's leading keyword, which `renderDeclarations` prints for these two kinds
+ *  only: a new kind of line it prints with either keyword rides into the headers world too. */
+export function declarationsKeptWithHeaders(declarations: string | undefined): string {
   if (!declarations) {
     return '';
   }
-  const lines = declarations.split('\n').filter((l) => l.startsWith('#define '));
+  const lines = declarations.split('\n').filter((l) => l.startsWith('#define ') || l.startsWith('register '));
   return lines.length ? lines.join('\n') + '\n' : '';
 }
 

package/src/frontend/asmdata.ts

@@ -29,17 +29,35 @@ 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
     : ((b[off + 3] << 24) | (b[off + 2] << 16) | (b[off + 1] << 8) | b[off]) >>> 0;
 
-// Parse an `objdump -r` VALUE field: `sw_jt+0x00000020` / `.text` / `@15` → {sym, addend}.
+// Parse an `objdump -r` VALUE field: `sw_jt+0x00000020` / `.text` / `@15` → {sym, addend}. A
+// negative RELA addend prints as `garr-0x00000004` (mwcc's `&garr[-1]`, compiled), and is kept as
+// the same 32-bit word a positive one is.
 function parseRelocValue(v: string): { sym: string; addend: number } {
+  const minus = v.match(/^(.+)-(0x[0-9a-f]+)$/i);
+  if (minus) {
+    return { sym: minus[1], addend: -parseInt(minus[2], 16) >>> 0 };
+  }
   const plus = v.indexOf('+');
   if (plus < 0) {
     return { sym: v, addend: 0 };
@@ -112,7 +130,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 +140,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