watr 4.7.0 → 4.7.2

package/dist/watr.js

@@ -1381,7 +1381,7 @@ var cleanup = (node, result) => {
   result.loc = node.loc;
   return result.length === 1 && result[0]?.[0] === "module" ? result[0] : result;
 };
-function compile(nodes) {
+function assemble(nodes, sizeOnly) {
   if (typeof nodes === "string") err.src = nodes, nodes = parse_default(nodes) || [];
   else err.src = "";
   err.loc = 0;
@@ -1389,8 +1389,11 @@ function compile(nodes) {
   let idx = 0;
   if (nodes[0] === "module") idx++, isId(nodes[idx]) && idx++;
   else if (typeof nodes[0] === "string") nodes = [nodes];
-  if (nodes[idx] === "binary") return Uint8Array.from(nodes.slice(++idx).flat());
-  if (nodes[idx] === "quote") return compile(nodes.slice(++idx).map((v) => v.valueOf().slice(1, -1)).flat().join(""));
+  if (nodes[idx] === "binary") {
+    const b = Uint8Array.from(nodes.slice(++idx).flat());
+    return sizeOnly ? b.length : b;
+  }
+  if (nodes[idx] === "quote") return assemble(nodes.slice(++idx).map((v) => v.valueOf().slice(1, -1)).flat().join(""), sizeOnly);
   nodes = nodes.flatMap((n, i) => {
     if (i < idx || !Array.isArray(n) || n[0] !== "import") return [n];
     const [, mod, ...rest] = n;
@@ -1503,6 +1506,32 @@ function compile(nodes) {
   };
   const globalSection = bin(SECTION.global);
   const elemSection = bin(SECTION.elem);
+  if (sizeOnly) {
+    const codeSizes = ctx.code.filter(Boolean).map((item) => codeItemSize(item, ctx));
+    const innerLen = codeSizes.length ? ulebSize(codeSizes.length) + codeSizes.reduce((a, b) => a + b, 0) : 0;
+    const codeSecLen = codeSizes.length ? 1 + ulebSize(innerLen) + innerLen : 0;
+    const metaSection2 = binMeta();
+    const dataSection2 = bin(SECTION.data);
+    const stringsSection2 = ctx.strings.length ? [SECTION.strings, ...vec([0, ...vec(ctx.strings.map((s) => vec(s)))])] : [];
+    const others = [
+      bin(SECTION.custom),
+      bin(SECTION.type),
+      bin(SECTION.import),
+      bin(SECTION.func),
+      bin(SECTION.table),
+      bin(SECTION.memory),
+      bin(SECTION.tag),
+      stringsSection2,
+      globalSection,
+      bin(SECTION.export),
+      bin(SECTION.start, false),
+      elemSection,
+      bin(SECTION.datacount, false),
+      metaSection2,
+      dataSection2
+    ];
+    return 8 + codeSecLen + others.reduce((s, sec) => s + sec.length, 0);
+  }
   const codeItems = ctx.code.filter(Boolean).map((item) => build[SECTION.code](item, ctx)).filter(Boolean);
   const codeSection = codeItems.length ? [SECTION.code, ...vec(vec(codeItems))] : [];
   const metaSection = binMeta();
@@ -1566,6 +1595,12 @@ function compile(nodes) {
     return out;
   }
 }
+function compile(nodes) {
+  return assemble(nodes);
+}
+function size(nodes) {
+  return assemble(nodes, true);
+}
 var isIdx = (n) => n?.[0] === "$" || !isNaN(n);
 var isId = (n) => n?.[0] === "$";
 var isMemParam = (n) => n?.[0] === "a" || n?.[0] === "o";
@@ -2105,6 +2140,62 @@ var instr = (nodes, ctx) => {
   }
   return out.push(11), out;
 };
+var ulebSize = (n) => uleb(n).length;
+var instrSize = (nodes, ctx) => {
+  let size2 = 0, meta = [];
+  while (nodes?.length) {
+    let op = nodes.shift();
+    if (op?.[0] === "@metadata") {
+      meta.push(op.slice(1));
+      continue;
+    }
+    if (Array.isArray(op)) {
+      op.loc != null && (err.loc = op.loc);
+      err(`Unknown instruction ${op[0]}`);
+    }
+    const opc = INSTR[op] || err(`Unknown instruction ${op}`);
+    let n = opc.length;
+    if (HANDLER[op]) n += HANDLER[op](nodes, ctx, op).length;
+    if (meta.length) {
+      for (const [type, data] of meta) (ctx.meta[type] ??= []).push([size2, data]);
+      meta = [];
+    }
+    size2 += n;
+  }
+  return size2 + 1;
+};
+var codeItemSize = (body, ctx) => {
+  let [typeidx, param] = body.shift();
+  if (!param) [, [param]] = ctx.type[id(typeidx, ctx.type)];
+  ctx.local = Object.create(param);
+  ctx.block = [];
+  ctx.local.name = "local";
+  ctx.block.name = "block";
+  if (ctx._codeIdx === void 0) ctx._codeIdx = 0;
+  let codeIdx = ctx._codeIdx++;
+  while (body[0]?.[0] === "local") {
+    let [, ...types] = body.shift();
+    if (isId(types[0])) {
+      let nm = types.shift();
+      if (nm in ctx.local) err(`Duplicate local ${nm}`);
+      else ctx.local[nm] = ctx.local.length;
+    }
+    ctx.local.push(...types);
+  }
+  ctx.meta = {};
+  const bytesLen = instrSize(body, ctx);
+  let loctypes = ctx.local.slice(param.length).reduce((a, type) => (type == a[a.length - 1]?.[1] ? a[a.length - 1][0]++ : a.push([1, type]), a), []);
+  const locals = vec(loctypes.map(([n, t]) => [...uleb(n), ...reftype(t, ctx)]));
+  const funcIdx = ctx.import.filter((imp) => imp[2][0] === "func").length + codeIdx;
+  for (const type in ctx.meta) {
+    for (const inst of ctx.meta[type]) inst[0] += locals.length;
+    ((ctx.metadata ??= {})[type] ??= []).push([funcIdx, ctx.meta[type]]);
+  }
+  ctx.local = ctx.block = ctx.meta = null;
+  const bodyLen = locals.length + bytesLen;
+  (ctx.codeSizePrefix ??= [])[codeIdx] = ulebSize(bodyLen);
+  return ulebSize(bodyLen) + bodyLen;
+};
 var expr = (node, ctx) => instr(normalize([node], ctx), ctx);
 var id = (nm, list, n) => (n = isId(nm) ? list[nm] : +nm, n in list ? n : err(`Unknown ${list.name} ${nm}`));
 var blockid = (nm, block, i) => (i = isId(nm) ? block.length - block[nm] : +nm, isNaN(i) || i > block.length ? err(`Bad label ${nm}`) : i);
@@ -2671,11 +2762,11 @@ var gc = (ast, ctx) => {
   ];
   ast.push(allocFunc);
   const structSize = (typeDef) => {
-    let size = 4;
+    let size2 = 4;
     for (const f of typeDef.fields) {
-      size += TYPE_SIZES[f.type] || 4;
+      size2 += TYPE_SIZES[f.type] || 4;
     }
-    return size;
+    return size2;
   };
   const fieldOffset = (typeDef, fieldIdx) => {
     let offset2 = 4;
@@ -2732,12 +2823,12 @@ var gc = (ast, ctx) => {
       const typeId = node[1];
       const typeDef = types.get(typeId);
       if (!typeDef || typeDef.kind !== "struct") return;
-      const size = structSize(typeDef);
+      const size2 = structSize(typeDef);
       const typeTag = typeIndices.get(typeId);
       const args = node.slice(2);
       const ptrLocal = "$__gc_ptr";
       const stores = [
-        ["local.set", ptrLocal, ["call", allocId, ["i32.const", size]]],
+        ["local.set", ptrLocal, ["call", allocId, ["i32.const", size2]]],
         ["i32.store", ["local.get", ptrLocal], ["i32.const", typeTag]]
         // store type tag
       ];
@@ -3118,7 +3209,7 @@ var resultType2 = (op) => {
 };
 var binarySize = (ast) => {
   try {
-    return compile(ast).length;
+    return size(ast);
   } catch {
     return Infinity;
   }
@@ -4500,7 +4591,7 @@ var buildInline = (params, locals, inlResult, cBody, args) => {
 };
 var INLINE_MAX_NODES = 90;
 var isV128SimdHelper = (params, inlResult) => inlResult === "v128" && params.length > 0 && params.every((p) => p.type === "v128");
-var inline = (ast, { simdOnly = false } = {}) => {
+var inline = (ast, { simdOnly = false, pin = EMPTY_SET } = {}) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
   const skip = /* @__PURE__ */ new Set();
   for (let round = 0; round < MAX_INLINE_ROUNDS; round++) {
@@ -4520,7 +4611,7 @@ var inline = (ast, { simdOnly = false } = {}) => {
     for (const n of ast) if (!Array.isArray(n) || n[0] !== "func") inlCollectPinned(n, pinned);
     let calleeName = null, parsed = null;
     for (const [name2, fn] of funcByName) {
-      if (skip.has(name2) || pinned.has(name2) || otherRef.has(name2) || SIMD_PROTECTED.has(name2)) continue;
+      if (skip.has(name2) || pinned.has(name2) || otherRef.has(name2) || pin.has(name2)) continue;
       if (!(callRefs.get(name2) >= 1)) continue;
       if (inlBodySize(fn) > INLINE_MAX_NODES) continue;
       if (inlCallsSelf(fn, name2)) continue;
@@ -4789,8 +4880,7 @@ var devirt = (ast) => {
   }
   return ast;
 };
-var SIMD_PROTECTED = /* @__PURE__ */ new Set(["$math.sin_core", "$math.cos_core", "$math.sin", "$math.cos", "$math.pow", "$math.atan2", "$math.hypot", "$math.log"]);
-var inlineOnce = (ast) => {
+var inlineOnce = (ast, { pin = EMPTY_SET } = {}) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
   const bodyStart = inlBodyStart, callsSelf = inlCallsSelf, unsafe = inlUnsafe, isBranch = inlIsBranch;
   const zeroFor = inlZeroFor, needsReset = inlNeedsReset;
@@ -4812,7 +4902,7 @@ var inlineOnce = (ast) => {
     for (const [name2, fn] of funcByName) {
       if (pinned.has(name2) || otherRef.has(name2)) continue;
       if (callRefs.get(name2) !== 1) continue;
-      if (SIMD_PROTECTED.has(name2)) continue;
+      if (pin.has(name2)) continue;
       if (callsSelf(fn, name2)) continue;
       let ok = true, nResult = 0;
       for (let i = 2; i < fn.length; i++) {
@@ -5999,13 +6089,14 @@ function optimize(ast, opts = true) {
   if (typeof ast === "string") ast = parse_default(ast);
   const strictGuard = opts === true;
   opts = normalize3(opts);
+  opts.pin = opts.pin instanceof Set ? opts.pin : new Set(opts.pin || []);
   const log = opts.log ? (msg, delta) => opts.log(msg, delta) : () => {
   };
   const verbose = opts.verbose || opts.log;
   ast = clone2(ast);
   const runInline = (a) => {
     if (!opts.inline) return a;
-    a = inline(a, { simdOnly: opts.inline === "simd" });
+    a = inline(a, { simdOnly: opts.inline === "simd", pin: opts.pin });
     if (opts.propagate) a = propagate(a);
     if (opts.mergeBlocks) a = mergeBlocks(a);
     if (opts.vacuum) a = vacuum(a);
@@ -6019,7 +6110,7 @@ function optimize(ast, opts = true) {
   if (!((opts.inlineOnce || opts.inline) && mayInline(ast))) {
     for (let round = 0; round < 3; round++) {
       const beforeRound2 = clone2(ast);
-      for (const [key, fn] of PASSES) if (opts[key] && key !== "inlineOnce" && key !== "inline" && key !== "devirt") ast = fn(ast);
+      for (const [key, fn] of PASSES) if (opts[key] && key !== "inlineOnce" && key !== "inline" && key !== "devirt") ast = fn(ast, opts);
       if (equal(beforeRound2, ast)) break;
       if (verbose) log(`  round ${round + 1} applied`);
     }
@@ -6029,7 +6120,7 @@ function optimize(ast, opts = true) {
   let sizeBefore = binarySize(ast);
   for (let round = 0; round < 3; round++) {
     beforeRound = clone2(ast);
-    for (const [key, fn] of PASSES) if (opts[key] && key !== "devirt" && key !== "inline") ast = fn(ast);
+    for (const [key, fn] of PASSES) if (opts[key] && key !== "devirt" && key !== "inline") ast = fn(ast, opts);
     if (opts.propagate && (opts.inlineOnce || opts.inline)) ast = propagate(ast);
     if (equal(beforeRound, ast)) break;
     const sizeAfter = binarySize(ast);