porffor 0.0.0-bddcdc3 → 0.0.0-d650361

package/compiler/decompile.js

@@ -42,8 +42,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;
@@ -57,7 +57,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       out += ` ;; label @${depth}`;
     }
 
-    if (inst[0] === Opcodes.br) {
+    if (inst[0] === Opcodes.br || inst[0] === Opcodes.br_if) {
       out += ` ;; goto @${depth - inst[1]}`;
     }
 

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 ];
 

package/compiler/index.js

@@ -4,6 +4,8 @@ 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;
 
@@ -14,7 +16,9 @@ const bold = x => `\u001b[1m${x}\u001b[0m`;
 const areaColors = {
   codegen: [ 20, 80, 250 ],
   opt: [ 250, 20, 80 ],
-  sections: [ 20, 250, 80 ]
+  sections: [ 20, 250, 80 ],
+  alloc: [ 250, 250, 20 ],
+  '2c': [ 20, 250, 250 ]
 };
 
 globalThis.log = (area, ...args) => console.log(`\u001b[90m[\u001b[0m${rgb(...areaColors[area], area)}\u001b[90m]\u001b[0m`, ...args);
@@ -35,9 +39,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;
@@ -63,5 +74,45 @@ export default (code, flags) => {
   const sections = produceSections(funcs, globals, tags, pages, 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'));
+  }
+
+  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/opt.js

@@ -1,5 +1,6 @@
 import { Opcodes, Valtype } from "./wasmSpec.js";
 import { number } from "./embedding.js";
+import { read_signedLEB128, read_ieee754_binary64 } from "./encoding.js";
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -20,7 +21,7 @@ export default (funcs, globals) => {
   if (optLevel === 0) return;
 
   const tailCall = process.argv.includes('-tail-call');
-  if (tailCall) log('opt', 'tail call proposal is not widely implemented! (you used -tail-call)');
+  if (tailCall) log('opt', 'warning: tail call proposal is not widely implemented! (you used -tail-call)');
 
   if (optLevel >= 2 && !process.argv.includes('-opt-no-inline')) {
     // inline pass (very WIP)
@@ -95,7 +96,6 @@ export default (funcs, globals) => {
         }
 
         if (t.index > c.index) t.index--; // adjust index if after removed func
-        if (c.memory) t.memory = true;
       }
 
       funcs.splice(funcs.indexOf(c), 1); // remove func from funcs
@@ -142,7 +142,7 @@ export default (funcs, globals) => {
             depth--;
             if (depth <= 0) break;
           }
-          if (op === Opcodes.br) {
+          if (op === Opcodes.br || op === Opcodes.br_if) {
             hasBranch = true;
             break;
           }
@@ -213,9 +213,9 @@ export default (funcs, globals) => {
         // i32.const 0
         // drop
         // -->
-        // <nothing>>
+        // <nothing>
 
-        wasm.splice(i - 1, 2); // remove this inst
+        wasm.splice(i - 1, 2); // remove these inst
         i -= 2;
         continue;
       }
@@ -259,6 +259,36 @@ export default (funcs, globals) => {
         continue;
       }
 
+      if (lastInst[0] === Opcodes.const && (inst === Opcodes.i32_to || inst === Opcodes.i32_to_u)) {
+        // change const and immediate i32 convert to i32 const
+        // f64.const 0
+        // i32.trunc_sat_f64_s || i32.trunc_sat_f64_u
+        // -->
+        // i32.const 0
+
+        wasm[i - 1] = number((valtype === 'f64' ? read_ieee754_binary64 : read_signedLEB128)(lastInst.slice(1)), Valtype.i32)[0]; // f64.const -> i32.const
+
+        wasm.splice(i, 1); // remove this inst
+        i--;
+        if (optLog) log('opt', `converted const -> i32 convert into i32 const`);
+        continue;
+      }
+
+      if (lastInst[0] === Opcodes.i32_const && (inst === Opcodes.i32_from || inst === Opcodes.i32_from_u)) {
+        // change i32 const and immediate convert to const (opposite way of previous)
+        // i32.const 0
+        // f64.convert_i32_s || f64.convert_i32_u
+        // -->
+        // f64.const 0
+
+        wasm[i - 1] = number(read_signedLEB128(lastInst.slice(1)))[0]; // i32.const -> f64.const
+
+        wasm.splice(i, 1); // remove this inst
+        i--;
+        if (optLog) log('opt', `converted i32 const -> convert into const`);
+        continue;
+      }
+
       if (tailCall && lastInst[0] === Opcodes.call && inst[0] === Opcodes.return) {
         // replace call, return with tail calls (return_call)
         // call X

package/compiler/parse.js

@@ -1,3 +1,4 @@
+// import { parse } from 'acorn';
 const { parse } = (await import(globalThis.document ? 'https://esm.sh/acorn' : 'acorn'));
 
 export default (input, flags) => {

package/compiler/prototype.js

@@ -15,17 +15,18 @@ const TYPES = {
   bigint: 0xffffffffffff7,
 
   // these are not "typeof" types but tracked internally
-  _array: 0xffffffffffff8
+  _array: 0xfffffffffff0f,
+  _regexp: 0xfffffffffff1f
 };
 
 // todo: turn these into built-ins once arrays and these become less hacky
 
 export const PrototypeFuncs = function() {
   const noUnlikelyChecks = process.argv.includes('-funsafe-no-unlikely-proto-checks');
+  const noCCAChecks = process.argv.includes('-funsafe-no-charcodeat-checks');
 
   this[TYPES._array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
-    // todo: out of bounds (>) properly
     at: (pointer, length, wIndex, iTmp) => [
       ...wIndex,
       Opcodes.i32_to,
@@ -36,7 +37,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_lt_s ],
       [ Opcodes.if, Blocktype.void ],
       [ Opcodes.local_get, iTmp ],
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_add ],
       [ Opcodes.local_set, iTmp ],
       [ Opcodes.end ],
@@ -47,7 +48,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_lt_s ],
 
       [ Opcodes.local_get, iTmp ],
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_ge_s ],
       [ Opcodes.i32_or ],
 
@@ -67,7 +68,7 @@ export const PrototypeFuncs = function() {
     // todo: only for 1 argument
     push: (pointer, length, wNewMember) => [
       // get memory offset of array at last index (length)
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
@@ -79,17 +80,17 @@ export const PrototypeFuncs = function() {
 
       // bump array length by 1 and return it
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_add ]
       ]),
 
-      ...length.get
+      ...length.get()
     ],
 
     pop: (pointer, length) => [
       // if length == 0, noop
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
@@ -100,13 +101,13 @@ export const PrototypeFuncs = function() {
 
       // decrement length by 1
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ]
       ]),
 
       // load last element
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
@@ -115,7 +116,7 @@ export const PrototypeFuncs = function() {
 
     shift: (pointer, length) => [
       // if length == 0, noop
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       Opcodes.i32_eqz,
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
@@ -126,7 +127,7 @@ export const PrototypeFuncs = function() {
 
       // decrement length by 1
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ]
       ]),
@@ -140,14 +141,68 @@ export const PrototypeFuncs = function() {
       ...number(pointer + ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32), // src = base array index + length size + an index
       ...number(pageSize - ValtypeSize.i32 - ValtypeSize[valtype], Valtype.i32), // size = PageSize - length size - an index
       [ ...Opcodes.memory_copy, 0x00, 0x00 ]
+    ],
+
+    fill: (pointer, length, wElement, iTmp) => [
+      ...wElement,
+      [ Opcodes.local_set, iTmp ],
+
+      // use cached length i32 as pointer
+      ...length.getCachedI32(),
+
+      // length - 1 for indexes
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_sub ],
+
+      // * sizeof value
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_mul ],
+
+      ...length.setCachedI32(),
+
+      ...(noUnlikelyChecks ? [] : [
+        ...length.getCachedI32(),
+        ...number(0, Valtype.i32),
+        [ Opcodes.i32_lt_s ],
+        [ Opcodes.if, Blocktype.void ],
+        ...number(pointer),
+        [ Opcodes.br, 1 ],
+        [ Opcodes.end ]
+      ]),
+
+      [ Opcodes.loop, Blocktype.void ],
+
+      // set element using pointer
+      ...length.getCachedI32(),
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+
+      // pointer - sizeof value
+      ...length.getCachedI32(),
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_sub ],
+
+      ...length.setCachedI32(),
+
+      // if pointer >= 0, loop
+      ...length.getCachedI32(),
+      ...number(0, Valtype.i32),
+      [ Opcodes.i32_ge_s ],
+      [ Opcodes.br_if, 0 ],
+
+      [ Opcodes.end ],
+
+      // return this array
+      ...number(pointer)
     ]
   };
 
   this[TYPES._array].at.local = Valtype.i32;
   this[TYPES._array].push.noArgRetLength = true;
