porffor 0.2.0-fde989a → 0.14.0-0d97d1e6a

package/compiler/decompile.js

@@ -1,5 +1,5 @@
-import { Blocktype, Opcodes, Valtype } from "./wasmSpec.js";
-import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from "./encoding.js";
+import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
+import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
 
 const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
 const invOpcodes = inv(Opcodes);
@@ -110,7 +110,6 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
 
     out += '\n';
     lastInst = inst;
-    i++;
   }
 
   return highlightAsm(out);
@@ -120,7 +119,7 @@ export const highlightAsm = asm => asm
   .replace(/(local|global|memory)\.[^\s]*/g, _ => `\x1B[31m${_}\x1B[0m`)
   .replace(/(i(8|16|32|64)x[0-9]+|v128)(\.[^\s]*)?/g, _ => `\x1B[34m${_}\x1B[0m`)
   .replace(/(i32|i64|f32|f64|drop)(\.[^\s]*)?/g, _ => `\x1B[36m${_}\x1B[0m`)
-  .replace(/(return_call|call|br_if|br|return|rethrow|throw)/g, _ => `\x1B[35m${_}\x1B[0m`)
+  .replace(/(return_call|call_indirect|call|br_if|br|return|rethrow|throw)/g, _ => `\x1B[35m${_}\x1B[0m`)
   .replace(/(block|loop|if|end|else|try|catch_all|catch|delegate)/g, _ => `\x1B[95m${_}\x1B[0m`)
   .replace(/unreachable/g, _ => `\x1B[91m${_}\x1B[0m`)
   .replace(/ \-?[0-9\.]+/g, _ => ` \x1B[33m${_.slice(1)}\x1B[0m`)

package/compiler/embedding.js

@@ -1,23 +1,23 @@
-import { Opcodes, Valtype } from "./wasmSpec.js";
-import { signedLEB128, ieee754_binary64 } from "./encoding.js";
-
-export 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) ] ];
-  }
-};
-
-export const enforceOneByte = arr => [ arr[0] ?? 0 ];
-export const enforceTwoBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0 ];
-export const enforceFourBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0 ];
-export const enforceEightBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0, arr[4] ?? 0, arr[5] ?? 0, arr[6] ?? 0, arr[7] ?? 0 ];
-
-export const i32x4 = (a, b, c, d) => [ [
-  ...Opcodes.v128_const,
-  ...enforceFourBytes(signedLEB128(a)),
-  ...enforceFourBytes(signedLEB128(b)),
-  ...enforceFourBytes(signedLEB128(c)),
-  ...enforceFourBytes(signedLEB128(d))
+import { Opcodes, Valtype } from './wasmSpec.js';
+import { signedLEB128, ieee754_binary64 } from './encoding.js';
+
+export 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) ] ];
+  }
+};
+
+export const enforceOneByte = arr => [ arr[0] ?? 0 ];
+export const enforceTwoBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0 ];
+export const enforceFourBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0 ];
+export const enforceEightBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0, arr[4] ?? 0, arr[5] ?? 0, arr[6] ?? 0, arr[7] ?? 0 ];
+
+export const i32x4 = (a, b, c, d) => [ [
+  ...Opcodes.v128_const,
+  ...enforceFourBytes(signedLEB128(a)),
+  ...enforceFourBytes(signedLEB128(b)),
+  ...enforceFourBytes(signedLEB128(c)),
+  ...enforceFourBytes(signedLEB128(d))
 ] ];

package/compiler/encoding.js

@@ -7,15 +7,8 @@ export const codifyString = str => {
   return out;
 };
 
