watr 4.5.3 → 4.6.0

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,7 +120,10 @@ 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;
@@ -123,7 +151,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}
  */
@@ -186,5 +221,32 @@ export function packData(ast: any[]): any[];
  * @returns {Array}
  */
 export function minifyImports(ast: any[]): any[];
+/**
+ * Unwrap redundant `(block $L body)` whose label is never targeted, splicing
+ * the body into the surrounding scope. Skips blocks with `param`/`result`/`type`
+ * annotations (their stack effect would change). Each unwrap drops the
+ * `block`+`end` framing bytes; iterates by walk so chained blocks collapse.
+ * @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":"AAs+EA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAiF/B;AAhhFD;;;;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;AAgYD,yCAoCC;AAID;;;;GAIG;AACH,0CAiGC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8CAgKC;AAtyCD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAa/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAu8CD;;;;;GAKG;AACH,0CAgDC;AAyED;;;;GAIG;AACH,4CAQC;AA4BD;;;;;;;;;;;GAWG;AACH,2CAyDC;AAID,2EAA2E;AAC3E,sCAgEC;AAID;;;;GAIG;AACH,4CAyCC;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;AAphCD;;;;;;;GAOG;AACH,+CAsBC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDAyFC"}