porffor 0.1.0

package/compiler/decompile.js

@@ -0,0 +1,102 @@
+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);
+const invValtype = inv(Valtype);
+
+export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = [], funcs = [], globals = {}, exceptions = []) => {
+  const invLocals = inv(locals, x => x.idx);
+  const invGlobals = inv(globals, x => x.idx);
+
+  const makeSignature = (params, returns) => `(${params.map(x => invValtype[x]).join(', ')}) -> (${returns.map(x => invValtype[x]).join(', ')})`;
+
+  let out = '', depth = name ? 1 : 0;
+  if (name) out += `${makeSignature(params, returns)} ;; $${name} (${ind})\n`;
+
+  const justLocals = Object.values(locals).sort((a, b) => a.idx - b.idx).slice(params.length);
+  if (justLocals.length > 0) out += `  local ${justLocals.map(x => invValtype[x.type]).join(' ')}\n`;
+
+  let i = 0, lastInst;
+  for (let inst of wasm.concat(name ? [ [ Opcodes.end ] ] : [])) {
+    if (inst[0] === null) continue;
+
+    if (inst[0] === 0xfd) { // simd inst prefix
+      if (inst[1] >= 128) inst = [ [ inst[0], inst[1], inst[2] ], ...inst.slice(3) ];
+        else inst = [ [ inst[0], inst[1] ], ...inst.slice(2) ];
+    }
+
+    if (inst[0] === 0xfc) { // misc inst prefix
+      inst = [ [ inst[0], inst[1] ], ...inst.slice(2) ];
+    }
+
+    if (inst[0] === Opcodes.end || inst[0] === Opcodes.else || inst[0] === Opcodes.catch_all) depth--;
+
+    const opStr = invOpcodes[inst[0]];
+    if (!opStr) console.log(`decomp: unknown op ${inst[0].toString(16)}`)
+    out += /* ' '.repeat(3 - i.toString().length) + i + ' ' + */ ' '.repeat(Math.max(0, depth * 2)) + opStr.replace('_', '.').replace('return.', 'return_').replace('call.', 'call_').replace('br.', 'br_');
+
+    if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block || inst[0] === Opcodes.else || inst[0] === Opcodes.try || inst[0] === Opcodes.catch_all) depth++;
+
+    if (inst[0] === Opcodes.f64_const) {
+      out += ` ${read_ieee754_binary64(inst.slice(1))}`;
+    } else if (inst[0] === Opcodes.i32_const || inst[0] === Opcodes.i64_const) {
+      out += ` ${read_signedLEB128(inst.slice(1))}`;
+    } else if (inst[0] === Opcodes.i32_load || inst[0] === Opcodes.i64_load || inst[0] === Opcodes.f64_load || inst[0] === Opcodes.i32_store || inst[0] === Opcodes.i64_store || inst[0] === Opcodes.f64_store) {
+      out += ` ${inst[1]} ${read_unsignedLEB128(inst.slice(2))}`
+    } else for (const operand of inst.slice(1)) {
+      if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block) {
+        if (operand === Blocktype.void) continue;
+        out += ` ${invValtype[operand]}`;
+      } else {
+        out += ` ${operand}`;
+      }
+    }
+
+    if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block || inst[0] === Opcodes.else) {
+      out += ` ;; label @${depth}`;
+    }
+
+    if (inst[0] === Opcodes.br) {
+      out += ` ;; goto @${depth - inst[1]}`;
+    }
+
+    if (inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) {
+      const callFunc = funcs.find(x => x.index === inst[1]);
+      if (callFunc) out += ` ;; $${callFunc.name} ${makeSignature(callFunc.params, callFunc.returns)}`;
+    }
+
+    if (inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) {
+      const name = invLocals[inst[1]];
+      const type = invValtype[locals[name]?.type];
+      if (name) out += ` ;; $${name}${type !== valtype ? ` (${type})` : ''}`;
+    }
+
+    if (inst[0] === Opcodes.global_get || inst[0] === Opcodes.global_set) {
+      const name = invGlobals[inst[1]];
+      const type = invValtype[globals[name]?.type];
+      if (name) out += ` ;; $${name}${type !== valtype ? ` (${type})` : ''}`;
+    }
+
+    if (inst[0] === Opcodes.throw && lastInst && exceptions) {
+      const exception = exceptions[lastInst[1]];
+      if (exception) out += ` ;; ${exception.constructor ? `${exception.constructor}('${exception.message}')` : `'${exception.message}'`}`;
+    }
+
+    out += '\n';
+    lastInst = inst;
+    i++;
+  }
+
+  return highlightAsm(out);
+};
+
+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(/[^m](i32|i64|f32|f64)(\.[^\s]*)?/g, _ => `${_[0]}\x1B[36m${_.slice(1)}\x1B[0m`)
+    .replace(/(return_call|call|br_if|br|return|throw|rethrow)/g, _ => `\x1B[35m${_}\x1B[0m`)
+    .replace(/(block|loop|if|end|else|try|catch|catch_all|delegate)/g, _ => `\x1B[95m${_}\x1B[0m`)
+    .replace(/ \-?[0-9\.]+/g, _ => ` \x1B[33m${_.slice(1)}\x1B[0m`)
+    .replace(/ ;;.*$/gm, _ => `\x1B[90m${_.replaceAll(/\x1B\[[0-9]+m/g, '')}\x1B[0m`);