-export const encodeString = str => [
-  str.length,
-  ...codifyString(str)
-];
-
-export const encodeVector = data => [
-  ...unsignedLEB128(data.length),
-  ...data.flat()
-];
+export const encodeString = str => unsignedLEB128(str.length).concat(codifyString(str));
+export const encodeVector = data => unsignedLEB128(data.length).concat(data.flat());
 
 export const encodeLocal = (count, type) => [
   ...unsignedLEB128(count),
@@ -24,6 +17,8 @@ export const encodeLocal = (count, type) => [
 
 // todo: this only works with integers within 32 bit range
 export const signedLEB128 = n => {
+  if (typeof n === 'bigint') return big_signedLEB128(n);
+
   n |= 0;
 
   // just input for small numbers (for perf as common)
@@ -50,6 +45,8 @@ export const signedLEB128 = n => {
 };
 
 export const unsignedLEB128 = n => {
+  if (typeof n === 'bigint') return big_unsignedLEB128(n);
+
   n |= 0;
 
   // just input for small numbers (for perf as common)
@@ -67,6 +64,46 @@ export const unsignedLEB128 = n => {
   return buffer;
 };
 
+export const big_signedLEB128 = n => {
+  // just input for small numbers (for perf as common)
+  if (n >= 0n && n <= 63n) return [ Number(n) ];
+  if (n >= -64n && n <= 0n) return [ 128 + Number(n) ];
+
+  const buffer = [];
+
+  while (true) {
+    let byte = Number(n & 0x7fn);
+    n >>= 7n;
+
+    if ((n === 0n && (byte & 0x40) === 0) || (n === -1n && (byte & 0x40) !== 0)) {
+      buffer.push(byte);
+      break;
+    } else {
+      byte |= 0x80n;
+    }
+
+    buffer.push(byte);
+  }
+
+  return buffer;
+};
+
+export const big_unsignedLEB128 = n => {
+  // just input for small numbers (for perf as common)
+  if (n >= 0n && n <= 127n) return [ n ];
+
+  const buffer = [];
+  do {
+    let byte = Number(n & 0x7fn);
+    n >>>= 7n;
+    if (n !== 0n) {
+      byte |= 0x80;
+    }
+    buffer.push(byte);
+  } while (n !== 0n);
+  return buffer;
+};
+
 export const read_signedLEB128 = _input => {
   const input = [..._input];
   let result = 0, shift = 0;
@@ -105,5 +142,52 @@ export const read_unsignedLEB128 = _input => {
 };
 
 // ieee 754 binary64
+// const ieee754Cache = {};
+// export const ieee754_binary64 = value => {
+//   if (ieee754Cache[value]) return ieee754Cache[value];
+//   return ieee754Cache[value] = [...new Uint8Array(new Float64Array([ value ]).buffer)];
+// };
 export const ieee754_binary64 = value => [...new Uint8Array(new Float64Array([ value ]).buffer)];
-export const read_ieee754_binary64 = buffer => new Float64Array(new Uint8Array(buffer).buffer)[0];
+export const read_ieee754_binary64 = buffer => new Float64Array(new Uint8Array(buffer).buffer)[0];
+
+
+// into funcs append to a given existing buffer instead of creating our own for perf
+export const signedLEB128_into = (n, buffer) => {
+  n |= 0;
+
+  // just input for small numbers (for perf as common)
+  if (n >= 0 && n <= 63) return buffer.push(n);
+  if (n >= -64 && n <= 0) return buffer.push(128 + n);
+
+  while (true) {
+    let byte = n & 0x7f;
+    n >>= 7;
+
+    if ((n === 0 && (byte & 0x40) === 0) || (n === -1 && (byte & 0x40) !== 0)) {
+      buffer.push(byte);
+      break;
+    } else {
+      byte |= 0x80;
+    }
+
+    buffer.push(byte);
+  }
+};
+
+export const unsignedLEB128_into = (n, buffer) => {
+  n |= 0;
+
+  // just input for small numbers (for perf as common)
+  if (n >= 0 && n <= 127) return buffer.push(n);
+
+  do {
+    let byte = n & 0x7f;
+    n >>>= 7;
+    if (n !== 0) {
+      byte |= 0x80;
+    }
+    buffer.push(byte);
+  } while (n !== 0);
+};
+
+export const ieee754_binary64_into = (value, buffer) => buffer.push(...new Uint8Array(new Float64Array([ value ]).buffer));

package/compiler/expression.js

@@ -1,4 +1,4 @@
-import { Opcodes } from "./wasmSpec.js";
+import { Opcodes } from './wasmSpec.js';
 
 export const operatorOpcode = {
   i32: {