@asmlift/core 0.9.0 → 0.11.0

package/src/structure/local-statics.ts

@@ -29,20 +29,38 @@
 // source's (`tide`) in one step, `nameLocalStatics`, which is where a clash between that name and
 // anything else the function names can first be seen whole.
 //
+// An element the target RELOCATES holds an address — a table of function pointers, of data
+// pointers, of `&arr[k]` — and is spelled as the address constant it is, `(u32)&sym` or
+// `(u32)((u8 *)&sym + k)`, in the integer element the rest of this typing picks: such an element
+// compiles to the same word and the same relocation as the pointer-typed source (agbcc and mwcc,
+// compiled), so the definition needs no pointer type to put the bytes where the target has them.
+//
 // REFUSES, naming the static, when the target's compiler declares no layout rules, when nothing
 // in the definition settles the width and the accesses disagree on it, when the width is no
 // integer type's or does not divide the size, when the loads disagree on the signedness, when the
 // definition is aligned narrower than its declaration here would be, when a bss static sits where
 // only a scalar initialized to zero is sure to land and it is no scalar (or the input does not
-// show where it sits);
+// show where it sits), when an element holding an address — a static's or the compiler's
+// anonymous image's — is no pointer's width;
 // and, at the rename, when two statics share a source name (one block cannot declare both) or
 // when the function names anything else by it — a global, a callee, a parameter, a local, itself —
