porffor 0.1.1 → 0.2.0-c6c8c81

package/compiler/decompile.js

@@ -17,8 +17,10 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
   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;
+  let i = -1, lastInst;
+  let byte = 0;
   for (let inst of wasm.concat(name ? [ [ Opcodes.end ] ] : [])) {
+    i++;
     if (inst[0] === null) continue;
 
     if (inst[0] === 0xfd) { // simd inst prefix
@@ -32,9 +34,30 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
 
     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_');
+    out += ' '.repeat(Math.max(0, depth * 2));
+
+    let opStr = invOpcodes[inst[0]];
+    if (!opStr) {
+      console.log(`decomp: unknown op ${inst[0]?.toString?.(16)} @${i}`);
+      // console.log(`prior: ${invOpcodes[wasm[i - 1][0]]}`);
+      out += `;; unknown op ${inst[0]?.toString?.(16)}\n`;
+      continue;
+    }
+
+    // out += '0x' + byte.toString(10).padStart(2, '0');
+    byte += inst.length;
+
+    out += opStr.replace('_', '.').replace('return.', 'return_').replace('call.', 'call_').replace('br.', 'br_').replace('catch.', 'catch_');
+
+    const comments = [];
+    inst = inst.filter(x => {
+      if (typeof x === 'string') {
+        comments.push(x);
+        return false;
+      }
+
+      return true;
+    })
 
     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++;
 
@@ -42,8 +65,8 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       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 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 || inst[0] === Opcodes.i32_store16 || inst[0] === Opcodes.i32_load16_u) {
+      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;
@@ -53,11 +76,13 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       }
     }
 
