@asmlift/core 0.8.1 → 0.10.0

package/src/raise/recover.ts

@@ -2,8 +2,9 @@
 // (signed comparisons/divisions ⇒ signed operands), types memory-access bases as pointers,
 // propagates pointer-ness across the SSA, then defaults the rest to s32. Emits recovered
 // types onto the SSA values in place.
-import { Fn, Value, defOpMap } from '../ir/core';
+import { Fn, RETURNS_OBJECT, Value, defOpMap } from '../ir/core';
 import { IrType, T, scalarTypeForAccess, typeEquals } from '../ir/types';
+import { storeSigned } from './storesign';
 
 const SIGNED_CMP = new Set(['icmp_slt', 'icmp_sle', 'icmp_sgt', 'icmp_sge']);
 const UNSIGNED_CMP = new Set(['icmp_ult', 'icmp_ule', 'icmp_ugt', 'icmp_uge']);
@@ -30,7 +31,7 @@ export function recoverTypes(fn: Fn): void {
   seedSignednessFromOpcodes(fn);
   typeDerefBases(fn);
   propagatePointers(fn);
-  defaultUnknownsToS32(fn);
+  defaultUnknowns(fn);
 }
 
 /** PHASE 1 — signedness from op semantics: the operands of a signed comparison are signed integers,
@@ -87,7 +88,7 @@ function typeDerefBases(fn: Fn): void {
           break;
         case 'store':
           width = op.attrs.width as number;
-          signed = width === 4;
+          signed = storeSigned(op, width);
           break;
         case 'aload':
           width = op.attrs.elemSize as number;
@@ -95,9 +96,7 @@ function typeDerefBases(fn: Fn): void {
           break;
         case 'astore':
           width = op.attrs.elemSize as number;
-          // an astore carries no signedness of its own unless a recovery recorded the member's;
-          // structure.ts reads it by the same rule
-          signed = (op.attrs.signed as boolean | undefined) ?? width === 4;
+          signed = storeSigned(op, width);
           break;
         default:
           continue;
@@ -115,20 +114,24 @@ function typeDerefBases(fn: Fn): void {
 // incoming `a0`) and a `p = p + stride` walk, so those values stay `unknown` and phase 4 would
 // spell them `int` — an `int→int*` assignment mwcc/agbcc REJECT (gcc warns).
 
-/** PHASE 4 — default every still-unknown value to s32. This is a COMPILER default (agbcc/IDO/GCC
- *  all take plain `int` as the integer default), not a hardware fact — applied uniformly. */
-function defaultUnknownsToS32(fn: Fn): void {
+/** PHASE 4 — default every still-unknown value to SIGNED, at its own width. Signedness is a
+ *  COMPILER default (agbcc/IDO/GCC all take plain `int` as the integer default), not a hardware
+ *  fact, and it is applied uniformly. The WIDTH is not a default at all: it is what the value was
+ *  built at, and a 64-bit value retyped `s32` here would be silently truncated by the first pass
+ *  that believed the type. `setInt` above already defaults this way. */
+function defaultUnknowns(fn: Fn): void {
+  const settle = (v: { type: IrType }) => {
+    if (v.type.kind === 'unknown') {
+      v.type = T.int(v.type.width, true);
+    }
+  };
   for (const b of fn.blocks) {
     for (const p of b.params) {
-      if (p.type.kind === 'unknown') {
-        p.type = T.s(32);
-      }
+      settle(p);
     }
     for (const op of b.ops) {
       for (const r of op.results) {
-        if (r.type.kind === 'unknown') {
-          r.type = T.s(32);
-        }
+        settle(r);
       }
     }
   }
@@ -246,6 +249,14 @@ export function returnType(fn: Fn): IrType {
     const term = b.ops[b.ops.length - 1];
     if (term?.opcode === 'ret' && term.operands.length > 0) {
       const v = term.operands[0];
+      // the function's own struct return object, handed back whole (ir/core.ts `RETURNS_OBJECT`)
+      if (term.attrs[RETURNS_OBJECT] === true && v.type.kind === 'ptr') {
+        return v.type.to;
+      }
+      // a struct a call returned by value, handed back whole (frontend/register-struct-call.ts)
+      if (v.type.kind === 'struct') {
+        return v.type;
+      }
       // A NARROW value in the return register does not make the DECLARED return type narrow: the
       // register is a word, and the value's width says how it was COMPUTED, not what the header
       // spelled. The two readings compile alike through agbcc and do NOT through mwcc —