watr 4.6.10 → 4.7.0

package/types/src/compile.d.ts

@@ -2,7 +2,11 @@
  * Converts a WebAssembly Text Format (WAT) tree to a WebAssembly binary format (WASM).
  *
  * @param {string|Array} nodes - The WAT tree or string to be compiled to WASM binary.
- * @returns {Uint8Array} The compiled WASM binary data.
+ * @returns {Uint8Array} The compiled WASM binary. When the WAT carries
+ *   `@metadata.code.<type>` annotations, the result also exposes a `.metadata`
+ *   property — `{ [type]: [[absoluteByteOffset, data], ...] }`, each offset the
+ *   instruction's position in the final binary. That's the hook a source-map
+ *   emitter needs to correlate generated wasm back to its source.
  */
 export default function compile(nodes: string | any[]): Uint8Array;
 //# sourceMappingURL=compile.d.ts.map

package/types/src/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AAuCA;;;;;GAKG;AACH,uCAHW,MAAM,QAAM,GACV,UAAU,CA8NtB"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AAuCA;;;;;;;;;GASG;AACH,uCAPW,MAAM,QAAM,GACV,UAAU,CAkRtB"}

package/types/src/optimize.d.ts

@@ -1,16 +1,4 @@
-/**
- * Optimize AST.
- *
- * @param {Array|string} ast - AST or WAT source
- * @param {boolean|string|Object} [opts=true] - Optimization options
- * @returns {Array} Optimized AST
- *
- * @example
- * optimize(ast)                      // all optimizations
- * optimize(ast, 'treeshake')         // only treeshake
- * optimize(ast, { fold: true })      // explicit
- */
-export default function optimize(ast: any[] | string, opts?: boolean | string | any): any[];
+export default function optimize(ast: any, opts?: boolean): any;
 /**
  * Recursively count AST nodes — fast size heuristic without compiling.
  * @param {any} node
@@ -68,42 +56,36 @@ export function strength(ast: any[]): any[];
  */
 export function branch(ast: any[]): any[];
 export function propagate(ast: any): any;
+export function inline(ast: any, { simdOnly }?: {
+    simdOnly?: boolean;
+}): any;
+export function inlineOnce(ast: any): any;
 /**
- * Inline tiny functions (single expression, no locals, no params or simple params).
- * @param {Array} ast
- * @returns {Array}
- */
-export function inline(ast: any[]): any[];
-/**
- * Inline functions that are called from exactly one place into their lone caller,
- * then delete them. Unlike {@link inline} (which duplicates tiny stateless bodies),
- * this never duplicates code and never inflates: each inlined function drops a
- * function-section entry, a type-section entry (if now unused), and a `call`
- * instruction, paying back only a `block`/`local.set` wrapper. This is what
- * `wasm-opt -Oz` does — collapsing helper chains down to a couple of functions —
- * and it's the bulk of the gap between hand-tuned WASM and naive codegen.
- *
- * A function `$f` qualifies when it is, all of:
- *  • named, with named params and locals (numeric indices can't be safely renamed);
- *  • referenced exactly once across the whole module, by a plain `call` (no
- *    `return_call`, `ref.func`, `elem`, `export`, or `start` reference, and not
- *    recursive);
- *  • single-result or void (a multi-value result can't be modeled as `(block (result …))`);
- *  • free of numeric (depth-relative) branch labels — those would shift under the
- *    extra block nesting — and of `return_call*` in its body.
+ * Devirtualize `call_indirect` through NaN-boxed closure values with a statically
+ * known candidate set. `let f = c ? a : b; … f(x)` emits a select of two i64
+ * closure constants into an f64 local; every call site then derives the table
+ * slot from that local's bits:
+ *   (i32.wrap_i64 (i64.and (i64.shr_u (i64.reinterpret_f64 (local.get $f))
+ *                                     (i64.const 32)) (i64.const 32767)))
+ * When EVERY write to $f in the function is such a constant set (≤2 candidates),
+ * each call site becomes a guarded direct call —
+ *   (if (result …) (i64.eq (i64.reinterpret_f64 (local.get $f)) (i64.const C1))
+ *     (then (call $tramp1 …args)) (else <next guard | original call_indirect>))
+ * — with the ORIGINAL call_indirect kept as the final arm, so unknown flows
+ * (zero-init paths the analysis can't see) behave exactly as before: the rewrite
+ * is a pure branch-predicted fast path, ~25% on callback loops, and the direct
+ * calls participate in inlining. A trivially-constant slot ((i32.const N) after
+ * fold) becomes a bare direct call with no guard.
  *
- * `(call $f a0 a1 …)` becomes
- *   (block $__inlN (result T)?
- *     (local.set $__inlN_p0 a0) (local.set $__inlN_p1 a1) …   ;; args evaluated once, in order
- *     …body, params/locals renamed to $__inlN_*, `return X` → `br $__inlN X`…)
- * and the renamed params+locals are appended to the caller's `local` decls; the
- * body's own block/loop/if labels are renamed too so they can't shadow the caller's.
- * Runs to a fixpoint so helper chains fully collapse.
- *
- * @param {Array} ast
- * @returns {Array}
+ * Soundness: the guard compares the SAME bits the slot extraction reads, so
+ * whichever constant flows to the call dispatches identically in both forms;
+ * candidates that don't resolve to an elem entry (or whose target's signature
+ * differs from the call's type — would-be runtime trap) disable the site. Any
+ * table mutation op in the module disables the pass entirely. The function
+ * table is exported for host-side closure invocation (reads); host mutation of
+ * it is outside the ABI contract, same as the closure-constant model itself.
  */
