porffor 0.2.0-c7b7423 → 0.2.0-cb647c8

package/compiler/wrap.js

@@ -1,5 +1,6 @@
 import compile from './index.js';
 import decompile from './decompile.js';
+import { encodeVector, encodeLocal } from './encoding.js';
 // import fs from 'node:fs';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
@@ -18,7 +19,8 @@ const TYPES = {
 
   // internal
   [internalTypeBase]: '_array',
-  [internalTypeBase + 1]: '_regexp'
+  [internalTypeBase + 1]: '_regexp',
+  [internalTypeBase + 2]: '_bytestring'
 };
 
 export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
@@ -35,14 +37,98 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
   if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
   const t2 = performance.now();
-  const { instance } = await WebAssembly.instantiate(wasm, {
-    '': {
-      p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
-      c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
-      t: _ => performance.now(),
-      ...customImports
+
+  let instance;
+  try {
+    0, { instance } = await WebAssembly.instantiate(wasm, {
+      '': {
+        p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
+        c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
+        t: _ => performance.now(),
+        ...customImports
+      }
+    });
+  } catch (e) {
+    // only backtrace for runner, not test262/etc
+    if (!process.argv[1].includes('/runner')) throw e;
+
+    const funcInd = parseInt(e.message.match(/function #([0-9]+) /)[1]);
+    const blobOffset = parseInt(e.message.split('@')[1]);
+
+    // convert blob offset -> function wasm offset.
+    // this is not good code and is somewhat duplicated
+    // I just want it to work for debugging, I don't care about perf/yes
+
+    const func = funcs.find(x => x.index === funcInd);
+    const locals = Object.values(func.locals).sort((a, b) => a.idx - b.idx).slice(func.params.length).sort((a, b) => a.idx - b.idx);
+
+    let localDecl = [], typeCount = 0, lastType;
+    for (let i = 0; i < locals.length; i++) {
+      const local = locals[i];
+      if (i !== 0 && local.type !== lastType) {
+        localDecl.push(encodeLocal(typeCount, lastType));
+        typeCount = 0;
+      }
+
+      typeCount++;
+      lastType = local.type;
+    }
+
+    if (typeCount !== 0) localDecl.push(encodeLocal(typeCount, lastType));
+
+    const toFind = encodeVector(localDecl).concat(func.wasm.flat().filter(x => x != null && x <= 0xff).slice(0, 40));
+
+    let i = 0;
+    for (; i < wasm.length; i++) {
+      let mismatch = false;
+      for (let j = 0; j < toFind.length; j++) {
+        if (wasm[i + j] !== toFind[j]) {
+          mismatch = true;
+          break;
+        }
+      }
+
+      if (!mismatch) break;
+    }
+
+    if (i === wasm.length) throw e;
+
+    const offset = (blobOffset - i) + encodeVector(localDecl).length;
+
+    let cumLen = 0;
+    i = 0;
+    for (; i < func.wasm.length; i++) {
+      cumLen += func.wasm[i].filter(x => x != null && x <= 0xff).length;
+      if (cumLen === offset) break;
+    }
+
+    if (cumLen !== offset) throw e;
+
+    i -= 1;
+
+    console.log(`\x1B[35m\x1B[1mporffor backtrace\u001b[0m`);
+
+    console.log('\x1B[4m' + func.name + '\x1B[0m');
+
+    const surrounding = 6;
+
+    const decomp = decompile(func.wasm.slice(i - surrounding, i + surrounding + 1), '', 0, func.locals, func.params, func.returns, funcs, globals, exceptions).slice(0, -1).split('\n');
+
+    const noAnsi = s => s.replace(/\u001b\[[0-9]+m/g, '');
+    let longest = 0;
+    for (let j = 0; j < decomp.length; j++) {
+      longest = Math.max(longest, noAnsi(decomp[j]).length);
     }
-  });
+
+    const middle = Math.floor(decomp.length / 2);
+    decomp[middle] = `\x1B[47m\x1B[30m${noAnsi(decomp[middle])}${'\u00a0'.repeat(longest - noAnsi(decomp[middle]).length)}\x1B[0m`;
+
+    console.log('\x1B[90m...\x1B[0m');
+    console.log(decomp.join('\n'));
+    console.log('\x1B[90m...\x1B[0m\n');
+
+    throw e;
+  }
 
   times.push(performance.now() - t2);
   if (flags.includes('info')) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
@@ -95,10 +181,18 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
             return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
           }
 
+          case '_bytestring': {
+            const pointer = ret;
+            const length = new Int32Array(memory.buffer, pointer, 1);
+
+            return Array.from(new Uint8Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
+          }
+
           case 'function': {
             // wasm func index, including all imports
             const func = funcs.find(x => (x.originalIndex ?? x.index) === ret);
-            if (!func) return ret;
+            // if (!func) return ret;
+            if (!func) return function () {};
 
             // make fake empty func for repl/etc
             return {[func.name]() {}}[func.name];

package/demo.js

@@ -0,0 +1,3 @@
+foo();
+
+// console.log('Hello, World!');

package/demo.ts

@@ -0,0 +1 @@
+console.log("hello world");

package/filesize.cmd

@@ -0,0 +1,2 @@
+@echo off
+echo %~z1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.2.0-c7b7423",
+  "version": "0.2.0-cb647c8",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/porf

@@ -0,0 +1,2 @@
+#!/bin/sh
+node runner/index.js "$@"

package/runner/index.js

@@ -3,6 +3,8 @@
 import compile from '../compiler/wrap.js';
 import fs from 'node:fs';
 
+const start = performance.now();
+
 if (process.argv.includes('-compile-hints')) {
   const v8 = await import('node:v8');
   v8.setFlagsFromString(`--experimental-wasm-compilation-hints`);
@@ -15,9 +17,22 @@ if (process.argv.includes('-compile-hints')) {
   // --experimental-wasm-return-call (on by default)
 }
 
-const file = process.argv.slice(2).find(x => x[0] !== '-');
+let file = process.argv.slice(2).find(x => x[0] !== '-');
+if (['run', 'wasm', 'native', 'c'].includes(file)) {
+  if (['wasm', 'native', 'c'].includes(file)) {
+    process.argv.push(`-target=${file}`);
+  }
+
+  file = process.argv.slice(process.argv.indexOf(file) + 1).find(x => x[0] !== '-');
+
+  const nonOptOutFile = process.argv.slice(process.argv.indexOf(file) + 1).find(x => x[0] !== '-');
+  if (nonOptOutFile) {
+    process.argv.push(`-o=${nonOptOutFile}`);
+  }
+}
+
 if (!file) {
-  if (process.argv.includes('-v')) {
+  if (process.argv.includes('-v') || process.argv.includes('--version')) {
     // just print version
     console.log((await import('./version.js')).default);
     process.exit(0);
@@ -52,4 +67,6 @@ try {
 } catch (e) {
   if (cache) process.stdout.write(cache);
   console.error(process.argv.includes('-i') ? e : `${e.constructor.name}: ${e.message}`);
-}
+}
+
+if (process.argv.includes('-t')) console.log(performance.now() - start);

package/runner/repl.js

@@ -45,9 +45,9 @@ let prev = '';
 const run = async (source, _context, _filename, callback, run = true) => {
   // hack: print "secret" before latest code ran to only enable printing for new code
 
-  let toRun = prev + `;\nprint(-0x1337);\n` + source.trim();
+  let toRun = (prev ? (prev + `;\nprint(-0x1337);\n`) : '') + source.trim();
 
-  let shouldPrint = false;
+  let shouldPrint = !prev;
   const { exports, wasm, pages } = await compile(toRun, [], {}, str => {
     if (shouldPrint) process.stdout.write(str);
     if (str === '-4919') shouldPrint = true;