porffor 0.2.0-aea77ff → 0.2.0-af678f0

package/README.md

@@ -121,7 +121,7 @@ No particular order and no guarentees, just what could happen soon™
   - *Basic* Wasm engine (interpreter) in JS
 - More math operators (`**`, etc)
 - `do { ... } while (...)`
-- Rewrite `console.log` to work with strings/arrays
+- Typed export inputs (array)
 - Exceptions
   - Rewrite to use actual strings (optional?)
   - `try { } finally { }`
@@ -130,7 +130,7 @@ No particular order and no guarentees, just what could happen soon™
   - Rewrite local indexes per func for smallest local header and remove unused idxs
   - Smarter inline selection (snapshots?)
   - Remove const ifs (`if (true)`, etc)
-  - Experiment with byte strings?
+  - Memory alignment
 - Runtime
   - WASI target
   - Run precompiled Wasm file if given
@@ -147,7 +147,7 @@ No particular order and no guarentees, just what could happen soon™
 - Self hosted testing?
 
 ## Performance
-*For the things it supports most of the time*, Porffor is blazingly fast compared to most interpreters, and common engines running without JIT. For those with JIT, it is not that much slower like a traditional interpreter would be; mostly the same or a bit faster/slower depending on what.
+*For the things it supports most of the time*, Porffor is *blazingly fast* compared to most interpreters, and common engines running without JIT. For those with JIT, it is usually slower by default, but can catch up with compiler arguments and typed input.
 
 ![Screenshot of comparison chart](https://github.com/CanadaHonk/porffor/assets/19228318/76c75264-cc68-4be1-8891-c06dc389d97a)
 
@@ -209,17 +209,42 @@ Porffor can run Test262 via some hacks/transforms which remove unsupported featu
 - `test262`: test262 runner and utils
 
 ## Usecases
-Basically none (other than giving people headaches). Potential ideas to come?
+Basically none right now (other than giving people headaches). Potential ideas:
+- Safety. As Porffor is written in JS, a memory-safe language\*, and compiles JS to Wasm, a fully sandboxed environment\*, it is quite safe. (\* These rely on the underlying implementations being secure. You could also run Wasm, or even Porffor itself, with an interpreter instead of a JIT for bonus security points too.)
+- Compiling JS to native binaries. This is still very early!
+- More in future probably?
 
 ## Usage
-Basically nothing will work :). See files in `test` for examples.
+Basically nothing will work :). See files in `test` and `bench` for examples.
 
-1. Clone repo
-2. `npm install`
-3. `node test` to run tests (some will fail)
-4. `node runner path/to/code.js` to run a file (or `node runner` to use wip repl)
+### Setup
+1. Clone this repo
+2. `npm install` - for parser(s)
 