-// which the block-scope static would hide.
-import { type Fn, type LocalObject, type LocalObjects, type Op, type Value, defOpMap } from '../ir/core';
+// which the block-scope static would hide — and when a global an initializer holds the address of
+// is hidden there by a static, parameter or local of its name.
+import {
+  type Fn,
+  LOCAL_OBJECT_ADDRESS_BYTES,
+  type LocalObject,
+  type LocalObjects,
+  type Op,
+  type Value,
+  defOpMap,
+} from '../ir/core';
 import { type IrType, T } from '../ir/types';
 import {
   type Expr,
+  type InitAddress,
   type SFn,
+  type SImage,
   type SStatic,
   type Stmt,
   mapExprChildren,
@@ -123,6 +141,8 @@ function zeroInitialized(
 export interface LocalStaticShapes {
   infos: Map<string, SymbolInfo>;
   statics: SStatic[];
+  /** the compiler's anonymous constant images, which no declaration spells (l3/constinit.ts) */
+  images: SImage[];
 }
 
 /** One access through a static's address: the width it reads or writes, and a load's extension. */
@@ -206,8 +226,11 @@ function elements(obj: LocalObject, width: number, signed: boolean): number[] {
 }
 
 /** The width of `obj`'s element: the one its definition's directives write, else the one every
- *  access agrees on; with no access either, the whole object where it is aligned below the
- *  compiler's aggregate floor, as only a scalar is, and a byte where it is not. */
+ *  access agrees on; with no access either, a pointer's where the target relocates a word of it (an
+ *  address table only handed to a callee, on a compiler that writes no directives: mwcc), else the
+ *  whole object where it is aligned below the compiler's aggregate floor, as only a scalar is, and
+ *  a byte where it is not. A relocation the pointer width does not seat is still refused, by the
+ *  caller's check of every relocation's offset. */
 function elementWidth(
   obj: LocalObject,
   accesses: readonly Access[],
@@ -220,9 +243,15 @@ function elementWidth(
   if (widths.length > 1) {
     return { refused: `whose accesses disagree on its element width (${widths.sort().join(' and ')} bytes)` };
   }
+  if (widths.length === 1) {
+    return widths[0];
+  }
+  if ((obj.relocs?.length ?? 0) > 0 && obj.size % LOCAL_OBJECT_ADDRESS_BYTES === 0) {
+    return LOCAL_OBJECT_ADDRESS_BYTES;
+  }
   const shown = obj.directives?.align ?? obj.placement?.align;
   const scalarOnly = shown !== undefined && shown < layout.aggregateAlign;
-  return widths[0] ?? (scalarOnly && [1, 2, 4].includes(obj.size) ? obj.size : 1);
+  return scalarOnly && [1, 2, 4].includes(obj.size) ? obj.size : 1;
 }
 
 /** The shape and definition of every static `fn` defines, or the refusal: the static's linker name
@@ -234,8 +263,9 @@ export function localStaticShapes(
   const objs = fn.localObjects;
   const infos = new Map<string, SymbolInfo>();
   const statics: SStatic[] = [];
+  const images: SImage[] = [];
   if (objs === undefined) {
-    return { infos, statics };
+    return { infos, statics, images };
   }
   if (layout === undefined) {
     const [first] = objs.keys();
@@ -262,6 +292,75 @@ export function localStaticShapes(
   // it places in the order it first uses them: the candidate's code decides that, no declaration.
   for (const obj of [...objs.values()].sort((a, b) => a.order - b.order)) {
     const say = (why: string) => ({ symbol: obj.symbol, refused: why });
+    if (obj.anonymous) {
+      // The compiler's own image of a local aggregate's initializer: typed by its directives alone,
+      // since nothing but the copy reads it, and never declared where it sits — l3/constinit.ts
+      // folds it into the local the copy fills, which is the declaration that placed it.
+      const unit = obj.directives?.unit;
+      if (unit === undefined || obj.bytes === undefined) {
+        return say('whose image writes no one element width — a struct, or padding alone');
+      }
+      if (![1, 2, 4].includes(unit) || obj.size % unit !== 0) {
+        return say(`whose ${unit}-byte elements are no integer array of its ${obj.size} bytes`);
+      }
+      const signed = obj.directives!.negative;
+      const count = obj.size / unit;
+      infos.set(obj.symbol, {
+        name: obj.symbol,
+        kind: 'data',
+        size: obj.size,
+        shape: 'array',
+        elemSize: unit,
+        elemSigned: signed,
+        dims: [count],
+        const: true,
+      });
+      // Only the elements the source spelled: an element it left out is a hole, and the holes after
+      // the last value are dropped. Spelled out as zeros, the initializer is a different one to the
+      // compiler, which clears and stores where most of one is zero rather than copy an image
+      // (expr.c `mostly_zeros_p`) — so the printer spells the element after a hole by designator,
+      // where the compiler parses one (`SFn.designators`).
+      const init: (number | InitAddress | null)[] = elements(obj, unit, signed);
+      for (const [from, n] of obj.directives!.gaps ?? []) {
+        if (from % unit !== 0 || n % unit !== 0) {
+          return say(`whose padding at byte ${from} does not fall on its ${unit}-byte elements`);
+        }
+        init.fill(null, from / unit, (from + n) / unit);
+      }
+      // An element the image relocates holds an address, as a static's does — an array of pointers
+      // (agbcc copies one with memcpy from 16 words, compiled).
+      for (const r of obj.relocs ?? []) {
+        if (unit !== LOCAL_OBJECT_ADDRESS_BYTES || r.offset % unit !== 0) {
+          return say(
+            `whose image holds the address '${r.symbol}', which its ${unit}-byte elements cannot — ` +
+              `an address is ${LOCAL_OBJECT_ADDRESS_BYTES}`,
+          );
+        }
+        init[r.offset / unit] = { symbol: r.symbol, addend: r.addend };
+      }
+      // A string literal's image is placed at the compiler's string alignment, which a brace list of
+      // strings is not (agbcc: `.align 2, 0` ahead of a STRING_CST's label, none ahead of
+      // `{"abcde"}`'s) — the same bytes, but spelled as a literal the image moves to a stricter
+      // alignment and shifts the unit's `.rodata`. Nor has it a padding run: one shorter than its
+      // array is copied at the literal's length and the tail cleared (`char a[16] = "abc…hijklm"` is
+      // memcpy 15 + memset 1), so a `.space` after the `.ascii` is a brace list's image copied whole.
+      // So the test is asked before the trailing holes are dropped, not after.
+      const string =
+        obj.directives!.string === true &&
+        unit === 1 &&
+        obj.directives!.align >= layout.stringAlign &&
+        !init.includes(null);
+      while (init.length > 0 && init[init.length - 1] === null) {
+        init.pop();
+      }
+      images.push({
+        name: obj.symbol,
+        type: T.array(T.int(unit * 8, signed), count),
+        init,
+        ...(string ? { string: true as const } : {}),
+      });
+      continue;
+    }
     const accesses = access.get(obj.symbol) ?? [];
     const dir = obj.directives;
     // the alignment the target shows
@@ -284,7 +383,22 @@ export function localStaticShapes(
     const signed = signs.size > 0 ? signs.has(true) : dir?.negative === true;
     const count = obj.size / width;
     const elem = T.int(width * 8, signed);
-    const init = zeroed.has(obj.symbol) ? [0] : obj.bytes === undefined ? undefined : elements(obj, width, signed);
+    const init: (number | InitAddress)[] | undefined = zeroed.has(obj.symbol)
+      ? [0]
+      : obj.bytes === undefined
+        ? undefined
+        : elements(obj, width, signed);
+    // An element the target relocates holds an address, which only an element of a pointer's width
+    // can: the relocation fills exactly that many bytes.
+    for (const r of obj.relocs ?? []) {
+      if (width !== LOCAL_OBJECT_ADDRESS_BYTES || r.offset % width !== 0) {
+        return say(
+          `whose initializer holds the address '${r.symbol}', which its ${width}-byte elements cannot — ` +
+            `an address is ${LOCAL_OBJECT_ADDRESS_BYTES}`,
+        );
+      }
+      init![r.offset / width] = { symbol: r.symbol, addend: r.addend };
+    }
     if (zeroed.has(obj.symbol) && count !== 1) {
       return say(`laid out where only a scalar initialized to zero is, but of ${count} elements`);
     }
@@ -320,7 +434,7 @@ export function localStaticShapes(
       ...(string ? { string: true as const } : {}),
     });
   }
-  return { infos, statics };
+  return { infos, statics, images };
 }
 
 /** `sfn` with each static's linker name replaced by its source name — every reference, assignment
@@ -332,7 +446,26 @@ export function nameLocalStatics(sfn: SFn, objs: LocalObjects): SFn | { symbol:
   for (const g of sfn.globals ?? []) {
     taken.add(g.name);
   }
+  // The globals an initializer holds the address of are named here as much as the body's: a static
+  // of the same name is in scope from its own declarator on, its initializer included.
+  const addressed = new Map<string, string>();
+  for (const obj of objs.values()) {
+    for (const r of obj.relocs ?? []) {
+      taken.add(r.symbol);
+      addressed.set(r.symbol, obj.symbol);
+    }
+  }
   const bound = new Set([...sfn.params, ...sfn.locals].map((x) => x.name));
+  // …and the function's own parameters hide one too: a static's initializer is read in their scope.
+  // A local is declared after every static and hides none, but its name is the emitter's to move.
+  for (const [name, holder] of addressed) {
+    if (bound.has(name)) {
+      return {
+        symbol: holder,
+        refused: `whose initializer holds the address of '${name}', which a parameter or local here also names — it would hide that global`,
+      };
+    }
+  }
   const callees = new Set<string>([sfn.name]);
   for (const e of walkExprs(sfn.body)) {
     if (e.k === 'call' && typeof e.fn === 'string') {
@@ -342,6 +475,9 @@ export function nameLocalStatics(sfn: SFn, objs: LocalObjects): SFn | { symbol:
   const rename = new Map<string, string>();
   const bySource = new Map<string, string>();
   for (const obj of objs.values()) {
+    if (obj.anonymous) {
+      continue; // no source name: folded into a local's initializer at emission (l3/constinit.ts)
+    }
     const say = (why: string) => ({ symbol: obj.symbol, refused: `whose source name '${obj.name}' ${why}` });
     const other = bySource.get(obj.name);
     if (other !== undefined) {

package/src/structure/namecoalesce.ts

@@ -133,7 +133,7 @@ export interface NameCoalesceDeps {
   varName: ReadonlyMap<Value, string>;
   /** name → the type it is declared with */
   varType: ReadonlyMap<string, IrType>;
-  /** every natural loop, as its header and the blocks its body contains (structure/loops.ts) */
+  /** every natural loop, as its header and the blocks its body contains (ir/loops.ts) */
   loops: readonly { header: Block; body: ReadonlySet<Block> }[];
 }