porffor 0.2.0-c7b7423 → 0.2.0-eaee2da

package/compiler/decompile.js

@@ -15,7 +15,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
   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`;
+  if (name && justLocals.length > 0) out += `  local ${justLocals.map(x => invValtype[x.type]).join(' ')}\n`;
 
   let i = -1, lastInst;
   let byte = 0;
@@ -32,7 +32,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       inst = [ [ inst[0], inst[1] ], ...inst.slice(2) ];
     }
 
-    if (inst[0] === Opcodes.end || inst[0] === Opcodes.else || inst[0] === Opcodes.catch_all) depth--;
+    if (depth > 0 && (inst[0] === Opcodes.end || inst[0] === Opcodes.else || inst[0] === Opcodes.catch_all)) depth--;
 
     out += ' '.repeat(Math.max(0, depth * 2));
 
@@ -119,7 +119,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
 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|drop)(\.[^\s]*)?/g, _ => `${_[0]}\x1B[36m${_.slice(1)}\x1B[0m`)
+  .replace(/(i32|i64|f32|f64|drop)(\.[^\s]*)?/g, _ => `\x1B[36m${_}\x1B[0m`)
   .replace(/(return_call|call|br_if|br|return|rethrow|throw)/g, _ => `\x1B[35m${_}\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`)

package/compiler/encoding.js

@@ -105,119 +105,5 @@ export const read_unsignedLEB128 = _input => {
 };
 
 // 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 => {
-  return [...new Uint8Array(new Float64Array([ value ]).buffer)];
-
-  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 => {
-  return new Float64Array(new Uint8Array(buffer).buffer)[0];
-
-  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)
-};
+export const ieee754_binary64 = value => [...new Uint8Array(new Float64Array([ value ]).buffer)];
+export const read_ieee754_binary64 = buffer => new Float64Array(new Uint8Array(buffer).buffer)[0];

package/compiler/index.js

@@ -52,7 +52,7 @@ export default (code, flags) => {
   if (process.argv.includes('-funcs')) logFuncs(funcs, globals, exceptions);
 
   const t2 = performance.now();
-  opt(funcs, globals, pages);
+  opt(funcs, globals, pages, tags);
   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);

package/compiler/opt.js

@@ -11,7 +11,7 @@ const performWasmOp = (op, a, b) => {
   }
 };
 
-export default (funcs, globals, pages) => {
+export default (funcs, globals, pages, tags) => {
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
   if (optLevel === 0) return;
 
@@ -99,10 +99,14 @@ export default (funcs, globals, pages) => {
 
   if (process.argv.includes('-opt-inline-only')) return;
 
+  const tagUse = tags.reduce((acc, x) => { acc[x.idx] = 0; return acc; }, {});
+
   // wasm transform pass
   for (const f of funcs) {
     const wasm = f.wasm;
 
+    const lastType = f.locals['#last_type'];
+
     let runs = 2; // how many by default? add arg?
     while (runs > 0) {
       runs--;
@@ -125,6 +129,8 @@ export default (funcs, globals, pages) => {
         if (inst[0] === Opcodes.local_get) getCount[inst[1]]++;
         if (inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) setCount[inst[1]]++;
 
+        if (inst[0] === Opcodes.throw) tagUse[inst[1]]++;
+
         if (inst[0] === Opcodes.block) {
           // remove unneeded blocks (no brs inside)
           // block
@@ -141,7 +147,7 @@ export default (funcs, globals, pages) => {
               depth--;
               if (depth <= 0) break;
             }
-            if (op === Opcodes.br || op === Opcodes.br_if) {
+            if (op === Opcodes.br || op === Opcodes.br_if || op === Opcodes.br_table) {
               hasBranch = true;
               break;
             }
@@ -221,6 +227,7 @@ export default (funcs, globals, pages) => {
           }
 
           if (checks === 0) {
+            // todo: review indexes below
             wasm.splice(j - 1, 2, [ Opcodes.drop ]); // remove typeswitch start
             wasm.splice(i - 1, 1); // remove this inst
 
@@ -231,6 +238,13 @@ export default (funcs, globals, pages) => {
           }
         }
 
+        // remove setting last type if it is never gotten
+        if (!f.gotLastType && inst[0] === Opcodes.local_set && inst[1] === lastType?.idx) {
+          // replace this inst with drop
+          wasm.splice(i, 1, [ Opcodes.drop ]); // remove this and last inst
+          if (i > 0) i--;
+        }
+
         if (i < 1) continue;
         let lastInst = wasm[i - 1];
 
@@ -531,5 +545,12 @@ export default (funcs, globals, pages) => {
     }
   }
 
+  for (const x in tagUse) {
+    if (tagUse[x] === 0) {
+      const el = tags.find(y => y.idx === x);
+      tags.splice(tags.indexOf(el), 1);
+    }
+  }
+
   // return funcs;
 };

package/compiler/parse.js

@@ -1,4 +1,5 @@
 import { log } from "./log.js";
+// import { parse } from 'acorn';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -6,16 +7,9 @@ if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
   globalThis.process = { argv: ['', '', ...Deno.args], stdout: { write: str => Deno.writeAllSync(Deno.stdout, textEncoder.encode(str)) } };
 }
 
-// import { parse } from 'acorn';
-
-let parser, parse;
-
-const loadParser = async () => {
-  parser = process.argv.find(x => x.startsWith('-parser='))?.split('=')?.[1] ?? 'acorn';
-  0, { parse } = (await import((globalThis.document ? 'https://esm.sh/' : '') + parser));
-};
-globalThis._porf_loadParser = loadParser;
-await loadParser();
+// should we try to support types (while parsing)
+const types = process.argv.includes('-parse-types');
+globalThis.typedInput = types && process.argv.includes('-opt-types');
 
 // todo: review which to use by default
 // supported parsers:
@@ -24,8 +18,13 @@ await loadParser();
 // - hermes-parser
 // - @babel/parser
 
-// should we try to support types (while parsing)
-const types = process.argv.includes('-types');
+let parser, parse;
+const loadParser = async (fallbackParser = 'acorn', forceParser) => {
+  parser = forceParser ?? process.argv.find(x => x.startsWith('-parser='))?.split('=')?.[1] ?? fallbackParser;
+  0, { parse } = (await import((globalThis.document ? 'https://esm.sh/' : '') + parser));
+};
+globalThis._porf_loadParser = loadParser;
+await loadParser(types ? '@babel/parser' : undefined);
 
 if (types && !['@babel/parser', 'hermes-parser'].includes(parser)) log.warning('parser', `passed -types with a parser (${parser}) which does not support`);
 

package/compiler/prototype.js

@@ -16,7 +16,8 @@ const TYPES = {
 
   // these are not "typeof" types but tracked internally
   _array: 0x10,
-  _regexp: 0x11
+  _regexp: 0x11,
+  _bytestring: 0x12
 };
 
 // todo: turn these into built-ins once arrays and these become less hacky
@@ -71,7 +72,7 @@ export const PrototypeFuncs = function() {
     ],
 
     // todo: only for 1 argument
-    push: (pointer, length, wNewMember) => [
+    push: (pointer, length, wNewMember, _1, _2, _3, unusedValue) => [
       // get memory offset of array at last index (length)
       ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
@@ -92,22 +93,28 @@ export const PrototypeFuncs = function() {
         ...number(1, Valtype.i32),
         [ Opcodes.i32_add ],
 
-        ...length.setCachedI32(),
-        ...length.getCachedI32(),
+        ...(unusedValue() ? [] : [
+          ...length.setCachedI32(),
+          ...length.getCachedI32(),
+        ])
       ]),
 
-      ...length.getCachedI32(),
-      Opcodes.i32_from_u
+      ...(unusedValue() ? [] : [
+        ...length.getCachedI32(),
+        Opcodes.i32_from_u
+      ])
 
       // ...length.get()
     ],
 
-    pop: (pointer, length) => [
+    pop: (pointer, length, _1, _2, _3, _4, unusedValue) => [
       // if length == 0, noop
       ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
-      ...number(UNDEFINED),
+      ...(unusedValue() ? [] : [
+        ...number(UNDEFINED),
+      ]),
       [ Opcodes.br, 1 ],
       [ Opcodes.end ],
 
@@ -119,19 +126,23 @@ export const PrototypeFuncs = function() {
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ],
 
-        ...length.setCachedI32(),
-        ...length.getCachedI32(),
+        ...(unusedValue() ? [] : [
+          ...length.setCachedI32(),
+          ...length.getCachedI32(),
+        ])
       ]),
 
       // load last element
-      ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
-      [ Opcodes.i32_mul ],
+      ...(unusedValue() ? [] : [
+        ...length.getCachedI32(),
+        ...number(ValtypeSize[valtype], Valtype.i32),
+        [ Opcodes.i32_mul ],
 
-      ...pointer,
-      [ Opcodes.i32_add ],
+        ...pointer,
+        [ Opcodes.i32_add ],
 
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+        [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+      ])
     ],
 
     shift: (pointer, length) => [
@@ -472,8 +483,152 @@ export const PrototypeFuncs = function() {
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
   this[TYPES.string].charCodeAt.local = Valtype.i32;
+  this[TYPES.string].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
   this[TYPES.string].isWellFormed.local = Valtype.i32;
   this[TYPES.string].isWellFormed.local2 = Valtype.i32;
   this[TYPES.string].isWellFormed.returnType = TYPES.boolean;
+
+  if (process.argv.includes('-bytestring')) {
+    this[TYPES._bytestring] = {
+      at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
+        const [ newOut, newPointer ] = arrayShell(1, 'i16');
+
+        return [
+          // setup new/out array
+          ...newOut,
+          [ Opcodes.drop ],
+
+          ...number(0, Valtype.i32), // base 0 for store later
+
+          ...wIndex,
+          Opcodes.i32_to_u,
+          [ Opcodes.local_tee, iTmp ],
+
+          // if index < 0: access index + array length
+          ...number(0, Valtype.i32),
+          [ Opcodes.i32_lt_s ],
+          [ Opcodes.if, Blocktype.void ],
+          [ Opcodes.local_get, iTmp ],
+          ...length.getCachedI32(),
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_set, iTmp ],
+          [ Opcodes.end ],
+
+          // if still < 0 or >= length: return undefined
+          [ Opcodes.local_get, iTmp ],
+          ...number(0, Valtype.i32),
+          [ Opcodes.i32_lt_s ],
+
+          [ Opcodes.local_get, iTmp ],
+          ...length.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
+          [ Opcodes.i32_or ],
+
+          [ Opcodes.if, Blocktype.void ],
+          ...number(UNDEFINED),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
+
+          [ Opcodes.local_get, iTmp ],
+
+          ...pointer,
+          [ Opcodes.i32_add ],
+
+          // load current string ind {arg}
+          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+          // store to new string ind 0
+          [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+          // return new string (pointer)
+          ...number(newPointer)
+        ];
+      },
+
+      // todo: out of bounds properly
+      charAt: (pointer, length, wIndex, _1, _2, arrayShell) => {
+        const [ newOut, newPointer ] = arrayShell(1, 'i16');
+
+        return [
+          // setup new/out array
+          ...newOut,
+          [ Opcodes.drop ],
+
+          ...number(0, Valtype.i32), // base 0 for store later
+
+          ...wIndex,
+
+          Opcodes.i32_to,
+
+          ...pointer,
+          [ Opcodes.i32_add ],
+
+          // load current string ind {arg}
+          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+          // store to new string ind 0
+          [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+          // return new string (page)
+          ...number(newPointer)
+        ];
+      },
+
+      charCodeAt: (pointer, length, wIndex, iTmp) => {
+        return [
+          ...wIndex,
+          Opcodes.i32_to,
+
+          ...(zeroChecks.charcodeat ? [] : [
+            [ Opcodes.local_set, iTmp ],
+
+            // index < 0
+            ...(noUnlikelyChecks ? [] : [
+              [ Opcodes.local_get, iTmp ],
+              ...number(0, Valtype.i32),
+              [ Opcodes.i32_lt_s ],
+            ]),
+
+            // index >= length
+            [ Opcodes.local_get, iTmp ],
+            ...length.getCachedI32(),
+            [ Opcodes.i32_ge_s ],
+
+            ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+            [ Opcodes.if, Blocktype.void ],
+            ...number(NaN),
+            [ Opcodes.br, 1 ],
+            [ Opcodes.end ],
+
+            [ Opcodes.local_get, iTmp ],
+          ]),
+
+          ...pointer,
+          [ Opcodes.i32_add ],
+
+          // load current string ind {arg}
+          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+          Opcodes.i32_from_u
+        ];
+      },
+
+      isWellFormed: () => {
+        return [
+          // we know it must be true as it is a bytestring lol
+          ...number(1)
+        ]
+      }
+    };
+
+    this[TYPES._bytestring].at.local = Valtype.i32;
+    this[TYPES._bytestring].at.returnType = TYPES._bytestring;
+    this[TYPES._bytestring].charAt.returnType = TYPES._bytestring;
+    this[TYPES._bytestring].charCodeAt.local = Valtype.i32;
+    this[TYPES._bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
+
+    this[TYPES._bytestring].isWellFormed.local = Valtype.i32;
+    this[TYPES._bytestring].isWellFormed.local2 = Valtype.i32;
+    this[TYPES._bytestring].isWellFormed.returnType = TYPES.boolean;
+  }
 };

package/compiler/sections.js

@@ -150,7 +150,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
       if (typeCount !== 0) localDecl.push(encodeLocal(typeCount, lastType));
 
-      return encodeVector([ ...encodeVector(localDecl), ...x.wasm.flat().filter(x => x <= 0xff), Opcodes.end ]);
+      return encodeVector([ ...encodeVector(localDecl), ...x.wasm.flat().filter(x => x != null && x <= 0xff), Opcodes.end ]);
     }))
   );
 

package/compiler/wasmSpec.js

@@ -32,8 +32,6 @@ export const Opcodes = {
   throw: 0x08,
   rethrow: 0x09,
 
-  return: 0x0F,
-
   call: 0x10,
   call_indirect: 0x11,
   return_call: 0x12,
@@ -42,7 +40,10 @@ export const Opcodes = {
   end: 0x0b,
   br: 0x0c,
   br_if: 0x0d,
+  br_table: 0x0e,
+  return: 0x0f,
   call: 0x10,
+
   drop: 0x1a,
 
   local_get: 0x20,
@@ -56,9 +57,12 @@ export const Opcodes = {
   i64_load: 0x29,
   f64_load: 0x2b,
 
+  i32_load8_s: 0x2c,
+  i32_load8_u: 0x2d,
   i32_load16_s: 0x2e,
   i32_load16_u: 0x2f,
 
+  i32_store8: 0x3a,
   i32_store16: 0x3b,
 
   i32_store: 0x36,

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,95 @@ 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) {
+    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,6 +178,13 @@ 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);