* Add intrinsic functions for wasm extensions

* add tests for decompiler

Author: ziad

.prettierignore

@@ -0,0 +1,6 @@
+lib/
+build/
+node_modules/
+playground/playground.bundle.js
+playground/playground.bundle.js.map
+generator/generated/

.prettierrc

@@ -0,0 +1,9 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "printWidth": 120,
+  "tabWidth": 2,
+  "semi": true,
+  "bracketSpacing": true,
+  "arrowParens": "always"
+}

playground/explorer.ts

@@ -3935,8 +3935,9 @@ export default class Explorer {
 
     if (this.moduleInfo.imports.length > 0) {
       const importTable = this.createInfoTable();
-      for (let importIndex = 0; importIndex < this.moduleInfo.imports.length; importIndex++) {
-        const importEntry = this.moduleInfo.imports[importIndex];
+      const sortedImports = this.moduleInfo.imports.map((entry, index) => ({ entry, index }));
+      sortedImports.sort((a, b) => a.entry.fieldName.localeCompare(b.entry.fieldName));
+      for (const { entry: importEntry, index: importIndex } of sortedImports) {
         const kindName = EXPORT_KIND_NAMES[importEntry.kind] || 'unknown';
         let signature = '';
         if (importEntry.kind === 0 && importEntry.typeIndex !== undefined && importEntry.typeIndex < flatTypes.length) {
@@ -3951,7 +3952,8 @@ export default class Explorer {
 
         const nameLink = document.createElement('a');
         nameLink.className = 'detail-info-link';
-        nameLink.style.flex = '0 0 140px';
+        nameLink.style.flex = '0 0 auto';
+        nameLink.style.maxWidth = '50%';
         nameLink.textContent = importEntry.fieldName;
         nameLink.title = `${importEntry.moduleName}.${importEntry.fieldName}`;
         nameLink.href = '#';
@@ -3994,8 +3996,9 @@ export default class Explorer {
 
     if (this.moduleInfo.exports.length > 0) {
       const exportTable = this.createInfoTable();
-      for (let exportIndex = 0; exportIndex < this.moduleInfo.exports.length; exportIndex++) {
-        const exportEntry = this.moduleInfo.exports[exportIndex];
+      const sortedExports = this.moduleInfo.exports.map((entry, index) => ({ entry, index }));
+      sortedExports.sort((a, b) => a.entry.name.localeCompare(b.entry.name));
+      for (const { entry: exportEntry, index: exportIndex } of sortedExports) {
         const kindName = EXPORT_KIND_NAMES[exportEntry.kind] || 'unknown';
         let signature = '';
         const targetSection = this.getExportTargetSection(exportEntry.kind);
@@ -4023,7 +4026,8 @@ export default class Explorer {
 
         const nameLink = document.createElement('a');
         nameLink.className = 'detail-info-link';
-        nameLink.style.flex = '0 0 140px';
+        nameLink.style.flex = '0 0 auto';
+        nameLink.style.maxWidth = '50%';
         nameLink.textContent = exportEntry.name;
         nameLink.title = exportEntry.name;
         nameLink.href = '#';
@@ -4143,8 +4147,8 @@ export default class Explorer {
       : 1;
 
     // Tier thresholds
-    const highThreshold = maxScore * 0.6;
-    const mediumThreshold = maxScore * 0.2;
+    const highThreshold = 150;
+    const mediumThreshold = 75;
     const highCount = entries.filter(entry => (entry.branchCount * 3 + entry.maxNestingDepth * 5 + entry.instructionCount) >= highThreshold).length;
     const medCount = entries.filter(entry => {
       const score = entry.branchCount * 3 + entry.maxNestingDepth * 5 + entry.instructionCount;

playground/playground.bundle.js

@@ -18,6 +18,11 @@ const valueTypeNames: Record<number, string> = {
   0x71: 'nullref',
   0x73: 'nullfuncref',
   0x72: 'nullexternref',
+  // Signed keys (readVarInt7 returns signed values for these)
+  [-1]: 'i32', [-2]: 'i64', [-3]: 'f32', [-4]: 'f64', [-5]: 'v128',
+  [-16]: 'funcref', [-17]: 'externref', [-18]: 'anyref', [-19]: 'eqref',
+  [-20]: 'i31ref', [-21]: 'structref', [-22]: 'arrayref',
+  [-15]: 'nullref', [-13]: 'nullfuncref', [-14]: 'nullexternref',
 };
 
 const blockTypeNames: Record<number, string> = {
@@ -290,6 +295,8 @@ export default class Disassembler {
     const names: Record<number, string> = {
       0x7f: 'i32', 0x7e: 'i64', 0x7d: 'f32', 0x7c: 'f64', 0x7b: 'v128',
       0x70: 'funcref', 0x6f: 'externref',
+      [-1]: 'i32', [-2]: 'i64', [-3]: 'f32', [-4]: 'f64', [-5]: 'v128',
+      [-16]: 'funcref', [-17]: 'externref',
     };
     return names[valueType] || `type_${valueType}`;
   }
@@ -369,7 +376,7 @@ export default class Disassembler {
         }
         case 1: { // table
           const tt = imp.tableType!;
-          const elemType = valueTypeNames[tt.elementType & 0xff] || 'anyfunc';
+          const elemType = valueTypeNames[tt.elementType] || 'anyfunc';
           const max = tt.maximum !== null ? ` ${tt.maximum}` : '';
           this.line(`(import ${mod} ${field} (table ${tt.initial}${max} ${elemType}))`);
           break;
@@ -546,7 +553,7 @@ export default class Disassembler {
   private writeTables(): void {
     for (let i = 0; i < this.module.tables.length; i++) {
       const t = this.module.tables[i];
-      const elemType = valueTypeNames[t.elementType & 0xff] || 'anyfunc';
+      const elemType = valueTypeNames[t.elementType] || 'anyfunc';
       const max = t.maximum !== null ? ` ${t.maximum}` : '';
       this.line(`(table (;${this.importedTableCount + i};) ${t.initial}${max} ${elemType})`);
     }

playground/playground.bundle.js.map

@@ -811,7 +811,7 @@ function parseDebugInfo(
         reader.readUint32(); // type_offset (4 bytes)
       }
       // Skip non-compile units entirely (type units, skeleton units, etc.)
-      if (unitType !== 0x01 && unitType !== 0x11) {
+      if (unitType !== 0x01) {
         reader.offset = unitEnd;
         continue;
       }
@@ -858,13 +858,29 @@ function parseDebugInfo(
         break;
       }
 
+      const attrStartOffset = reader.offset;
       const attrs = new Map<number, string | number | boolean | null>();
       for (const attrDef of abbrev.attributes) {
         const value = readAttrValue(reader, attrDef.form, addressSize, debugStr, debugLineStr, attrDef.implicitConst, unitStart, debugStrOffsets, strOffsetsBase);
         attrs.set(attrDef.attribute, value);
       }
 
       if (abbrev.tag === DW_TAG_compile_unit) {
+        // Extract str_offsets_base first — if non-zero, re-parse CU attributes with correct base
+        const strOffsetsBaseVal = attrs.get(DW_AT_str_offsets_base);
+        if (typeof strOffsetsBaseVal === 'number' && strOffsetsBaseVal !== strOffsetsBase) {
+          strOffsetsBase = strOffsetsBaseVal;
+          // Re-parse CU DIE attributes with the correct strOffsetsBase
+          const savedOffset = reader.offset;
+          reader.offset = attrStartOffset;
+          attrs.clear();
+          for (const attrDef of abbrev.attributes) {
+            const value = readAttrValue(reader, attrDef.form, addressSize, debugStr, debugLineStr, attrDef.implicitConst, unitStart, debugStrOffsets, strOffsetsBase);
+            attrs.set(attrDef.attribute, value);
+          }
+          reader.offset = savedOffset;
+        }
+
         const nameVal = attrs.get(DW_AT_name);
         if (typeof nameVal === 'string') { unitName = nameVal; }
         const producerVal = attrs.get(DW_AT_producer);
@@ -873,8 +889,6 @@ function parseDebugInfo(
         if (typeof langVal === 'number') { unitLanguage = langVal; }
         const compDirVal = attrs.get(DW_AT_comp_dir);
         if (typeof compDirVal === 'string') { unitCompDir = compDirVal; }
-        const strOffsetsBaseVal = attrs.get(DW_AT_str_offsets_base);
-        if (typeof strOffsetsBaseVal === 'number') { strOffsetsBase = strOffsetsBaseVal; }
       }
 
       if (abbrev.tag === DW_TAG_subprogram) {

src/Disassembler.ts

@@ -135,8 +135,10 @@ export function buildControlFlowGraph(instructions: DecodedInstruction[]): Contr
     }
 
     if (mnemonic === 'delegate') {
-      // delegate ends the current try scope. The depth immediate identifies which
-      // enclosing try block handles the exception — this is runtime behavior, not CFG structure.
+      // delegate terminates the current try block (pops one scope).
+      // The depth immediate identifies which enclosing try re-catches the exception —
+      // this affects runtime exception routing but not scope nesting.
+      // The delegate instruction itself acts like 'end' for the current try.
       if (scopeStack.length > 0) {
         const scope = scopeStack.pop()!;
         if (!scope.endTarget) {

src/DwarfParser.ts

@@ -273,7 +273,12 @@ export function emitLowered(
         } else {
           const addr = formatExpression(stmt.address, 0);
           const offsetStr = stmt.offset > 0 ? (addr === '0' ? String(stmt.offset) : `${addr} + ${stmt.offset}`) : addr;
-          emit(`memory[${offsetStr}] = ${formatExpression(stmt.value, 0)};`);
+          if (stmt.storeType.includes('v128') || stmt.storeType.includes('atomic')) {
+            const intrinsicName = stmt.storeType.replace(/\./g, '_');
+            emit(`${intrinsicName}(${offsetStr}, ${formatExpression(stmt.value, 0)});`);
+          } else {
+            emit(`memory[${offsetStr}] = ${formatExpression(stmt.value, 0)};`);
+          }
         }
         break;
       }
@@ -313,6 +318,15 @@ export function emitLowered(
     }
   }
 
+  function isIntrinsicOp(op: string): boolean {
+    return op.includes('x4_') || op.includes('x8_') || op.includes('x16_') || op.includes('x2_') ||
+           op.startsWith('v128_') || op.includes('atomic_') ||
+           op.startsWith('struct_') || op.startsWith('array_') ||
+           op.startsWith('table_') || op.startsWith('memory_') ||
+           op.startsWith('ref_') || op.startsWith('i31_') ||
+           op.startsWith('extern_') || op.startsWith('any_');
+  }
+
   function formatExpression(expr: Expression, parentPrec: number): string {
     switch (expr.kind) {
       case 'var':
@@ -334,6 +348,9 @@ export function emitLowered(
           const left = formatExpression(expr.left, prec);
           return maybeWrap(`${left} * ${multiplier}`, prec, parentPrec);
         }
+        if (isIntrinsicOp(expr.op)) {
+          return `${expr.op}(${formatExpression(expr.left, 0)}, ${formatExpression(expr.right, 0)})`;
+        }
         const unsigned = UNSIGNED_OPS[expr.op];
         if (unsigned) {
           const left = `(unsigned)${formatExpression(expr.left, PRECEDENCE['unary'])}`;
@@ -378,6 +395,11 @@ export function emitLowered(
         }
         const addr = formatExpression(expr.address, 0);
         const offsetStr = expr.offset > 0 ? (addr === '0' ? String(expr.offset) : `${addr} + ${expr.offset}`) : addr;
+        // SIMD/atomic loads emit as intrinsic calls
+        if (expr.loadType.includes('v128') || expr.loadType.includes('atomic')) {
+          const intrinsicName = expr.loadType.replace(/\./g, '_');
+          return `${intrinsicName}(${offsetStr})`;
+        }
         const loadCast = LOAD_TYPE_CAST[expr.loadType];
         if (loadCast) {
           return `(${loadCast})memory[${offsetStr}]`;

src/decompiler/ControlFlowGraph.ts

@@ -157,6 +157,10 @@ function transformStatement(statement: Statement, structBases: Set<string>): Sta
     case 'store': {
       const address = xExpr(statement.address);
       const value = xExpr(statement.value);
+      // Skip struct/array pattern detection for v128 and atomic stores
+      if (statement.storeType.includes('v128') || statement.storeType.includes('atomic')) {
+        return { kind: 'store', address, offset: statement.offset, storeType: statement.storeType, value };
+      }
       // Struct field store: base + const where base is a struct pointer
       const structStore = tryStructAccess(address, statement.offset, structBases);
       if (structStore) {
@@ -205,6 +209,10 @@ function transformExpr(expression: Expression, structBases: Set<string>): Expres
   switch (expression.kind) {
     case 'load': {
       const address = xExpr(expression.address);
+      // Skip struct/array pattern detection for v128 and atomic loads
+      if (expression.loadType.includes('v128') || expression.loadType.includes('atomic')) {
+        return { kind: 'load', address, offset: expression.offset, loadType: expression.loadType };
+      }
       // Struct field access: base + const where base is a struct pointer
       const structAccess = tryStructAccess(address, expression.offset, structBases);
       if (structAccess) {