+    if (comments.length > 0) out += ` ;; ${comments.join(' ')}`;
+
     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) {
+    if (inst[0] === Opcodes.br || inst[0] === Opcodes.br_if) {
       out += ` ;; goto @${depth - inst[1]}`;
     }
 
@@ -95,8 +120,9 @@ 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(/[^m](i32|i64|f32|f64|drop)(\.[^\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(/(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`)
     .replace(/ ;;.*$/gm, _ => `\x1B[90m${_.replaceAll(/\x1B\[[0-9]+m/g, '')}\x1B[0m`);

package/compiler/embedding.js

@@ -9,11 +9,15 @@ export const number = (n, valtype = valtypeBinary) => {
   }
 };
 
-const enforceTwoBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0 ];
+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,
-  ...enforceTwoBytes(signedLEB128(a)),
-  ...enforceTwoBytes(signedLEB128(b)),
-  ...enforceTwoBytes(signedLEB128(c)),
-  ...enforceTwoBytes(signedLEB128(d))
+  ...enforceFourBytes(signedLEB128(a)),
+  ...enforceFourBytes(signedLEB128(b)),
+  ...enforceFourBytes(signedLEB128(c)),
+  ...enforceFourBytes(signedLEB128(d))
 ] ];

package/compiler/encoding.js

@@ -22,15 +22,15 @@ export const encodeLocal = (count, type) => [
   type
 ];
 
+// todo: this only works with integers within 32 bit range
 export const signedLEB128 = n => {
-  // todo: this only works with integers within 32 bit range
+  n |= 0;
 
   // 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;
@@ -50,6 +50,8 @@ export const signedLEB128 = n => {
 };
 
 export const unsignedLEB128 = n => {
+  n |= 0;
+
   // just input for small numbers (for perf as common)
   if (n >= 0 && n <= 127) return [ n ];
 
@@ -107,6 +109,8 @@ export const read_unsignedLEB128 = _input => {
 // 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 => {
+  return [...new Uint8Array(new Float64Array([ value ]).buffer)];
+
   let isLE = true, mLen = 52, nBytes = 8, offset = 0;
   let buffer = new Array(nBytes).fill(0);
 
@@ -174,6 +178,8 @@ export const ieee754_binary64 = value => {
 };
 
 export const read_ieee754_binary64 = buffer => {
+  return new Float64Array(new Uint8Array(buffer).buffer)[0];
+
   let isLE = true, mLen = 52, nBytes = 8, offset = 0;
 
   let e, m

package/compiler/index.js

@@ -1,29 +1,20 @@
+import { underline, bold, log } from './log.js';
 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';
+import toc from './2c.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')));
 
+  const startIndex = funcs.sort((a, b) => a.index - b.index)[0].index;
   for (const f of funcs) {
-    console.log(`${underline(f.name)} (${f.index})`);
+    console.log(`${underline(f.name)} (${f.index - startIndex})`);
 
     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}`);
@@ -35,9 +26,16 @@ const logFuncs = (funcs, globals, exceptions) => {
   console.log();
 };
 
+const getArg = name => process.argv.find(x => x.startsWith(`-${name}=`))?.slice(name.length + 2);
+
+const writeFileSync = (typeof process !== 'undefined' ? (await import('node:fs')).writeFileSync : undefined);
+const execSync = (typeof process !== 'undefined' ? (await import('node:child_process')).execSync : undefined);
+
 export default (code, flags) => {
   globalThis.optLog = process.argv.includes('-opt-log');
   globalThis.codeLog = process.argv.includes('-code-log');
+  globalThis.allocLog = process.argv.includes('-alloc-log');
+  globalThis.regexLog = process.argv.includes('-regex-log');
 
   for (const x in BuiltinPreludes) {
     if (code.indexOf(x + '(') !== -1) code = BuiltinPreludes[x] + code;
@@ -48,20 +46,60 @@ export default (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);
+  const { funcs, globals, tags, exceptions, pages, data } = 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);
+  opt(funcs, globals, pages);
   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);
+  const sections = produceSections(funcs, globals, tags, pages, data, 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 };
+  if (allocLog) {
+    const wasmPages = Math.ceil((pages.size * pageSize) / 65536);
+    const bytes = wasmPages * 65536;
+    log('alloc', `\x1B[1mallocated ${bytes / 1024}KiB\x1B[0m for ${pages.size} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}`);
+    console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n') + '\n');
+  }
+
+  const out = { wasm: sections, funcs, globals, tags, exceptions, pages };
+
+  const target = getArg('target') ?? getArg('t') ?? 'wasm';
+  const outFile = getArg('o');
+
+  if (target === 'c') {
+    const c = toc(out);
+
+    if (outFile) {
+      writeFileSync(outFile, c);
+    } else {
+      console.log(c);
+    }
+
+    process.exit();
+  }
+
+  if (target === 'native') {
+    const compiler = getArg('compiler') ?? 'clang';
+    const cO = getArg('cO') ?? 'Ofast';
+
+    const tmpfile = 'tmp.c';
+    const args = [ compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native' ];
+
+    const c = toc(out);
+    writeFileSync(tmpfile, c);
+
+    // obvious command escape is obvious
+    execSync(args.join(' '), { stdio: 'inherit' });
+
+    process.exit();
+  }
+
+  return out;
 };

package/compiler/log.js

@@ -0,0 +1,15 @@
+export const rgb = (r, g, b, x) => `\x1b[38;2;${r};${g};${b}m${x}\u001b[0m`;
+export const underline = x => `\u001b[4m${x}\u001b[0m`;
+export const bold = x => `\u001b[1m${x}\u001b[0m`;
+
+const areaColors = {
+  codegen: [ 20, 80, 250 ],
+  opt: [ 250, 20, 80 ],
+  sections: [ 20, 250, 80 ],
+  alloc: [ 250, 250, 20 ],
+  parser: [ 240, 240, 240 ],
+  '2c': [ 20, 250, 250 ]
+};
+
+export const log = (area, ...args) => console.log(`\u001b[90m[\u001b[0m${rgb(...areaColors[area], area)}\u001b[90m]\u001b[0m`, ...args);
+log.warning = (area, ...args) => log(area, '\u001b[93m' + args[0], ...args.slice(1), '\u001b[0m');