-export function inlineOnce(ast: any[]): any[];
+export function devirt(ast: any): any;
 /**
  * Normalize options to a { passName: bool } map. An explicit object is kept
  * as-is (preserving `log`/`verbose`), with any unmentioned pass filled to its

package/types/src/optimize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAs2FA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAmE/B;AAh6FD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAIlB;AA8CD;;;;;GAKG;AACH,6CAgJC;AAuMD;;;;GAIG;AACH,wCAuBC;AAoMD;;;;GAIG;AACH,4CAqBC;AA+CD;;;;;GAKG;AACH,8CAmDC;AA7QD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CAuCC;AAggBD,yCAoCC;AAID;;;;GAIG;AACH,0CAgGC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8CAmOC;AAyzCD;;;;;;;;GAQG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAc/B;AAvBD,qEAAqE;AACrE,uBAA8D;AAljC9D;;;;;GAKG;AACH,0CAgDC;AAwED;;;;GAIG;AACH,4CAQC;AA4BD;;;;;;;;;;;GAWG;AACH,2CAyDC;AAID,2EAA2E;AAC3E,sCAgEC;AAID;;;;GAIG;AACH,4CAyCC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CAiDC;AAID;;;;;GAKG;AACH,4CAqBC;AAID;;;;;;GAMG;AACH,wCAmBC;AAID;;;;;GAKG;AACH,4CAiDC;AAoCD;;;;;GAKG;AACH,0CA8DC;AAiWD,uCAyBC;AAtXD;;;;;GAKG;AACH,8CAyEC;AAoID;;;;GAIG;AACH,4CAyDC;AAqBD;;;;;GAKG;AACH,iDAgBC;AA9qCD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAiFC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDAyFC"}
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAyxHA,gEAyFC;AA9zHD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAIlB;AA8CD;;;;;GAKG;AACH,6CAgJC;AAwUD;;;;GAIG;AACH,wCAkDC;AA0YD;;;;GAIG;AACH,4CAqBC;AA+CD;;;;;GAKG;AACH,8CAmDC;AAndD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CAwDC;AAID;;;;GAIG;AACH,0CA6CC;AAuyBD,yCAqCC;AAmND;;QAqEC;AAySD,0CAgJC;AArbD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAwOC;AAghDD;;;;;;;;GAQG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAc/B;AAvBD,qEAAqE;AACrE,uBAA8D;AArlC9D;;;;;GAKG;AACH,0CA8DC;AA+ED;;;;GAIG;AACH,4CAQC;AAiCD;;;;;;;;;;;GAWG;AACH,2CAyDC;AAID,2EAA2E;AAC3E,sCAgEC;AAID;;;;GAIG;AACH,4CAyCC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CAiDC;AAID;;;;;GAKG;AACH,4CAqBC;AAID;;;;;;GAMG;AACH,wCAmBC;AAID;;;;;GAKG;AACH,4CAiDC;AAoCD;;;;;GAKG;AACH,0CA8DC;AAwWD,uCAyBC;AA7XD;;;;;GAKG;AACH,8CAyEC;AA2ID;;;;GAIG;AACH,4CAyDC;AAqBD;;;;;GAKG;AACH,iDAgBC;AA/sCD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAiFC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDAyFC"}