porffor 0.16.0-ab08df866 → 0.16.0-b099006b8

package/compiler/assemble.js

@@ -21,7 +21,7 @@ const chHint = (topTier, baselineTier, strategy) => {
   return (strategy | (baselineTier << 2) | (topTier << 4));
 };
 
-export default (funcs, globals, tags, pages, data, flags) => {
+export default (funcs, globals, tags, pages, data, flags, noTreeshake = false) => {
   const types = [], typeCache = {};
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
@@ -44,7 +44,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   let importFuncs = [];
 
-  if (optLevel < 1 || !Prefs.treeshakeWasmImports) {
+  if (optLevel < 1 || !Prefs.treeshakeWasmImports || noTreeshake) {
     importFuncs = importedFuncs;
   } else {
     let imports = new Map();
@@ -94,7 +94,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   const importSection = importFuncs.length === 0 ? [] : createSection(
     Section.import,
-    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(new Array(x.params).fill(x.name.startsWith('profile') ? Valtype.i32 : valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
+    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(typeof x.params === 'object' ? x.params : new Array(x.params).fill(valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
   );
 
   const funcSection = createSection(
@@ -116,7 +116,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
     ] ])
   );
 
-  if (pages.has('func argc lut')) {
+  if (pages.has('func argc lut') && !data.addedFuncArgcLut) {
     // generate func argc lut data
     const bytes = [];
     for (let i = 0; i < funcs.length; i++) {
@@ -128,6 +128,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
       offset: pages.get('func argc lut').ind * pageSize,
       bytes
     });
+    data.addedFuncArgcLut = true;
   }
 
   // const t0 = performance.now();

package/compiler/builtins.js

@@ -32,13 +32,13 @@ export const importedFuncs = [
   {
     name: 'profile1',
     import: 'y',
-    params: 1,
+    params: [ Valtype.i32 ],
     returns: 0
   },
   {
     name: 'profile2',
     import: 'z',
-    params: 1,
+    params: [ Valtype.i32 ],
     returns: 0
   },
   {

package/compiler/codegen.js

@@ -1807,7 +1807,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       f64_store: { imms: 2, args: [ true, false ], returns: 0 },
 
       // value
-      i32_const: { imms: 1, args: [], returns: 1 },
+      i32_const: { imms: 1, args: [], returns: 0 },
     };
 
     const opName = name.slice('__Porffor_wasm_'.length);
@@ -1999,8 +1999,8 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     }
 
     if (valtypeBinary !== Valtype.i32 && (
-      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
-      (importedFuncs[name] && name.startsWith('profile'))
+      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32)
+      // (importedFuncs[name] && name.startsWith('profile'))
     )) {
       out.push(Opcodes.i32_to);
     }
@@ -2181,7 +2181,7 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
   if (Prefs.typeswitchUseBrtable)
     return brTable(type, bc, returns);
 
-  const tmp = localTmp(scope, '#typeswitch_tmp', Valtype.i32);
+  const tmp = localTmp(scope, '#typeswitch_tmp' + (Prefs.typeswitchUniqueTmp ? randId() : ''), Valtype.i32);
   const out = [
     ...type,
     [ Opcodes.local_set, tmp ],
@@ -3502,7 +3502,7 @@ const generateMember = (scope, decl, _global, _name) => {
     }
 
     if (builtinFuncs[name]) return withType(scope, number(builtinFuncs[name].typedParams ? (builtinFuncs[name].params.length / 2) : builtinFuncs[name].params.length), TYPES.number);
-    if (importedFuncs[name]) return withType(scope, number(importedFuncs[name].params), TYPES.number);
+    if (importedFuncs[name]) return withType(scope, number(importedFuncs[name].params.length ?? importedFuncs[name].params), TYPES.number);
     if (internalConstrs[name]) return withType(scope, number(internalConstrs[name].length ?? 0), TYPES.number);
 
     if (Prefs.fastLength) {
@@ -3971,19 +3971,8 @@ export default program => {
   data = [];
   currentFuncIndex = importedFuncs.length;
 
-  globalThis.valtype = 'f64';
-
-  const valtypeOpt = process.argv.find(x => x.startsWith('--valtype='));
-  if (valtypeOpt) valtype = valtypeOpt.split('=')[1];
-
-  globalThis.valtypeBinary = Valtype[valtype];
-
   const valtypeInd = ['i32', 'i64', 'f64'].indexOf(valtype);
 
-  globalThis.pageSize = PageSize;
-  const pageSizeOpt = process.argv.find(x => x.startsWith('--page-size='));
-  if (pageSizeOpt) pageSize = parseInt(pageSizeOpt.split('=')[1]) * 1024;
-
   // set generic opcodes for current valtype
   Opcodes.const = [ Opcodes.i32_const, Opcodes.i64_const, Opcodes.f64_const ][valtypeInd];
   Opcodes.eq = [ Opcodes.i32_eq, Opcodes.i64_eq, Opcodes.f64_eq ][valtypeInd];

package/compiler/cyclone.js

@@ -0,0 +1,535 @@
+// cyclone: wasm partial constant evaluator (it is fast and dangerous hence "cyclone")
+import { signedLEB128, ieee754_binary64, read_ieee754_binary64, read_signedLEB128 } from './encoding.js';
+import { Opcodes, Valtype } from './wasmSpec.js';
+
+const number = (n, valtype = valtypeBinary) => {
+  switch (valtype) {
+    case Valtype.i32: return [ Opcodes.i32_const, ...signedLEB128(n) ];
+    case Valtype.i64: return [ Opcodes.i64_const, ...signedLEB128(n) ];
+    case Valtype.f64: return [ Opcodes.f64_const, ...ieee754_binary64(n) ];
+  }
+};
+
+const f64ToI32Op = {
+  [Opcodes.f64_eq]: Opcodes.i32_eq,
+  [Opcodes.f64_ne]: Opcodes.i32_ne,
+  [Opcodes.f64_lt]: Opcodes.i32_lt_s,
+  [Opcodes.f64_le]: Opcodes.i32_le_s,
+  [Opcodes.f64_gt]: Opcodes.i32_gt_s,
+  [Opcodes.f64_ge]: Opcodes.i32_ge_s,
+  [Opcodes.f64_add]: Opcodes.i32_add,
+  [Opcodes.f64_sub]: Opcodes.i32_sub,
+  [Opcodes.f64_mul]: Opcodes.i32_mul,
+  [Opcodes.f64_div]: Opcodes.i32_div_s,
+};
+
+export default wasm => {
+  let stack = []; // """""stack"""""
+  for (let i = 0; i < wasm.length; i++) {
+    let op = wasm[i];
+    if (!op) continue;
+
+    // op = [ ...op.filter(x => x != null && x <= 0xff) ];
+    op = [ ...op ];
+    wasm[i] = op;
+
+    let opcode = op[0];
+    if (opcode === 0xfc) { // multibyte op
+      opcode = (opcode << 8) + op[1];
+    }
+
+    const push = val => {
+      stack.push({ val, op });
+    };
+
+    const pop = () => {
+      const popped = stack.pop();
+
+      // remove the op
+      wasm.splice(wasm.indexOf(popped.op), 1);
+      i--;
+
+      return popped.val;
+    };
+
+    const pop2 = () => [ pop(), pop() ];
+
+    const bool = v => v ? 1 : 0;
+
+    const replaceOp = newOp => {
+      op.splice(0, op.length, ...newOp);
+    };
+    const replaceVal = (val, valtype) => replaceOp(number(val, valtype));
+
+    const empty = () => {
+      stack = [];
+    };
+
+    switch (opcode) {
+      case Opcodes.i32_const: {
+        const n = read_signedLEB128(op.slice(1));
+        push(n);
+        break;
+      }
+      case Opcodes.f64_const: {
+        const n = read_ieee754_binary64(op.slice(1));
+        push(n);
+        break;
+      }
+
+      case Opcodes.i32_eqz: {
+        if (stack.length < 1) { empty(); break; };
+        const v = bool(pop() === 0);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_eq: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a === b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_ne: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a !== b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_lt_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a < b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_le_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a <= b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_gt_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a > b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_ge_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a >= b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+
+      case Opcodes.i32_add: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a + b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_sub: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a - b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_mul: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a * b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_div_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a / b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_rem_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a % b; // not rem but good enough
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+
+      case Opcodes.i32_and: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a & b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_or: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a | b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_xor: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a ^ b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_shl: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a << b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_shr_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a >> b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_shr_u: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a >>> b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_eq: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a === b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_ne: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a !== b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_lt: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a < b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_le: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a <= b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_gt: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a > b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_ge: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a >= b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_abs: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.abs(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_neg: {
+        if (stack.length < 1) { empty(); break; };
+        const v = -pop();
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_ceil: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.ceil(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_floor: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.floor(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_trunc: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.trunc(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_nearest: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.round(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_sqrt: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.sqrt(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_add: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a + b;
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_sub: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a - b;
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_mul: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a * b;
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_div: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a / b;
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_min: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = Math.min(a, b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_max: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a + b;
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_copysign: { // ?
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = Math.abs(a) * (b > 0 ? 1 : -1);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_convert_i32_u:
+      case Opcodes.f64_convert_i32_s: {
+        if (stack.length < 1) { empty(); break; };
+        const v = pop();
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case 0xfc02: { // i32_trunc_sat_f64_s
+        if (stack.length < 1) { empty(); break; }
+        const v = pop();
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+
+      case 0xfc03: { // i32_trunc_sat_f64_u
+        if (stack.length < 1) { empty(); break; }
+        const v = pop();
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+
+      default: {
+        empty();
+        break;
+      }
+    }
+
+    // this does, eg:
+    // local.get 7 ;; $i (i32)
+    // f64.convert_i32_s
+    // f64.const 1
+    // f64.add
+    // i32.trunc_sat_f64_s <--
+    // local.set 7 ;; $i (i32)
+    // ->
+    // local.get 7 ;; $i (i32)
+    // i32.const 1
+    // i32.add
+    // local.set 7 ;; $i (i32)
+    if (
+      (opcode >= 0xa0 && opcode <= 0xa3) || // main f64 math op
+      (opcode >= 0x61 && opcode <= 0x66) // main f64 eq op
+    ) {
+      const o2 = wasm[i - 1][0];
+      if (o2 === Opcodes.f64_const) { // f64.const
+        const o3 = wasm[i - 2][0];
+        if (o3 === Opcodes.f64_convert_i32_s || o3 === Opcodes.f64_convert_i32_u) {
+          // remove now unneeded i32 -> f64 convert
+          wasm.splice(i - 2, 1);
+          i--;
+
+          // convert f64.const -> i32.const
+          const n = read_ieee754_binary64(wasm[i - 1].slice(1));
+          wasm.splice(i - 1, 1, number(n, Valtype.i32));
+
+          // convert math op from f64 to i32
+          wasm[i][0] = f64ToI32Op[wasm[i][0]];
+
+          const nextOp = wasm[i + 1];
+          if (nextOp && opcode >= 0xa0 && opcode <= 0xa3) {
+            if (nextOp[0] === 0xfc && (nextOp[1] === 0x02 || nextOp[1] === 0x03)) {
+              // remove optional unneeded f64 -> i32 convert after
+              wasm.splice(i + 1, 1);
+            } else {
+              // add now needed i32 -> f64 convert after
+              wasm.splice(i + 1, Opcodes.i32_trunc_sat_f64_s);
+            }
+          }
+        }
+      }
+    }
+
+    if ((opcode === 0xfc02 || opcode === 0xfc03) && i > 3) { // i32.trunc_sat_f64_s/u
+      const o2 = wasm[i - 1][0];
+      if (
+        (o2 >= 0xa0 && o2 <= 0xa3) || // main f64 math op
+        (o2 >= 0x61 && o2 <= 0x66) // main f64 eq op
+      ) {
+        const o3 = wasm[i - 2][0];
+        if (o3 === Opcodes.f64_const) { // f64.const
+          const o4 = wasm[i - 3][0];
+          if (o4 === Opcodes.f64_convert_i32_s || o4 === Opcodes.f64_convert_i32_u) {
+            // remove now unneeded i32 -> f64 convert
+            wasm.splice(i - 3, 1);
+            i--;
+          } else {
+            // add now needed f64 -> i32 convert prior
+            wasm.splice(i - 2, 0, Opcodes.i32_trunc_sat_f64_s);
+            i++;
+          }
+
+          // convert f64.const -> i32.const
+          const n = read_ieee754_binary64(wasm[i - 2].slice(1));
+          wasm.splice(i - 2, 1, number(n, Valtype.i32));
+
+          // convert math op from f64 to i32
+          wasm[i - 1][0] = f64ToI32Op[wasm[i - 1][0]];
+
+          // remove this now unneeded f64 -> i32 convert
+          wasm.splice(i, 1);
+        }
+      }
+    }
+  }
+};

package/compiler/decompile.js

@@ -4,6 +4,8 @@ import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from '.
 const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
 const invOpcodes = inv(Opcodes);
 const invValtype = inv(Valtype);
+globalThis.invOpcodes = invOpcodes;
+globalThis.invValtype = invValtype;
 
 export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = [], funcs = [], globals = {}, exceptions = []) => {
   const invLocals = inv(locals, x => x.idx);
@@ -91,7 +93,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       if (callFunc) out += ` ;; $${callFunc.name} ${makeSignature(callFunc.params, callFunc.returns)}`;
       if (globalThis.importFuncs && inst[1] < importFuncs.length) {
         const importFunc = importFuncs[inst[1]];
-        out += ` ;; import ${importFunc.name} ${makeSignature(new Array(importFunc.params).fill(valtypeBinary), new Array(importFunc.returns).fill(valtypeBinary),)}`;
+        out += ` ;; import ${importFunc.name} ${makeSignature(typeof importFunc.params === 'object' ? importFunc.params : new Array(importFunc.params).fill(valtypeBinary), new Array(importFunc.returns).fill(valtypeBinary),)}`;
       }
     }