+  this[TYPES._array].fill.local = valtypeBinary;
+  this[TYPES._array].fill.returnType = TYPES._array;
 
   this[TYPES.string] = {
-    // todo: out of bounds properly
     at: (pointer, length, wIndex, iTmp, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
@@ -157,9 +212,9 @@ export const PrototypeFuncs = function() {
         [ Opcodes.drop ],
 
         ...number(0, Valtype.i32), // base 0 for store later
-        Opcodes.i32_to_u,
 
         ...wIndex,
+        Opcodes.i32_to_u,
         [ Opcodes.local_tee, iTmp ],
 
         // if index < 0: access index + array length
@@ -167,7 +222,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_lt_s ],
         [ Opcodes.if, Blocktype.void ],
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         [ Opcodes.i32_add ],
         [ Opcodes.local_set, iTmp ],
         [ Opcodes.end ],
@@ -178,7 +233,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_lt_s ],
 
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         [ Opcodes.i32_ge_s ],
         [ Opcodes.i32_or ],
 
@@ -234,27 +289,31 @@ export const PrototypeFuncs = function() {
       return [
         ...wIndex,
         Opcodes.i32_to,
-        [ Opcodes.local_set, iTmp ],
 
-        // index < 0
-        ...(noUnlikelyChecks ? [] : [
+        ...(noCCAChecks ? [] : [
+          [ 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 ],
-          ...number(0, Valtype.i32),
-          [ Opcodes.i32_lt_s ],
-        ]),
+          ...length.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
 
-        // index >= length
-        [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
-        [ Opcodes.i32_ge_s ],
+          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+          [ Opcodes.if, Blocktype.void ],
+          ...number(NaN),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
 
-        ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
-        [ Opcodes.if, Blocktype.void ],
-        ...number(NaN),
-        [ Opcodes.br, 1 ],
-        [ Opcodes.end ],
+          [ Opcodes.local_get, iTmp ],
+        ]),
 
-        [ Opcodes.local_get, iTmp ],
         ...number(ValtypeSize.i16, Valtype.i32),
         [ Opcodes.i32_mul ],
 
@@ -265,7 +324,7 @@ export const PrototypeFuncs = function() {
     },
   };
 
-  this[TYPES.string].at.local = valtypeBinary;
+  this[TYPES.string].at.local = Valtype.i32;
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
   this[TYPES.string].charCodeAt.local = Valtype.i32;

package/compiler/sections.js

@@ -8,11 +8,26 @@ const createSection = (type, data) => [
   ...encodeVector(data)
 ];
 
+const customSection = (name, data) => [
+  Section.custom,
+  ...encodeVector([...encodeString(name), ...data])
+];
+
+const chHint = (topTier, baselineTier, strategy) => {
+  // 1 byte of 4 2 bit components: spare, top tier, baseline tier, compilation strategy
+  // tiers: 0x00 = default, 0x01 = baseline (liftoff), 0x02 = optimized (turbofan)
+  // strategy: 0x00 = default, 0x01 = lazy, 0x02 = eager, 0x03 = lazy baseline, eager top tier
+  return (strategy | (baselineTier << 2) | (topTier << 4));
+};
+
 export default (funcs, globals, tags, pages, flags) => {
   const types = [], typeCache = {};
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
 
+  const compileHints = process.argv.includes('-compile-hints');
+  if (compileHints) log('sections', 'warning: compile hints is V8 only w/ experimental arg! (you used -compile-hints)');
+
   const getType = (params, returns) => {
     const hash = `${params.join(',')}_${returns.join(',')}`;
     if (optLog) log('sections', `getType(${JSON.stringify(params)}, ${JSON.stringify(returns)}) -> ${hash} | cache: ${typeCache[hash]}`);
@@ -36,7 +51,7 @@ export default (funcs, globals, tags, pages, flags) => {
     // tree shake imports
     for (const f of funcs) {
       for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] < importedFuncs.length) {
+        if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] < importedFuncs.length) {
           const idx = inst[1];
           const func = importedFuncs[idx];
 
@@ -51,15 +66,17 @@ export default (funcs, globals, tags, pages, flags) => {
     // fix call indexes for non-imports
     const delta = importedFuncs.length - importFuncs.length;
     for (const f of funcs) {
+      f.originalIndex = f.index;
       f.index -= delta;
 
       for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] >= importedFuncs.length) {
+        if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] >= importedFuncs.length) {
           inst[1] -= delta;
         }
       }
     }
   }
+  globalThis.importFuncs = importFuncs;
 
   if (optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
 
@@ -73,6 +90,14 @@ export default (funcs, globals, tags, pages, flags) => {
     encodeVector(funcs.map(x => getType(x.params, x.returns))) // type indexes
   );
 
+  // compilation hints section - unspec v8 only
+  // https://github.com/WebAssembly/design/issues/1473#issuecomment-1431274746
+  const chSection = !compileHints ? [] : customSection(
+    'compilationHints',
+    // for now just do everything as optimise eager
+    encodeVector(funcs.map(_ => chHint(0x02, 0x02, 0x02)))
+  );
+
   const globalSection = Object.keys(globals).length === 0 ? [] : createSection(
     Section.global,
     encodeVector(Object.keys(globals).map(x => [ globals[x].type, 0x01, ...number(globals[x].init ?? 0, globals[x].type).flat(), Opcodes.end ]))
@@ -145,6 +170,7 @@ export default (funcs, globals, tags, pages, flags) => {
     ...typeSection,
     ...importSection,
     ...funcSection,
+    ...chSection,
     ...memorySection,
     ...tagSection,
     ...globalSection,

package/compiler/wrap.js

@@ -1,10 +1,11 @@
 import compile from './index.js';
 import decompile from './decompile.js';
-import fs from 'node:fs';
+// import fs from 'node:fs';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
 const typeBase = 0xffffffffffff0;
+const internalTypeBase = 0xfffffffffff0f;
 const TYPES = {
   [typeBase]: 'number',
   [typeBase + 1]: 'boolean',
@@ -16,7 +17,8 @@ const TYPES = {
   [typeBase + 7]: 'bigint',
 
   // internal
-  [typeBase + 8]: '_array'
+  [internalTypeBase]: '_array',
+  [internalTypeBase + 1]: '_regexp'
 };
 
 export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
@@ -27,16 +29,23 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   if (source.includes('export function')) flags.push('module');
 
-  fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
+  const getString = pointer => {
+    const length = new Int32Array(memory.buffer, pointer, 1);
+
+    return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
+  };
+
   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)),
+      s: valtype === 'i64' ? i => print(getString(Number(i))) : i => print(getString(i)),
       a: c => { if (!Number(c)) throw new Error(`assert failed`); },
       t: _ => performance.now(),
       ...customImports
@@ -90,6 +99,15 @@ 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 'function': {
+            // wasm func index, including all imports
+            const func = funcs.find(x => (x.originalIndex ?? x.index) === ret);
+            if (!func) return ret;
+
+            // make fake empty func for repl/etc
+            return {[func.name]() {}}[func.name];
+          }
+
           default: return ret;
         }
       } catch (e) {

package/hi.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+
+double inline f64_f(double x, double y) {
+  return x - (int)(x / y) * y;
+}
+
+double isPrime(double number) {
+  double i;
+
+  if (number < 2e+0) {
+    return 0e+0;
+  }
+  i = 2e+0;
+  while (i < number) {
+    if (f64_f(number, i) == 0e+0) {
+      return 0e+0;
+    }
+    i = i + 1e+0;
+  }
+  return 1e+0;
+}
+
+int main() {
+  double sum;
+  double counter;
+
+  sum = 0e+0;
+  counter = 0e+0;
+  while (counter <= 1e+5) {
+    if (isPrime(counter) == 1e+0) {
+      sum = sum + counter;
+    }
+    counter = counter + 1e+0;
+  }
+  printf("%f\n", sum);
+}
+

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.0.0-bddcdc3",
+  "version": "0.0.0-d650361",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {