porffor 0.2.0-fde989a → 0.2.0-fdf0fc5

package/compiler/decompile.js

@@ -110,7 +110,6 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
 
     out += '\n';
     lastInst = inst;
-    i++;
   }
 
   return highlightAsm(out);

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,22 @@ 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 => [
+//   str.length,
+//   ...codifyString(str)
+// ];
+export const encodeString = str => unsignedLEB128(str.length).concat(codifyString(str));
+
+// export const encodeVector = data => [
+//   ...unsignedLEB128(data.length),
+//   ...data.flat()
+// ];
+// export const encodeVector = data => {
+//   const out = data.flat();
+//   out.unshift.apply(out, unsignedLEB128(data.length));
+//   return out;
+// };
+export const encodeVector = data => unsignedLEB128(data.length).concat(data.flat());
 
 export const encodeLocal = (count, type) => [
   ...unsignedLEB128(count),
@@ -24,6 +31,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 +59,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 +78,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 +156,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));