porffor 0.16.0-594397507 → 0.16.0-688a50c13

package/compiler/parse.js

@@ -43,7 +43,7 @@ export default (input, flags) => {
       webcompat: true,
 
       // babel
-      plugins: types ? ['estree', 'typescript'] : ['estree'],
+      plugins: types || flags.includes('typed') ? ['estree', 'typescript'] : ['estree'],
 
       // multiple
       sourceType: flags.includes('module') ? 'module' : 'script',

package/compiler/pgo.js

@@ -0,0 +1,207 @@
+import { Opcodes, Valtype } from './wasmSpec.js';
+import { number } from './embedding.js';
+import { importedFuncs } from './builtins.js';
+import Prefs from './prefs.js';
+import assemble from './assemble.js';
+import wrap, { writeByteStr } from './wrap.js';
+import * as Havoc from './havoc.js';
+
+export const setup = () => {
+  importedFuncs[importedFuncs.profile2].params = [ Valtype.i32, valtypeBinary ];
+
+  // enable these prefs by default for pgo
+  Prefs.typeswitchUniqueTmp = Prefs.typeswitchUniqueTmp === false ? false : true;
+  Prefs.cyclone = Prefs.cyclone === false ? false : true;
+};
+
+export const run = obj => {
+  const wasmFuncs = obj.funcs;
+
+  let starts = {};
+  const time = (id, msg) => {
+    if (!Prefs.pgoLog) return;
+
+    if (!starts[id]) {
+      process.stdout.write(msg);
+      starts[id] = performance.now();
+    } else {
+      process.stdout.write(`\r${' '.repeat(50)}\r[${(performance.now() - starts[id]).toFixed(2)}ms] ${msg}\n`);
+    }
+  };
+
+  time(0, `injecting PGO logging...`);
+
+  let funcs = [];
+  for (let i = 0; i < wasmFuncs.length; i++) {
+    const { name, internal, params, locals, wasm } = wasmFuncs[i];
+    if (internal) continue; // ignore internal funcs
+    wasmFuncs[i].originalWasm = structuredClone(wasm);
+
+    const invLocals = Object.keys(locals).reduce((acc, x) => { acc[locals[x].idx] = locals[x]; return acc; }, {});
+
+    const id = funcs.length;
+    funcs.push({ name, id, locals, params, invLocals });
+
+    wasm.unshift(
+      // mark active func
+      ...number(i, Valtype.i32),
+      [ Opcodes.call, importedFuncs.profile1 ],
+
+      // log args
+      ...params.flatMap((_, i) => [
+        ...number(i, Valtype.i32),
+        [ Opcodes.local_get, i ],
+        ...(invLocals[i].type !== Valtype.f64 ? [ Opcodes.i32_from ] : []),
+        [ Opcodes.call, importedFuncs.profile2 ]
+      ])
+    );
+
+    for (let j = 0; j < wasm.length; j++) {
+      const inst = wasm[j];
+      if (inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) {
+        wasm.splice(j + 1, 0,
+          ...number(inst[1], Valtype.i32),
+          [ Opcodes.local_get, inst[1] ],
+          ...(invLocals[inst[1]].type !== Valtype.f64 ? [ Opcodes.i32_from ] : []),
+          [ Opcodes.call, importedFuncs.profile2 ]
+        );
+      }
+    }
+  }
+
+  let localData = funcs.map(x => new Array(Object.keys(x.locals).length).fill(0).map(() => []));
+
+  time(0, `injected PGO logging`);
+  time(1, `running with PGO logging...`);
+
+  let activeFunc = null, abort = false;
+  try {
+    obj.wasm = assemble(obj.funcs, obj.globals, obj.tags, obj.pages, obj.data, obj.flags, true);
+
+    const { exports } = wrap(obj, [], {
+      y: n => {
+        activeFunc = n;
+      },
+      z: (i, n) => {
+        if (activeFunc == null) throw 'fail';
+        localData[activeFunc][i].push(n);
+      },
+      w: (ind, outPtr) => { // readArgv
+        const pgoInd = process.argv.indexOf('--pgo');
+        const args = process.argv.slice(pgoInd).filter(x => !x.startsWith('-'));
+        const str = args[ind - 1];
+        if (pgoInd === -1 || !str) {
+          if (Prefs.pgoLog) console.log('\nPGO warning: script was expecting arguments, please specify args to use for PGO after --pgo arg');
+          return -1;
+        }
+
+        writeByteStr(exports.$, outPtr, str);
+        return str.length;
+      }
+    }, () => {});
+
+    exports.main();
+  } catch (e) {
+    throw e;
+  }
+
+  for (const x of funcs) {
+    const wasmFunc = wasmFuncs.find(y => y.name === x.name);
+    wasmFunc.wasm = wasmFunc.originalWasm;
+    delete wasmFunc.originalWasm;
+  }
+
+  if (abort) {
+    console.log('aborting PGO!');
+    return false;
+  }
+
+  time(1, `ran with PGO logging`);
+  time(2, 'processing PGO data...');
+
+  // process data
+  let log = '';
+  for (let i = 0; i < localData.length; i++) {
+    const func = funcs[i];
+    const total = localData[i].length;
+
+    const localKeys = Object.keys(func.locals).sort((a, b) => a.idx - b.idx);
+    const localValues = Object.values(func.locals).sort((a, b) => a.idx - b.idx);
+    func.localKeys = localKeys;
+    func.localValues = localValues;
+
+    let counts = new Array(10).fill(0);
+    const consistents = localData[i].map((x, j) => {
+      if (j < func.params.length) return false; // param
+      if (x.length === 0 || !x.every((y, i) => i < 1 ? true : y === x[i - 1])) return false; // not consistent
+
+      counts[0]++;
+      return x[0];
+    });
+
+    const integerOnlyF64s = localData[i].map((x, j) => {
+      if (j < func.params.length) return false; // param
+      if (localValues[j].type === Valtype.i32) return false; // already i32
+      if (x.length === 0 || !x.every(y => Number.isInteger(y))) return false; // not all integer values
+
+      counts[1]++;
+      return true;
+    });
+
+    func.consistents = consistents;
+    func.integerOnlyF64s = integerOnlyF64s;
+
+    log += `  ${func.name}: identified ${counts[0]}/${total} locals as consistent${Prefs.verbosePgo ? ':' : ''}\n`;
+    if (Prefs.verbosePgo) {
+      for (let j = func.params.length; j < localData[i].length; j++) {
+        log += `    ${consistents[j] !== false ? '\u001b[92m' : '\u001b[91m'}${localKeys[j]}\u001b[0m: ${new Set(localData[i][j]).size} unique values set\n`;
+      }
+    }
+
+    log += `  ${func.name}: identified ${counts[1]}/${localValues.reduce((acc, x) => acc + (x.type === Valtype.f64 ? 1 : 0), 0)} f64 locals as integer usage only${Prefs.verbosePgo ? ':' : ''}\n`;
+    if (Prefs.verbosePgo) {
+      for (let j = func.params.length; j < localData[i].length; j++) {
+        if (localValues[j].type !== Valtype.f64) continue;
+        log += `    ${integerOnlyF64s[j] ? '\u001b[92m' : '\u001b[91m'}${localKeys[j]}\u001b[0m\n`;
+      }
+
+      log += '\n';
+    }
+  }
+
+  time(2, 'processed PGO data' + log);
+  time(3, 'optimizing using PGO data...');
+
+  log = '';
+  for (const x of funcs) {
+    const wasmFunc = wasmFuncs.find(y => y.name === x.name);
+
+    let targets = [];
+    for (let i = 0; i < x.integerOnlyF64s.length; i++) {
+      const c = x.integerOnlyF64s[i];
+      if (c === false) continue;
+
+      targets.push(i);
+    }
+
+    log += `  ${x.name}: replaced ${targets.length} f64 locals with i32s\n`;
+    if (targets.length > 0) Havoc.f64ToI32s(wasmFunc, targets);
+
+    targets = [];
+    let consts = [];
+    for (let i = 0; i < x.consistents.length; i++) {
+      const c = x.consistents[i];
+      if (c === false) continue;
+
+      targets.push(i);
+
+      const valtype = x.localValues[i].type;
+      consts.push(number(c, valtype)[0]);
+    }
+
+    log += `  ${x.name}: replaced ${targets.length} locals with consts\n`;
+    if (targets.length > 0) Havoc.localsToConsts(wasmFunc, targets, consts, { localKeys: x.localKeys });
+  }
+
+  time(3, 'optimized using PGO data' + log);
+};

package/compiler/precompile.js

@@ -26,7 +26,7 @@ const compile = async (file, [ _funcs, _globals ]) => {
 
   const porfCompile = (await import(`./index.js?_=${Date.now()}`)).default;
 
-  let { funcs, globals, data, exceptions } = porfCompile(source, ['module']);
+  let { funcs, globals, data, exceptions } = porfCompile(source, ['module', 'typed']);
 
   const allocated = new Set();
 
@@ -38,11 +38,14 @@ const compile = async (file, [ _funcs, _globals ]) => {
         x.data[y].offset -= x.data[0].offset;
       }
     }
-    if (x.exceptions) x.exceptions = x.exceptions.map(x => {
-      const obj = exceptions[x];
-      if (obj) obj.exceptId = x;
-      return obj;
-    }).filter(x => x);
+
+    if (x.exceptions) {
+      x.exceptions = x.exceptions.map(x => {
+        const obj = exceptions[x];
+        if (obj) obj.exceptId = x;
+        return obj;
+      }).filter(x => x);
+    }
 
     const locals = Object.keys(x.locals).reduce((acc, y) => {
       acc[x.locals[y].idx] = { ...x.locals[y], name: y };
@@ -87,6 +90,8 @@ const compile = async (file, [ _funcs, _globals ]) => {
 };
 
 const precompile = async () => {
+  if (globalThis._porf_loadParser) await globalThis._porf_loadParser('@babel/parser');
+
   const dir = join(__dirname, 'builtins');
 
   let funcs = [], globals = [];

package/compiler/prefs.js

@@ -1,4 +1,4 @@
-const onByDefault = [ 'bytestring', 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls', 'optUnused' ];
+const onByDefault = [ 'bytestring', 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls', 'optUnused', 'data', 'rmUnusedTypes' ];
 
 let cache = {};
 const obj = new Proxy({}, {
@@ -23,9 +23,14 @@ const obj = new Proxy({}, {
     // do not cache in web demo as args are changed live
     if (!globalThis.document) cache[p] = ret;
     return ret;
+  },
+
+  set(_, p, v) {
+    cache[p] = v;
+    return true;
   }
 });
 
-obj.uncache = () => cache = {};
+export const uncache = () => cache = {};
 
 export default obj;

package/compiler/prototype.js

@@ -1,6 +1,5 @@
 import { Opcodes, Blocktype, Valtype, ValtypeSize } from './wasmSpec.js';
 import { number } from './embedding.js';
-import { unsignedLEB128 } from './encoding.js';
 import { UNDEFINED } from './builtins.js';
 import { TYPES } from './types.js';
 import Prefs from './prefs.js';
@@ -55,10 +54,10 @@ export const PrototypeFuncs = function() {
 
       // read from memory
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.load, 0, ValtypeSize.i32 ],
 
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ]
+      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
     ],
 
     // todo: only for 1 argument
@@ -74,12 +73,12 @@ export const PrototypeFuncs = function() {
       // store value
       [ Opcodes.local_get, iTmp ],
       ...wNewMember,
-      [ Opcodes.store, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.store, 0, ValtypeSize.i32 ],
 
       // store type
       [ Opcodes.local_get, iTmp ],
       ...wType,
-      [ Opcodes.i32_store8, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
+      [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
 
       // bump array length by 1 and return it
       ...length.setI32([
@@ -137,10 +136,10 @@ export const PrototypeFuncs = function() {
         [ Opcodes.local_set, iTmp ],
 
         [ Opcodes.local_get, iTmp ],
-        [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+        [ Opcodes.load, 0, ValtypeSize.i32 ],
 
         [ Opcodes.local_get, iTmp ],
-        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ]
+        [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
       ])
     ],
 
@@ -168,10 +167,10 @@ export const PrototypeFuncs = function() {
       // load first element
       // todo/perf: unusedValue opt
       ...pointer,
-      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.load, 0, ValtypeSize.i32 ],
 
       ...pointer,
-      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
+      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
 
       // offset page by -1 ind
       // ...number(pointer + ValtypeSize.i32, Valtype.i32), // dst = base array index + length size
@@ -250,12 +249,12 @@ export const PrototypeFuncs = function() {
       // store value
       [ Opcodes.local_get, iTmp2 ],
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.store, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.store, 0, ValtypeSize.i32 ],
 
       // store type
       [ Opcodes.local_get, iTmp2 ],
       ...wType,
-      [ Opcodes.i32_store8, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
+      [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
 
       // pointer - sizeof value
       ...length.getCachedI32(),
@@ -292,11 +291,8 @@ export const PrototypeFuncs = function() {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
-        // setup new/out array
+        // setup new/out array and use pointer for store
         ...newOut,
-        [ Opcodes.drop ],
-
-        ...number(0, Valtype.i32), // base 0 for store later
 
         ...wIndex,
         Opcodes.i32_to_u,
@@ -335,13 +331,14 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_add ],
 
         // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
         // store to new string ind 0
-        [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+        [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
         // return new string (pointer)
-        ...number(newPointer)
+        ...newPointer,
+        Opcodes.i32_from_u
       ];
     },
 
@@ -350,11 +347,8 @@ export const PrototypeFuncs = function() {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
-        // setup new/out array
+        // setup new/out array and use as pointer for store
         ...newOut,
-        [ Opcodes.drop ],
-
-        ...number(0, Valtype.i32), // base 0 for store later
 
         ...wIndex,
         Opcodes.i32_to,
@@ -366,13 +360,14 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_add ],
 
         // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
         // store to new string ind 0
-        [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+        [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
         // return new string (page)
-        ...number(newPointer)
+        ...newPointer,
+        Opcodes.i32_from_u
       ];
     },
 
@@ -411,7 +406,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_add ],
 
       // load current string ind {arg}
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
       Opcodes.i32_from_u
     ],
 
@@ -433,7 +428,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.block, Blocktype.void ],
 
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
       [ Opcodes.local_set, iTmp2 ],
 
       // if not surrogate, continue
@@ -455,7 +450,7 @@ export const PrototypeFuncs = function() {
 
       // if not followed by trailing surrogate, return false
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize.i16) ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 + ValtypeSize.i16 ],
       ...number(0xFC00, Valtype.i32),
       [ Opcodes.i32_and ],
       ...number(0xDC00, Valtype.i32),
@@ -507,11 +502,8 @@ export const PrototypeFuncs = function() {
         const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
         return [
-          // setup new/out array
+          // setup new/out array and use pointer for store later
           ...newOut,
-          [ Opcodes.drop ],
-
-          ...number(0, Valtype.i32), // base 0 for store later
 
           ...wIndex,
           Opcodes.i32_to_u,
@@ -548,13 +540,14 @@ export const PrototypeFuncs = function() {
           [ Opcodes.i32_add ],
 
           // load current string ind {arg}
-          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+          [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
 
           // store to new string ind 0
-          [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+          [ Opcodes.i32_store8, 0, ValtypeSize.i32 ],
 
           // return new string (pointer)
-          ...number(newPointer)
+          ...newPointer,
+          Opcodes.i32_from_u
         ];
       },
 
@@ -563,11 +556,8 @@ export const PrototypeFuncs = function() {
         const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
         return [
-          // setup new/out array
+          // setup new/out array and use pointer for later
           ...newOut,
-          [ Opcodes.drop ],
-
-          ...number(0, Valtype.i32), // base 0 for store later
 
           ...wIndex,
           Opcodes.i32_to,
@@ -576,13 +566,14 @@ export const PrototypeFuncs = function() {
           [ Opcodes.i32_add ],
 
           // load current string ind {arg}
-          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+          [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
 
           // store to new string ind 0
-          [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+          [ Opcodes.i32_store8, 0, ValtypeSize.i32 ],
 
           // return new string (page)
-          ...number(newPointer)
+          ...newPointer,
+          Opcodes.i32_from_u
         ];
       },
 
@@ -618,7 +609,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_add ],
 
         // load current string ind {arg}
-        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+        [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
         Opcodes.i32_from_u
       ],
 

package/compiler/wrap.js

@@ -6,8 +6,25 @@ import { TYPES } from './types.js';
 import { log } from './log.js';
 import Prefs from './prefs.js';
 
+const fs = (typeof process?.version !== 'undefined' ? (await import('node:fs')) : undefined);
+
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
+export const readByteStr = (memory, ptr) => {
+  const length = (new Int32Array(memory.buffer.slice(ptr, ptr + 4), 0, 1))[0];
+  return Array.from(new Uint8Array(memory.buffer, ptr + 4, length)).map(x => String.fromCharCode(x)).join('');
+};
+
+export const writeByteStr = (memory, ptr, str) => {
+  const length = str.length;
+  (new Int32Array(memory.buffer.slice(ptr, ptr + 4), 0, 1))[0] = length;
+
+  const arr = new Uint8Array(memory.buffer, ptr + 4, length);
+  for (let i = 0; i < length; i++) {
+    arr[i] = str.charCodeAt(i);
+  }
+};
+
 const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
   switch (type) {
     case TYPES.boolean: return Boolean(value);
@@ -29,17 +46,17 @@ const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
     }
 
     case TYPES.string: {
-      const length = (new Int32Array(memory.buffer, value, 1))[0];
+      const length = (new Int32Array(memory.buffer.slice(value, value + 4), 0, 1))[0];
       return Array.from(new Uint16Array(memory.buffer, value + 4, length)).map(x => String.fromCharCode(x)).join('');
     }
 
     case TYPES.bytestring: {
-      const length = (new Int32Array(memory.buffer, value, 1))[0];
+      const length = (new Int32Array(memory.buffer.slice(value, value + 4), 0, 1))[0];
       return Array.from(new Uint8Array(memory.buffer, value + 4, length)).map(x => String.fromCharCode(x)).join('');
     }
 
     case TYPES.array: {
-      const length = (new Int32Array(memory.buffer, value, 1))[0];
+      const length = (new Int32Array(memory.buffer.slice(value, value + 4), 0, 1))[0];
 
       const out = [];
       for (let i = 0; i < length; i++) {
@@ -60,12 +77,12 @@ const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
     }
 
     case TYPES.date: {
-      const t = (new Float64Array(memory.buffer, value, 1))[0];
+      const t = (new Float64Array(memory.buffer.slice(value, value + 8), 0, 1))[0];
       return new Date(t);
     }
 
     case TYPES.set: {
-      const size = (new Int32Array(memory.buffer, value, 1))[0];
+      const size = (new Int32Array(memory.buffer.slice(value, value + 4), 0, 1))[0];
 
       const out = new Set();
       for (let i = 0; i < size; i++) {
@@ -85,44 +102,47 @@ const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
       return out;
     }
 
-    case TYPES.symbol: {
-      const descStore = pages.get('bytestring: __Porffor_symbol_descStore/ptr').ind * pageSize;
-      const offset = descStore + 4 + ((value - 1) * 9);
+    // case TYPES.symbol: {
+    //   const descStore = pages.get('bytestring: __Porffor_symbol_descStore/ptr').ind * pageSize;
+    //   const offset = descStore + 4 + ((value - 1) * 9);
 
-      const v = (new Float64Array(memory.buffer.slice(offset, offset + 8), 0, 1))[0];
-      const t = (new Uint8Array(memory.buffer, offset + 8, 1))[0];
+    //   const v = (new Float64Array(memory.buffer.slice(offset, offset + 8), 0, 1))[0];
+    //   const t = (new Uint8Array(memory.buffer, offset + 8, 1))[0];
 
-      const desc = porfToJSValue({ memory, funcs, pages }, v, t);
+    //   const desc = porfToJSValue({ memory, funcs, pages }, v, t);
 
-      return Symbol(desc);
-    }
+    //   return Symbol(desc);
+    // }
 
     default: return value;
   }
 };
 
-export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
+export default (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
   const times = [];
 
   const t1 = performance.now();
-  const { wasm, funcs, globals, tags, exceptions, pages, c } = compile(source, flags);
+  const { wasm, funcs, globals, tags, exceptions, pages, c } = typeof source === 'object' ? source : compile(source, flags);
 
   globalThis.porfDebugInfo = { funcs, globals };
 
-  if (source.includes('export function')) flags.push('module');
+  if (source.includes?.('export ')) flags.push('module');
 
-  // (await import('node:fs')).writeFileSync('out.wasm', Buffer.from(wasm));
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (Prefs.profileCompiler) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
   const backtrace = (funcInd, blobOffset) => {
-    if (funcInd == null || blobOffset == null) return false;
+    if (funcInd == null || blobOffset == null ||
+        Number.isNaN(funcInd) || Number.isNaN(blobOffset)) return false;
 
     // 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);
+    if (!func) return false;
+
     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;
@@ -197,13 +217,15 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   let instance;
   try {
-    let wasmEngine = WebAssembly;
-    if (Prefs.asur) {
-      log.warning('wrap', 'using our !experimental! asur wasm engine instead of host to run');
-      wasmEngine = await import('../asur/index.js');
-    }
-
-    0, { instance } = await wasmEngine.instantiate(wasm, {
+    // let wasmEngine = WebAssembly;
+    // if (Prefs.asur) {
+    //   log.warning('wrap', 'using our !experimental! asur wasm engine instead of host to run');
+    //   wasmEngine = await import('../asur/index.js');
+    // }
+
+    // 0, { instance } = await wasmEngine.instantiate(wasm, {
+    const module = new WebAssembly.Module(wasm);
+    instance = new WebAssembly.Instance(module, {
       '': {
         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)),
@@ -211,12 +233,31 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
         u: () => performance.timeOrigin,
         y: () => {},
         z: () => {},
+        w: (ind, outPtr) => { // readArgv
+          const args = process.argv.slice(2).filter(x => !x.startsWith('-'));
+          const str = args[ind];
+          if (!str) return -1;
+
+          writeByteStr(memory, outPtr, str);
+          return str.length;
+        },
+        q: (pathPtr, outPtr) => { // readFile
+          try {
+            const path = readByteStr(memory, pathPtr);
+            const contents = fs.readFileSync(path, 'utf8');
+            writeByteStr(memory, outPtr, contents);
+            return contents.length;
+          } catch {
+            return -1;
+          }
+        },
         ...customImports
       }
     });
   } catch (e) {
     // only backtrace for runner, not test262/etc
     if (!process.argv[1].includes('/runner')) throw e;
+    if (!(e instanceof WebAssembly.CompileError)) throw e;
 
     const funcInd = parseInt(e.message.match(/function #([0-9]+) /)?.[1]);
     const blobOffset = parseInt(e.message.split('@')?.[1]);