-You can also use Deno (`deno run -A ...` instead of `node ...`), or Bun (`bun ...` instead of `node ...`).
+### Running a file
+The repos comes with easy alias files for Unix and Windows, which you can use like so:
+- Unix: `./porf path/to/script.js`
+- Windows: `.\porf path/to/script.js`
+
+Please note that further examples below will just use `./porf`, you need to use `.\porf` on Windows. You can also swap out `node` in the alias to use another runtime like Deno (`deno run -A`) or Bun (`bun ...`), or just use it yourself (eg `node runner/index.js ...`, `bun runner/index.js ...`). Node and Bun should work great, Deno support is WIP.
+
+### Trying a REPL
+**`./porf`**. Just run it with no script file argument.
+
+### Compiling to native binaries
+> [!WARNING]
+> Compiling to native binaries uses [2c](#2c), Porffor's own Wasm->C compiler, which is experimental.
+
+**`./porf native path/to/script.js out(.exe)`**. You can specify the compiler with `-compiler=clang/zig/gcc`, and which opt level to use with `-cO=O3` (`Ofast` by default). Output binaries are also stripped by default.
+
+### Compiling to C
+> [!WARNING]
+> Compiling to C uses [2c](#2c), Porffor's own Wasm->C compiler, which is experimental.
+
+**`./porf c path/to/script.js (out.c)`**. When not including an output file, it will be printed to stdout instead.
+
+### Compiling to a Wasm binary
+**`./porf compile path/to/script.js out.wasm`**. Currently it does not use an import standard like WASI, so it is mostly unusable.
 
 ### Options
 - `-target=wasm|c|native` (default: `wasm`) to set target output (native compiles c output to binary, see args below)

package/compiler/2c.js

@@ -1,24 +1,106 @@
-import { read_ieee754_binary64, read_signedLEB128 } from './encoding.js';
+import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
 import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
 import { operatorOpcode } from './expression.js';
 import { log } from "./log.js";
 
 const CValtype = {
-  i8: 'char',
-  i16: 'unsigned short', // presume all i16 stuff is unsigned
-  i32: 'long',
-  i32_u: 'unsigned long',
-  i64: 'long long',
-  i64_u: 'unsigned long long',
+  i8: 'i8',
+  i16: 'i16',
+  i32: 'i32',
+  u32: 'u32',
+  i64: 'i64',
+  u64: 'u64',
 
-  f32: 'float',
-  f64: 'double',
+  f32: 'f32',
+  f64: 'f64',
 
   undefined: 'void'
 };
 
+const alwaysPreface = `typedef uint8_t i8;
+typedef uint16_t i16;
+typedef int32_t i32;
+typedef uint32_t u32;
+typedef int64_t i64;
+typedef uint64_t u64;
+typedef float f32;
+typedef double f64;
+
+f64 NAN = 0e+0/0e+0;
+
+struct ReturnValue {
+  ${CValtype.f64} value;
+  ${CValtype.i32} type;
+};\n\n`;
+
+// todo: is memcpy/etc safe with host endianness?
+
+// all:
+// immediates: ['align', 'offset']
+const CMemFuncs = {
+  [Opcodes.i32_store]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.i32],
+    returns: false
+  },
+  [Opcodes.i32_store16]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.i16],
+    returns: false
+  },
+  [Opcodes.i32_store8]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.i8],
+    returns: false
+  },
+
+  [Opcodes.i32_load]: {
+    c: `${CValtype.i32} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.i32
+  },
+  [Opcodes.i32_load16_u]: {
+    c: `${CValtype.i16} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.i32
+  },
+  [Opcodes.i32_load8_u]: {
+    c: `${CValtype.i8} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.i32
+  },
+
+  [Opcodes.f64_store]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.f64],
+    returns: false
+  },
+  [Opcodes.f64_load]: {
+    c: `${CValtype.f64} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.f64
+  },
+};
+
 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);
 
 for (const x in CValtype) {
   if (Valtype[x]) CValtype[Valtype[x]] = CValtype[x];
@@ -36,11 +118,18 @@ const todo = msg => {
 };
 
 const removeBrackets = str => {
-  if (str.startsWith('(long)(unsigned long)')) return '(long)(unsigned long)(' + removeBrackets(str.slice(22, -1)) + ')';
+  // return str;
+  // if (str.startsWith(`(${CValtype.i32})(${CValtype.u32})`)) return `(${CValtype.i32})(${CValtype.u32})(` + removeBrackets(str.slice(22, -1)) + ')';
+
+  for (const x in CValtype) {
+    const p = `(${x})`;
+    if (str.startsWith(p)) return p + removeBrackets(str.slice(p.length));
+  }
+
   return str.startsWith('(') && str.endsWith(')') ? str.slice(1, -1) : str;
 };
 
-export default ({ funcs, globals, tags, exceptions, pages }) => {
+export default ({ funcs, globals, tags, data, exceptions, pages }) => {
   const invOperatorOpcode = Object.values(operatorOpcode).reduce((acc, x) => {
     for (const k in x) {
       acc[x[k]] = k;
@@ -56,12 +145,11 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
   }
 
   const includes = new Map(), unixIncludes = new Map(), winIncludes = new Map();
+  const prepend = new Map(), prependMain = new Map();
 
-  // TODO: make type i16
-  let out = `struct ReturnValue {
-  ${CValtype.f64} value;
-  ${CValtype.i32} type;
-};\n\n`;
+  includes.set('stdint.h', true);
+
+  let out = ``;
 
   for (const x in globals) {
     const g = globals[x];
@@ -70,6 +158,15 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     out += ';\n';
   }
 
+  if (pages.size > 0) {
+    prepend.set('_memory', `char _memory[${pages.size * pageSize}];\n`);
+    includes.set('string.h', true);
+  }
+
+  if (data.length > 0) {
+    prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n'));
+  }
+
   // for (const [ x, p ] of pages) {
     // out += `${CValtype[p.type]} ${x.replace(': ', '_').replace(/[^0-9a-zA-Z_]/g, '')}[100]`;
     // out += ';\n';
@@ -78,7 +175,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
   if (out) out += '\n';
 
   let depth = 1;
-  const line = (str, semi = true) => out += `${' '.repeat(depth * 2)}${str}${semi ? ';' : ''}\n`;
+  let brDepth = 0;
+  const line = (str, semi = true) => out += `${' '.repeat(depth * 2 + brDepth * 2)}${str}${semi ? ';' : ''}\n`;
   const lines = lines => {
     for (const x of lines) {
       out += `${' '.repeat(depth * 2)}${x}\n`;
@@ -111,6 +209,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     return tmp;
   };
 
+  let brId = 0;
+
   for (const f of funcs) {
     depth = 1;
 
@@ -124,7 +224,12 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     const returns = f.returns.length > 0;
 
     const shouldInline = f.internal;
-    out += `${f.name === 'main' ? 'int' : (f.internal ? (returns ? 'double' : 'void') : 'struct ReturnValue')} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+    out += `${f.name === 'main' ? 'int' : (f.internal ? (returns ? CValtype.f64 : 'void') : 'struct ReturnValue')} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+
+    if (f.name === 'main') {
+      out += [...prependMain.values()].join('\n');
+      if (prependMain.size > 0) out += '\n\n';
+    }
 
     const localKeys = Object.keys(f.locals).sort((a, b) => f.locals[a].idx - f.locals[b].idx).slice(f.params.length).sort((a, b) => f.locals[a].idx - f.locals[b].idx);
     for (const x of localKeys) {
@@ -134,11 +239,58 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
     if (localKeys.length !== 0) out += '\n';
 
+    const rets = [];
+    const runOnEnd = [];
+
     let vals = [];
-    const endNeedsCurly = [], ignoreEnd = [];
-    let beginLoop = false, lastCond = false, ifTernary = false;
+    const endNeedsCurly = [];
+    const brs = [];
+    let lastCond = false;
+
+    // let brDepth = 0;
+
+    const blockStart = (i, loop) => {
+      // reset "stack"
+      // vals = [];
+
+      rets.push(i[1]);
+
+      const br = brId++;
+      brs.push(br);
+      if (loop) {
+        line(`j${br}:;`, false);
+        runOnEnd.push(null);
+      } else {
+        runOnEnd.push(() => line(`j${br}:;`, false));
+      }
+
+      if (i[1] !== Blocktype.void) line(`${CValtype[i[1]]} _r${br}`);
+
+      brDepth++;
+    };
+
+    const highlight = i => {
+      const surrounding = 6;
+
+      const decomp = decompile(f.wasm.slice(i - surrounding, i + surrounding + 1), '', 0, f.locals, f.params, f.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');
+    };
+
     for (let _ = 0; _ < f.wasm.length; _++) {
       const i = f.wasm[_];
+      if (!i || !i[0]) continue;
 
       if (invOperatorOpcode[i[0]]) {
         const b = vals.pop();
@@ -160,12 +312,12 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
         switch (i[1]) {
           // i32_trunc_sat_f64_s
           case 0x02:
-            vals.push(`(${CValtype.i32})${vals.pop()}`);
+            vals.push(`(${CValtype.i32})(${vals.pop()})`);
             break;
 
           // i32_trunc_sat_f64_u
           case 0x03:
-            vals.push(`(${CValtype.i32})(${CValtype.i32_u})${vals.pop()}`);
+            vals.push(`(${CValtype.u32})(${vals.pop()})`);
             break;
         }
 
@@ -176,12 +328,19 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
       switch (i[0]) {
         case Opcodes.i32_const:
         case Opcodes.i64_const:
-          vals.push(read_signedLEB128(i.slice(1)).toString());
+          // vals.push(read_signedLEB128(i.slice(1)).toString());
+          vals.push(new String(read_signedLEB128(i.slice(1)).toString()));
+          vals.at(-1).offset = _;
           break;
 
-        case Opcodes.f64_const:
-          vals.push(read_ieee754_binary64(i.slice(1)).toExponential());
+        case Opcodes.f64_const: {
+          // const val = read_ieee754_binary64(i.slice(1)).toExponential();
+          const val = new String(read_ieee754_binary64(i.slice(1)).toExponential());
+          // vals.push(val == 'NaN' ? 'NAN' : val);
+          vals.push(val == 'NaN' ? new String('NAN') : val);
+          vals.at(-1).offset = _;
           break;
+        }
 
         case Opcodes.local_get:
           vals.push(`${invLocals[i[1]]}`);
@@ -192,9 +351,9 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
           break;
 
         case Opcodes.local_tee:
-          // line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
-          // vals.push(`${invLocals[i[1]]}`);
-          vals.push(`((${invLocals[i[1]]} = ${vals.pop()}))`);
+          line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
+          vals.push(`${invLocals[i[1]]}`);
+          // vals.push(`((${invLocals[i[1]]} = ${vals.pop()}))`);
           break;
 
         case Opcodes.global_get:
@@ -207,78 +366,102 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
         case Opcodes.f64_trunc:
           // vals.push(`trunc(${vals.pop()})`);
-          vals.push(`(int)(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
+          vals.push(`(${CValtype.i32})(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
           break;
 
         case Opcodes.f64_convert_i32_u:
         case Opcodes.f64_convert_i32_s:
         case Opcodes.f64_convert_i64_u:
         case Opcodes.f64_convert_i64_s:
-          // int to double
-          vals.push(`(double)${vals.pop()}`);
+          // int to f64
+          vals.push(`(${CValtype.f64})(${removeBrackets(vals.pop())})`);
           break;
 
+        case Opcodes.i32_eqz:
+          if (lastCond) {
+            vals.push(`!(${removeBrackets(vals.pop())})`);
+          } else {
+            let cond = '(' + removeBrackets(vals.pop());
+            if (cond.startsWith(`(${CValtype.i32})`)) cond = `${cond.slice(`(${CValtype.i32})`.length)}) == 0e+0`;
+              else cond += ') == 0';
+            vals.push(cond);
+          }
+          lastCond = true;
+          continue;
+
         case Opcodes.return:
           // line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
           line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(vals.pop())}, ${removeBrackets(vals.pop())} }` : ''}`);
           break;
 
-        case Opcodes.if:
+        case Opcodes.if: {
           let cond = removeBrackets(vals.pop());
           if (!lastCond) {
-            if (cond.startsWith('(long)')) cond = `${cond.slice(6)} == 1e+0`;
-              else cond += ' == 1';
-          }
-
-          ifTernary = i[1] !== Blocktype.void;
-          if (ifTernary) {
-            ifTernary = cond;
-            break;
+            if (cond.startsWith(`(${CValtype.i32})`)) cond = `(${cond.slice(`(${CValtype.i32})`.length)}) != 0e+0`;
+              else cond = `(${cond}) != 0`;
           }
 
-          if (beginLoop) {
-            beginLoop = false;
-            line(`while (${cond}) {`, false);
-
-            depth++;
-            endNeedsCurly.push(true);
-            ignoreEnd.push(false, true);
-            break;
-          }
+          line(`// if ${invValtype[i[1]] ?? ''}`, false);
+          blockStart(i, false);
 
           line(`if (${cond}) {`, false);
 
           depth++;
           endNeedsCurly.push(true);
-          ignoreEnd.push(false);
           break;
+        }
 
-        case Opcodes.else:
-          if (ifTernary) break;
+        case Opcodes.else: {
+          const br = brs.at(-1);
+          const ret = rets.at(-1);
+          if (ret && ret !== Blocktype.void) {
+            // console.log(vals, ret);
+            // console.log(decompile(f.wasm.slice(_ - 5, _ + 1)));
+            if (vals.length > 0) line(`_r${br} = ${removeBrackets(vals.pop())}`);
+            // vals.push(`_r${br}`);
+          }
 
           depth--;
           line(`} else {`, false);
           depth++;
+
+          // reset "stack"
+          // vals = [];
           break;
+        }
 
-        case Opcodes.loop:
-          // not doing properly, fake a while loop
-          beginLoop = true;
+        case Opcodes.loop: {
+          line(`// loop ${invValtype[i[1]] ?? ''}`, false);
+          blockStart(i, true);
+          endNeedsCurly.push(false);
           break;
+        }
 
-        case Opcodes.end:
-          if (ignoreEnd.pop()) break;
+        case Opcodes.end: {
+          const br = brs.pop();
+          const ret = rets.pop();
+          if (ret && ret !== Blocktype.void) {
+            // console.log(vals, ret);
+            // console.log(decompile(f.wasm.slice(_ - 5, _ + 1)));
+            if (vals.length > 0) line(`_r${br} = ${removeBrackets(vals.pop())}`);
+            vals.push(`_r${br}`);
+          }
 
-          if (ifTernary) {
-            const b = vals.pop();
-            const a = vals.pop();
-            vals.push(`${ifTernary} ? ${a} : ${b}`);
-            break;
+          const enc = endNeedsCurly.pop() === true;
+          if (enc) {
+            depth--;
+            line('}', false);
           }
 
-          depth--;
-          if (endNeedsCurly.pop() === true) line('}', false);
+          brDepth--;
+
+          line(`// end`, false);
+
+          const roe = runOnEnd.pop();
+          if (roe) roe();
+
           break;
+        }
 
         case Opcodes.call:
           let func = funcs.find(x => x.index === i[1]);
@@ -286,7 +469,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
             const importFunc = importFuncs[i[1]];
             switch (importFunc.name) {
               case 'print':
-                line(`printf("%f\\n", ${vals.pop()})`);
+                // line(`printf("%f\\n", ${vals.pop()})`);
+                line(`printf("${valtype === 'f64' ? '%g' : '%i'}\\n", ${vals.pop()})`);
                 includes.set('stdio.h', true);
                 break;
               case 'printChar':
@@ -349,13 +533,74 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
           vals.pop();
           break;
 
-        case Opcodes.br:
-          // ignore
-          // reset "stack"
-          vals = [];
+        case Opcodes.block:
+          line(`// block ${invValtype[i[1]] ?? ''}`, false);
+          blockStart(i, false);
+          endNeedsCurly.push(false);
+          break;
+
+        case Opcodes.br: {
+          const ret = rets[brDepth - i[1] - 1];
+          // console.log(rets, brDepth, i[1], brDepth - i[1] - 1, ret, vals);
+          if (ret !== Blocktype.void) line(`_r${brs[brDepth - i[1] - 1]} = ${removeBrackets(vals.pop())}`);
+          line(`goto j${brs[brDepth - i[1] - 1]}`);
+
+          // // reset "stack"
+          // vals = [];
+          break;
+        }
+
+        case Opcodes.br_if: {
+          const ret = rets[brDepth - i[1] - 1];
+          // console.log(rets, brDepth, i[1], brDepth - i[1] - 1, ret, vals);
+
+          let cond = removeBrackets(vals.pop());
+          if (!lastCond) {
+            if (cond.startsWith(`(${CValtype.i32})`)) cond = `(${cond.slice(`(${CValtype.i32})`.length)}) != 0e+0`;
+              else cond = `(${cond}) != 0`;
+          }
+
+          line(`if (${cond}) {`, false);
+          depth++;
+          if (ret !== Blocktype.void) line(`_r${brs[brDepth - i[1] - 1]} = ${removeBrackets(vals.at(-1))}`);
+          line(`goto j${brs[brDepth - i[1] - 1]}`);
+          depth--;
+          line(`}`, false);
+
           break;
+        }
+
+        case Opcodes.throw: {
+          const id = vals.pop();
+
+          line(`printf("Uncaught ${exceptions[id].constructor}: ${exceptions[id].message}\\n")`);
+          line(`exit(1)`);
+
+          includes.set('stdlib.h', true);
+
+          break;
+        }
 
         default:
+          if (CMemFuncs[i[0]]) {
+            const name = invOpcodes[i[0]];
+            const func = CMemFuncs[i[0]];
+            if (!prepend.has(name)) {
+              prepend.set(name, `${func.returns || 'void'} ${name}(${CValtype.i32} align, ${CValtype.i32} offset, ${func.args.map((x, i) => `${func.argTypes[i]} ${x}`).join(', ')}) {\n  ${func.c.replaceAll('\n', '\n  ')}\n}\n`);
+              // generate func c and prepend
+            }
+
+            const immediates = [ i[1], read_unsignedLEB128(i.slice(2)) ];
+
+            let args = [];
+            for (let j = 0; j < func.args.length; j++) args.unshift(removeBrackets(vals.pop()));
+
+            if (func.returns !== false) {
+              vals.push(`${name}(${immediates[0]}, ${immediates[1]}, ${args.join(', ')})`);
+            } else line(`${name}(${immediates[0]}, ${immediates[1]}, ${args.join(', ')})`);
+            break;
+          }
+
           log.warning('2c', `unimplemented op: ${invOpcodes[i[0]]}`);
           // todo(`unimplemented op: ${invOpcodes[i[0]]}`);
       }
@@ -379,7 +624,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
 
   const makeIncludes = includes => [...includes.keys()].map(x => `#include <${x}>\n`).join('');
 
-  out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + out;
+  out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + alwaysPreface + [...prepend.values()].join('\n') + '\n\n' + out;
 
-  return out;
+  return out.trim();
 };