watr 4.5.3 → 4.6.1

package/types/src/optimize.d.ts

@@ -67,11 +67,6 @@ export function strength(ast: any[]): any[];
  * @returns {Array}
  */
 export function branch(ast: any[]): any[];
-/**
- * Propagate values through locals and eliminate single-use/dead locals.
- * Constants propagate to all uses; pure single-use exprs inline into get site.
- * Multi-pass with batch counting for convergence.
- */
 export function propagate(ast: any): any;
 /**
  * Inline tiny functions (single expression, no locals, no params or simple params).
@@ -79,6 +74,36 @@ export function propagate(ast: any): any;
  * @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.
+ *
+ * `(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}
+ */
+export function inlineOnce(ast: any[]): any[];
 /**
  * Normalize options to { opt: bool } map.
  * @param {boolean|string|Object} opts
@@ -95,11 +120,15 @@ export namespace OPTS {
     let branch: boolean;
     let propagate: boolean;
     let inline: boolean;
+    let inlineOnce: boolean;
     let vacuum: boolean;
+    let mergeBlocks: boolean;
+    let coalesce: boolean;
     let peephole: boolean;
     let globals: boolean;
     let offset: boolean;
     let unbranch: boolean;
+    let loopify: boolean;
     let stripmut: boolean;
     let brif: boolean;
     let foldarms: boolean;
@@ -123,7 +152,14 @@ export function vacuum(ast: any[]): any[];
  */
 export function peephole(ast: any[]): any[];
 /**
- * Replace global.get of immutable globals with their constant init values.
+ * Replace `global.get` of an immutable, const-initialised global with the
+ * constant — but only when it doesn't grow the module. A `global.get` costs
+ * ~2 B; an `i32.const 12345` costs 4 B; an `f64.const` costs 9 B. Naively
+ * inlining a big constant read from many sites trades a few cheap reads + one
+ * global decl for many fat immediates — pure bloat (and the node-count size
+ * guard can't see it: same number of AST nodes). So we only propagate a global
+ * when `refs·constSize ≤ refs·2 + declSize`; when every read is replaced and
+ * the global isn't exported, its now-dead decl is dropped here too.
  * @param {Array} ast
  * @returns {Array}
  */
@@ -136,6 +172,31 @@ export function offset(ast: any): any;
  * @returns {Array}
  */
 export function unbranch(ast: any[]): any[];
+/**
+ * Collapse the `while`-emit idiom into a single loop.
+ *
+ *   (block $A
+ *     (loop $B
+ *       (br_if $A (i32.eqz cond))   ;; exit when cond is false
+ *       …body…
+ *       (br $B)                      ;; continue
+ *     ))
+ *
+ * becomes
+ *
+ *   (loop $B
+ *     (if cond (then …body… (br $B))))
+ *
+ * Saves ~3 B per while-loop (drop the outer block framing + the `i32.eqz`,
+ * trade `br_if`→`if`). Safe only when:
+ *  - the block contains nothing but the loop (plus optional `type` slot),
+ *  - block / loop are void (no result),
+ *  - $A is never targeted from within body (only the head `br_if` uses it).
+ *
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function loopify(ast: any[]): any[];
 /**
  * Strip mutability from globals that are never written.
  * Enables globals constant-propagation for more globals.
@@ -186,5 +247,45 @@ export function packData(ast: any[]): any[];
  * @returns {Array}
  */
 export function minifyImports(ast: any[]): any[];
+/**
+ * Unwrap redundant blocks whose label is never targeted. The block's stack
+ * effect is determined entirely by its body, so removing the `block`/`end`
+ * framing is sound as long as no `br` reaches into the block from inside.
+ *
+ * Two complementary patterns:
+ *
+ * 1. **Block at scope level** (sibling in `func`/`block`/`loop`/`then`/`else`):
+ *    splice body into the parent scope. Works for untyped, `(result T)`-typed,
+ *    or even `(param …)`-typed blocks — in all cases the body produces the
+ *    same net stack effect as the framed block did, at the same position.
+ * 2. **Result-typed block in expression position** (`(block (result T) expr)`
+ *    as the value of some operand): collapse to `expr` if the body is a
+ *    single value expression. Catches the wrappers jz codegen leaves around
+ *    arena allocations once `propagate` has folded the intermediate
+ *    set/get pairs to a single call.
+ *
+ * Pattern 2 runs first (post-order) so pattern 1 sees the cleaned-up parents.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function mergeBlocks(ast: any[]): any[];
+/**
+ * Share local slots between same-type locals with non-overlapping live ranges.
+ * Live range = [first pos, last pos] of any local.get/set/tee, extended over
+ * any loop containing a reference (so a value read across loop iterations stays
+ * intact). Greedy slot assignment by start position. Params and unnamed/numeric
+ * references are left alone; `localReuse` later removes the renamed-away decls.
+ *
+ * Soundness: WASM zero-initializes locals at function entry, so a local whose
+ * first reference (in walk order) is a `local.get` *relies* on that implicit
+ * zero — coalescing it into a slot whose previous user left a non-zero residue
+ * would silently change behavior (e.g. a `for (let i=0; …)` loop counter
+ * inheriting `N*4` from a sibling temp). Such "read-first" locals can still
+ * serve as a slot's *primary* (the slot then keeps the function's zero start),
+ * but can never be a donor merged into an existing slot.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function coalesceLocals(ast: any[]): any[];
 export { count as size };
 //# sourceMappingURL=optimize.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAuhEA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAkE/B;AArjED;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAIlB;AAwGD;;;;;GAKG;AACH,6CAgJC;AA6ID;;;;GAIG;AACH,wCAwBC;AAoMD;;;;GAIG;AACH,4CAqBC;AA+CD;;;;;GAKG;AACH,8CAmDC;AA7QD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CAuCC;AA6VD;;;;GAIG;AACH,yCAsBC;AAID;;;;GAIG;AACH,0CAiGC;AAvjCD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAa/B;;;;;;;;;;;;;;;;;;;;;;;;;AA4iCD;;;;;GAKG;AACH,0CAgDC;AAyED;;;;GAIG;AACH,4CAQC;AAID;;;;GAIG;AACH,2CAyCC;AAID,2EAA2E;AAC3E,sCAgEC;AAID;;;;GAIG;AACH,4CAuCC;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"}
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAonFA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAkF/B;AA9pFD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAIlB;AAwGD;;;;;GAKG;AACH,6CAgJC;AA2KD;;;;GAIG;AACH,wCAwBC;AAoMD;;;;GAIG;AACH,4CAqBC;AA+CD;;;;;GAKG;AACH,8CAmDC;AA7QD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CAuCC;AAgYD,yCAoCC;AAID;;;;GAIG;AACH,0CAiGC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8CAgKC;AAp0CD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAa/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAugDD;;;;;GAKG;AACH,0CAgDC;AAyED;;;;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;AAnoCD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,+CA2CC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDAyFC"}