package/compiler/embedding.js

@@ -0,0 +1,19 @@
+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) ] ];
+  }
+};
+
+const enforceTwoBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0 ];
+export const i32x4 = (a, b, c, d) => [ [
+  ...Opcodes.v128_const,
+  ...enforceTwoBytes(signedLEB128(a)),
+  ...enforceTwoBytes(signedLEB128(b)),
+  ...enforceTwoBytes(signedLEB128(c)),
+  ...enforceTwoBytes(signedLEB128(d))
+] ];

package/compiler/encoding.js

@@ -0,0 +1,217 @@
+export const codifyString = str => {
+  let out = [];
+  for (let i = 0; i < str.length; i++) {
+    out.push(str.charCodeAt(i));
+  }
+
+  return out;
+};
+
+export const encodeString = str => [
+  str.length,
+  ...codifyString(str)
+];
+
+export const encodeVector = data => [
+  ...unsignedLEB128(data.length),
+  ...data.flat()
+];
+
+export const encodeLocal = (count, type) => [
+  ...unsignedLEB128(count),
+  type
+];
+
+export const signedLEB128 = n => {
+  // todo: this only works with integers within 32 bit range
+
+  // just input for small numbers (for perf as common)
+  if (n >= 0 && n <= 63) return [ n ];
+  if (n >= -64 && n <= 0) return [ 128 + n ];
+
+  const buffer = [];
+  n |= 0;
+
+  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);
+  }
+
+  return buffer;
+};
+
+export const unsignedLEB128 = n => {
+  // just input for small numbers (for perf as common)
+  if (n >= 0 && n <= 127) return [ n ];
+
+  const buffer = [];
+  do {
+    let byte = n & 0x7f;
+    n >>>= 7;
+    if (n !== 0) {
+      byte |= 0x80;
+    }
+    buffer.push(byte);
+  } while (n !== 0);
+  return buffer;
+};
+
+export const read_signedLEB128 = _input => {
+  const input = [..._input];
+  let result = 0, shift = 0;
+
+  while (true) {
+    const byte = input.shift();
+    result |= (byte & 0x7f) << shift;
+
+    shift += 7;
+
+    if ((0x80 & byte) === 0) {
+      if (shift < 32 && (byte & 0x40) !== 0) {
+        return result | (-1 << shift);
+      }
+
+      return result;
+    }
+  }
+};
+
+// todo: check this with large unsigned values
+export const read_unsignedLEB128 = _input => {
+  const input = [..._input];
+  let result = 0, shift = 0;
+
+  while (true) {
+    const byte = input.shift();
+    result |= (byte & 0x7f) << shift;
+
+    shift += 7;
+
+    if ((0x80 & byte) === 0) {
+      return result;
+    }
+  }
+};
+
+// ieee 754 binary64
+
+// from https://github.com/feross/ieee754
+// BSD 3-Clause. Copyright 2008 Fair Oaks Labs, Inc. (https://github.com/feross/ieee754/blob/master/LICENSE)
+export const ieee754_binary64 = value => {
+  let isLE = true, mLen = 52, nBytes = 8, offset = 0;
+  let buffer = new Array(nBytes).fill(0);
+
+  let e, m, c
+  let eLen = (nBytes * 8) - mLen - 1
+  const eMax = (1 << eLen) - 1
+  const eBias = eMax >> 1
+  const rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+  let i = isLE ? 0 : (nBytes - 1)
+  const d = isLE ? 1 : -1
+  const s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+
+  value = Math.abs(value)
+
+  if (isNaN(value) || value === Infinity) {
+    m = isNaN(value) ? 1 : 0
+    e = eMax
+  } else {
+    e = Math.floor(Math.log(value) / Math.LN2)
+    if (value * (c = Math.pow(2, -e)) < 1) {
+      e--
+      c *= 2
+    }
+    if (e + eBias >= 1) {
+      value += rt / c
+    } else {
+      value += rt * Math.pow(2, 1 - eBias)
+    }
+    if (value * c >= 2) {
+      e++
+      c /= 2
+    }
+
+    if (e + eBias >= eMax) {
+      m = 0
+      e = eMax
+    } else if (e + eBias >= 1) {
+      m = ((value * c) - 1) * Math.pow(2, mLen)
+      e = e + eBias
+    } else {
+      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+      e = 0
+    }
+  }
+
+  while (mLen >= 8) {
+    buffer[offset + i] = m & 0xff
+    i += d
+    m /= 256
+    mLen -= 8
+  }
+
+  e = (e << mLen) | m
+  eLen += mLen
+  while (eLen > 0) {
+    buffer[offset + i] = e & 0xff
+    i += d
+    e /= 256
+    eLen -= 8
+  }
+
+  buffer[offset + i - d] |= s * 128
+
+  return buffer;
+};
+
+export const read_ieee754_binary64 = buffer => {
+  let isLE = true, mLen = 52, nBytes = 8, offset = 0;
+
+  let e, m
+  const eLen = (nBytes * 8) - mLen - 1
+  const eMax = (1 << eLen) - 1
+  const eBias = eMax >> 1
+  let nBits = -7
+  let i = isLE ? (nBytes - 1) : 0
+  const d = isLE ? -1 : 1
+  let s = buffer[offset + i]
+
+  i += d
+
+  e = s & ((1 << (-nBits)) - 1)
+  s >>= (-nBits)
+  nBits += eLen
+  while (nBits > 0) {
+    e = (e * 256) + buffer[offset + i]
+    i += d
+    nBits -= 8
+  }
+
+  m = e & ((1 << (-nBits)) - 1)
+  e >>= (-nBits)
+  nBits += mLen
+  while (nBits > 0) {
+    m = (m * 256) + buffer[offset + i]
+    i += d
+    nBits -= 8
+  }
+
+  if (e === 0) {
+    e = 1 - eBias
+  } else if (e === eMax) {
+    return m ? NaN : ((s ? -1 : 1) * Infinity)
+  } else {
+    m = m + Math.pow(2, mLen)
+    e = e - eBias
+  }
+  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+};

