@asmlift/core 0.8.1 → 0.10.0

package/src/l3/volstore.ts

@@ -92,9 +92,10 @@
 // both configurations and with any window. No row demands the read spelling, and a variation with no
 // inhabitant is what "earn the level" forbids.
 import { type IrType, T, scalarTypeForAccess } from '../ir/types';
-import { cellAddress, inRange } from './address';
-import { type Expr, type SFn, type Stmt, stmtChildren } from './ast';
+import { cellAddress, inRange, qualifiedBase } from './address';
+import { type Expr, type SFn, type Stmt, dotBase, stmtChildren } from './ast';
 import { type Gate, firstRejection } from './gates';
+import { derefStrideOk } from './typing';
 
 /** One STORE lvalue as the gates read it. */
 interface AccessCtx {
@@ -141,9 +142,6 @@ export const VOL_STORE_GATES: readonly Gate<AccessCtx>[] = [
   },
 ];
 
-/** Does this base already assert volatility — a `volatile` cast at any depth of the cast chain? */
-const qualifiedBase = (e: Expr): boolean => e.k === 'cast' && (e.volatile === true || qualifiedBase(e.e));
-
 /** The pointee the deref cast carries: the access's own scalar type. */
 const pointee = (ix: Extract<Expr, { k: 'index' }>): IrType => scalarTypeForAccess(ix.width, ix.signed);
 
@@ -169,8 +167,17 @@ function qualify(lval: Expr, window: readonly [number, number] | undefined): Exp
   if (firstRejection(VOL_STORE_GATES, ctx) !== null) {
     return lval;
   }
-  // An existing scalar pointer cast takes the qualifier in place; a bare const gets one minted,
-  // exactly the node backend/cfamily.ts's own deref legalization would have synthesized.
+  return qualifiedAccess(lval);
+}
+
+/** An indexed access with `volatile` on the pointee of its deref cast. An existing scalar pointer
+ *  cast takes the qualifier in place; a bare base gets one minted, exactly the node
+ *  backend/cfamily.ts's own deref legalization would have synthesized. Also how
+ *  {@link qualifiedMemoryAccess} spells an indexed access the lift marked `volatile`. */
+export function qualifiedAccess(lval: Extract<Expr, { k: 'index' }>): Extract<Expr, { k: 'index' }> {
+  if (qualifiedBase(lval.base)) {
+    return lval;
+  }
   const base: Expr =
     lval.base.k === 'cast' && lval.base.to.kind === 'ptr'
       ? { ...lval.base, volatile: true }
@@ -178,6 +185,88 @@ function qualify(lval: Expr, window: readonly [number, number] | undefined): Exp
   return { ...lval, base };
 }
 