package/compiler/expression.js

@@ -0,0 +1,70 @@
+import { Opcodes } from "./wasmSpec.js";
+
+export const operatorOpcode = {
+  i32: {
+    '+': Opcodes.i32_add,
+    '-': Opcodes.i32_sub,
+    '*': Opcodes.i32_mul,
+    '/': Opcodes.i32_div_s,
+    '%': Opcodes.i32_rem_s,
+
+    '&': Opcodes.i32_and,
+    '|': Opcodes.i32_or,
+    '^': Opcodes.i32_xor,
+    '<<': Opcodes.i32_shl,
+    '>>': Opcodes.i32_shr_s,
+    '>>>': Opcodes.i32_shr_u,
+
+    '==': Opcodes.i32_eq,
+    '===': Opcodes.i32_eq,
+    '!=': Opcodes.i32_ne,
+    '!==': Opcodes.i32_ne,
+
+    '>': Opcodes.i32_gt_s,
+    '>=': Opcodes.i32_ge_s,
+    '<': Opcodes.i32_lt_s,
+    '<=': Opcodes.i32_le_s
+  },
+
+  i64: {
+    '+': Opcodes.i64_add,
+    '-': Opcodes.i64_sub,
+    '*': Opcodes.i64_mul,
+    '/': Opcodes.i64_div_s,
+    '%': Opcodes.i64_rem_s,
+
+    '&': Opcodes.i64_and,
+    '|': Opcodes.i64_or,
+    '^': Opcodes.i64_xor,
+    '<<': Opcodes.i64_shl,
+    '>>': Opcodes.i64_shr_s,
+    '>>>': Opcodes.i64_shr_u,
+
+    '==': Opcodes.i64_eq,
+    '===': Opcodes.i64_eq,
+    '!=': Opcodes.i64_ne,
+    '!==': Opcodes.i64_ne,
+
+    '>': Opcodes.i64_gt_s,
+    '>=': Opcodes.i64_ge_s,
+    '<': Opcodes.i64_lt_s,
+    '<=': Opcodes.i64_le_s
+  },
+
+  f64: {
+    '+': Opcodes.f64_add,
+    '-': Opcodes.f64_sub,
+    '*': Opcodes.f64_mul,
+    '/': Opcodes.f64_div,
+
+    '==': Opcodes.f64_eq,
+    '===': Opcodes.f64_eq,
+    '!=': Opcodes.f64_ne,
+    '!==': Opcodes.f64_ne,
+
+    '>': Opcodes.f64_gt,
+    '>=': Opcodes.f64_ge,
+    '<': Opcodes.f64_lt,
+    '<=': Opcodes.f64_le
+  }
+};

package/compiler/index.js

@@ -0,0 +1,67 @@
+import parse from './parse.js';
+import codeGen from './codeGen.js';
+import opt from './opt.js';
+import produceSections from './sections.js';
+import decompile from './decompile.js';
+import { BuiltinPreludes } from './builtins.js';
+
+globalThis.decompile = decompile;
+
+const rgb = (r, g, b, x) => `\x1b[38;2;${r};${g};${b}m${x}\u001b[0m`;
+const underline = x => `\u001b[4m${x}\u001b[0m`;
+const bold = x => `\u001b[1m${x}\u001b[0m`;
+
+const areaColors = {
+  codegen: [ 20, 80, 250 ],
+  opt: [ 250, 20, 80 ],
+  sections: [ 20, 250, 80 ]
+};
+
+globalThis.log = (area, ...args) => console.log(`\u001b[90m[\u001b[0m${rgb(...areaColors[area], area)}\u001b[90m]\u001b[0m`, ...args);
+
+const logFuncs = (funcs, globals, exceptions) => {
+  console.log('\n' + underline(bold('funcs')));
+
+  for (const f of funcs) {
+    console.log(`${underline(f.name)} (${f.index})`);
+
+    console.log(`params: ${f.params.map((_, i) => Object.keys(f.locals)[Object.values(f.locals).indexOf(Object.values(f.locals).find(x => x.idx === i))]).join(', ')}`);
+    console.log(`returns: ${f.returns.length > 0 ? true : false}`);
+    console.log(`locals: ${Object.keys(f.locals).sort((a, b) => f.locals[a].idx - f.locals[b].idx).map(x => `${x} (${f.locals[x].idx})`).join(', ')}`);
+    console.log();
+    console.log(decompile(f.wasm, f.name, f.index, f.locals, f.params, f.returns, funcs, globals, exceptions));
+  }
+
+  console.log();
+};
+
+export default (code, flags) => {
+  globalThis.optLog = process.argv.includes('-opt-log');
+  globalThis.codeLog = process.argv.includes('-code-log');
+
+  for (const x in BuiltinPreludes) {
+    if (code.indexOf(x + '(') !== -1) code = BuiltinPreludes[x] + code;
+  }
+
+  const t0 = performance.now();
+  const program = parse(code, flags);
+  if (flags.includes('info')) console.log(`1. parsed in ${(performance.now() - t0).toFixed(2)}ms`);
+
+  const t1 = performance.now();
+  const { funcs, globals, tags, exceptions, pages } = codeGen(program);
+  if (flags.includes('info')) console.log(`2. generated code in ${(performance.now() - t1).toFixed(2)}ms`);
+
+  if (process.argv.includes('-funcs')) logFuncs(funcs, globals, exceptions);
+
+  const t2 = performance.now();
+  opt(funcs, globals);
+  if (flags.includes('info')) console.log(`3. optimized code in ${(performance.now() - t2).toFixed(2)}ms`);
+
+  if (process.argv.includes('-opt-funcs')) logFuncs(funcs, globals, exceptions);
+
+  const t3 = performance.now();
+  const sections = produceSections(funcs, globals, tags, pages, flags);
+  if (flags.includes('info')) console.log(`4. produced sections in ${(performance.now() - t3).toFixed(2)}ms`);
+
+  return { wasm: sections, funcs, globals, tags, exceptions, pages };
+};