+/** A memory access the lift marked `volatile` (frontend/device-pins.ts), spelled through a
+ *  `volatile` pointee: an indexed access by {@link qualifiedAccess}; a recovered struct member
+ *  through the struct pointer it is reached by — `((volatile struct S *)0x40000B0)[ch].field_0`,
+ *  `((volatile struct S *)p)->field_0` — whether that pointer is already a cast or a variable
+ *  `typeOf` types as one; and a union view through the member it views. A named global — `gSym`,
+ *  `gSym.field` — is returned unchanged, since its declaration owns its qualifiers. Null when the
+ *  pointer the access is reached by has no type to cast it to, for the caller to refuse rather
+ *  than drop the qualifier. */
+export function qualifiedMemoryAccess(e: Expr, typeOf: (x: Expr) => IrType | undefined): Expr | null {
+  if (e.k === 'index') {
+    return qualifiedAccess(e);
+  }
+  if (e.k !== 'field') {
+    return e;
+  }
+  const element = dotBase(e);
+  if (element !== undefined) {
+    const base = qualifiedPointer(element.base, typeOf);
+    return base === null ? null : { ...e, base: { ...element, base } };
+  }
+  if (e.dot === true) {
+    if (e.base.k !== 'field') {
+      return e;
+    }
+    const member = qualifiedMemoryAccess(e.base, typeOf);
+    return member === null ? null : { ...e, base: member };
+  }
+  const base = qualifiedPointer(e.base, typeOf);
+  return base === null ? null : { ...e, base };
+}
+
+/** Does this access reach the object it names through a pointer cast — one the tree spells,
+ *  `((struct T *)&gSym)->f`, or one the C-family printer puts on a base that does not stride the
+ *  access as spelled (backend/cfamily.ts `legalizedIndexBase`), `((u16 *)&gSym)[3]` — rather than
+ *  through the object's own name, element or member? The pointee of such a cast carries none of the
+ *  object's declared qualifiers unless it says so itself. `typeOf` is the rendered C type the
+ *  printer judges a base by. */
+export function castOffDeclaration(e: Expr, typeOf: (x: Expr) => IrType | undefined): boolean {
+  if (e.k === 'field') {
+    // A dot member over an element prints that element's base as spelled.
+    const element = dotBase(e);
+    if (element !== undefined) {
+      return addressCast(element.base, typeOf);
+    }
+    return e.dot === true ? castOffDeclaration(e.base, typeOf) : addressCast(e.base, typeOf);
+  }
+  if (e.k !== 'index') {
+    return false;
+  }
+  if (addressCast(e.base, typeOf)) {
+    return true;
+  }
+  if (e.lead !== undefined && e.lead.length > 0) {
+    return false; // a multidimensional global's subscript prints its base as spelled
+  }
+  return !derefStrideOk(
+    typeOf(e.base) ?? (e.baseElem !== undefined ? T.ptr(e.baseElem) : undefined),
+    e.width,
+    e.signed,
+  );
+}
+
+/** Is there a cast between this address and the object it is taken from: one on it, under its
+ *  arithmetic, or on the access whose element or member it is? */
+const addressCast = (p: Expr, typeOf: (x: Expr) => IrType | undefined): boolean =>
+  p.k === 'cast' ||
+  (p.k === 'bin' && (addressCast(p.l, typeOf) || addressCast(p.r, typeOf))) ||
+  ((p.k === 'index' || p.k === 'field') && castOffDeclaration(p, typeOf));
+
+/** A pointer expression carrying `volatile` on its pointee: a pointer cast takes it in place, and
+ *  any other pointer is cast to its own type with it. */
+function qualifiedPointer(p: Expr, typeOf: (x: Expr) => IrType | undefined): Expr | null {
+  if (qualifiedBase(p)) {
+    return p;
+  }
+  if (p.k === 'cast' && p.to.kind === 'ptr') {
+    return { ...p, volatile: true };
+  }
+  const t = typeOf(p);
+  return t?.kind === 'ptr' ? { k: 'cast', to: t, volatile: true, e: p } : null;
+}
+
 /** How many stores this tree would qualify — the enumeration gate, so a function with no device
  *  store costs one walk and no candidate.
  *

package/src/mangle.ts

@@ -129,6 +129,36 @@ export function demangle(sym: string): CppSig | null {
   return { name, cls, params };
 }
 
+/** How a class opens where gcc 2 names one: a length (`3Foo`), a nesting count (`Q21A1B`, and
+ *  `Q_12_` past nine levels) or a template (`t3Vec1Zi`). A member function's const and volatile
+ *  marks come before it (`get__C3Fooi`, `get__V3Fooi`, `get__CQ21A1Bi`), and CodeWarrior's class
+ *  opens the same way, its marks following the class (`getStartHour__11PlayerStateCFv`). */
+const GCC2_CLASS = String.raw`(?:\d|Q(?:\d|_\d+_)|t\d)`;
+
+/** How many argument words a C++ symbol may be handed ahead of its declared parameters: 1 where it
+ *  may name a MEMBER function, whose `this` the declared list leaves out; 0 where it cannot; and
+ *  `undefined` for a constructor or destructor, which may also take a flag no declaration states
+ *  (an in-charge or delete flag, beside `this`). Either mangling scheme a target here compiles with
+ *  puts the class right after the `__`, length-prefixed or `Q<n>`-nested: CodeWarrior's
+ *  `pick__3FooFiPi` (`__ct__3FooFv`, `__dt__3FooFv`), and gcc 2's `pick__3FooiPi` (a const method
+ *  `pick__C3FooiPi`, a volatile one `pick__V3FooiPi`, a constructor `__3Foo`, a destructor `_$_3Foo`
+ *  or `_._3Foo`, every one of which this abstains on, nested `_._Q21A1B` included), where a
+ *  TEMPLATE class is spelled `t<n><name><args>` in the class's place (`get__t3Vec1Zii`, a
+ *  constructor `__t3Vec1Zii`, `operator=` `__as__t3Vec1ZiRCt3Vec1Zi`). A free function (`f__Fii`)
+ *  and a plain C name answer 0. A STATIC member mangles as a method does and takes no
+ *  `this`, so 1 is "may", and a reader that needs the exact count must not take it as one.
+ *
+ *  THE PATTERNS ERR TOWARDS A MEMBER, because the errors cost differently: a method read as free
+ *  loses its `this` word, and the own-declaration bound (`proto.ts` `ownArgumentWords`) then turns
+ *  its last parameter into an uninitialised local, where a C name read as a method only leaves one
+ *  more register a parameter. */
+export function implicitArgumentWords(sym: string): 0 | 1 | undefined {
+  if (/^__(?:ct|dt)__/.test(sym) || new RegExp(`^__${GCC2_CLASS}`).test(sym) || /^_[$.]_/.test(sym)) {
+    return undefined;
+  }
+  return new RegExp(`__[CV]*${GCC2_CLASS}`).test(sym) ? 1 : 0;
+}
+
 /** A class qualifier off the front of `s` — `12RefCountable`, or `Q23zen17particleGenerator` for a
  *  nested one — as its scope names and the remaining string; null when `s` does not open with one. */
 function parseQualifier(s: string): { scopes: string[]; rest: string } | null {
@@ -178,7 +208,17 @@ export function demangledName(sym: string): string | null {
   return null;
 }
 
-/** Spell a CppType as C++ source (`Vec *`, `unsigned int`). */
+/** Spell a CppType as C++ source where no declarator is involved — a return type, a cast
+ *  (`Vec *`, `unsigned int`). */
 export function spellType(t: CppType): string {
   return t.base + (t.ptr ? ' ' + '*'.repeat(t.ptr) : '');
 }
+
+/** Declare a name of a CppType, C declarator rules: a pointer binds its `*` to the declarator
+ *  (`Vec *p`), everything else is the prefix `spellType name`. The C-family backend's `cDeclare`
+ *  says the same of an `IrType`; C++ has its own type vocabulary (`CppType`, from the mangled
+ *  name) and so needs its own declarator, or one function spells its pointers two ways — the type
+ *  prefix in the parameter list and the declarator form in the body. */
+export function declareCpp(t: CppType, name: string): string {
+  return t.ptr > 0 ? `${t.base} ${'*'.repeat(t.ptr)}${name}` : `${t.base} ${name}`;
+}