porffor 0.34.6 → 0.34.8

package/compiler/codegen.js

@@ -48,12 +48,18 @@ const cacheAst = (decl, wasm) => {
   return wasm;
 };
 
-const funcRef = (idx, name) => {
+const funcRef = func => {
+  // generate func
+  func.generate?.();
+
   if (globalThis.precompile) return [
-    [ Opcodes.const, 'funcref', name ]
+    [ Opcodes.const, 'funcref', func.name ]
   ];
 
-  return number(idx - importedFuncs.length);
+  return [
+    [ Opcodes.const, func.index - importedFuncs.length ]
+    // [ Opcodes.const, func.index - importedFuncs.length, 'funcref' ]
+  ];
 };
 
 const generate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
@@ -189,6 +195,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
         for (const x of newFuncs) {
           x.export = true;
+
+          // generate func
+          x.generate?.();
         }
       }
 
@@ -344,9 +353,7 @@ const generateIdent = (scope, decl) => {
       if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name].idx ] ];
 
       if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name] - importedFuncs.length);
-      if (Object.hasOwn(funcIndex, name)) {
-        return funcRef(funcIndex[name], name);
-      }
+      if (Object.hasOwn(funcIndex, name)) return funcRef(funcByName(name));
     }
 
     if (local?.idx === undefined && rawName.startsWith('__')) {
@@ -1117,6 +1124,14 @@ const asmFuncToAsm = (scope, func) => {
 
       return idx;
     },
+    funcRef: name => {
+      if (funcIndex[name] == null && builtinFuncs[name]) {
+        includeBuiltin(scope, name);
+      }
+
+      const func = funcByName(name);
+      return funcRef(func);
+    },
     glbl: (opcode, name, type) => {
       const globalName = '#porf#' + name; // avoid potential name clashing with user js
       if (!globals[globalName]) {
@@ -1164,7 +1179,7 @@ const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTy
     wasm = [];
   }
 
-  const existing = funcs.find(x => x.name === name);
+  const existing = funcByName(name);
   if (existing) return existing;
 
   const nameParam = i => localNames[i] ?? (i >= params.length ? ['a', 'b', 'c'][i - params.length] : ['x', 'y', 'z'][i]);
@@ -1223,7 +1238,7 @@ const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTy
     for (const inst of wasm) {
       if (inst.at(-1) === 'read func lut') {
         inst.splice(2, 99);
-        inst.push(...unsignedLEB128(allocPage({}, 'func lut') * pageSize));
+        inst.push(...unsignedLEB128(allocPage({}, 'func lut')));
       }
     }
 
@@ -1391,7 +1406,7 @@ const getNodeType = (scope, node) => {
         return TYPES.number;
       }
 
-      const func = funcs.find(x => x.name === name);
+      const func = funcByName(name);
       if (func) {
         if (func.returnType != null) return func.returnType;
       }
@@ -1616,11 +1631,11 @@ const countLeftover = wasm => {
         else if (inst[0] === Opcodes.memory_copy[0] && (inst[1] === Opcodes.memory_copy[1] || inst[1] === Opcodes.memory_init[1])) count -= 3;
         else if (inst[0] === Opcodes.return) count = 0;
         else if (inst[0] === Opcodes.call) {
-          let func = funcs.find(x => x.index === inst[1]);
           if (inst[1] < importedFuncs.length) {
-            func = importedFuncs[inst[1]];
+            const func = importedFuncs[inst[1]];
             count = count - func.params + func.returns;
           } else {
+            const func = funcByIndex(inst[1]);
             count = count - func.params.length + func.returns.length;
           }
         } else if (inst[0] === Opcodes.call_indirect) {
@@ -1855,7 +1870,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
   // opt: virtualize iifes
   if (isFuncType(decl.callee.type)) {
-    const [ func ] = generateFunc(scope, decl.callee);
+    const [ func ] = generateFunc(scope, decl.callee, true);
     name = func.name;
   }
 
@@ -2439,19 +2454,19 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
             [ Opcodes.i32_mul ],
             ...number(4, Valtype.i32),
             [ Opcodes.i32_add ],
-            [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ],
+            [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut')), 'read func lut' ],
             [ Opcodes.local_set, flags ],
 
             // check if non-constructor was called with new, if so throw
-            [ Opcodes.local_get, flags ],
-            ...number(0b10, Valtype.i32),
-            [ Opcodes.i32_and ],
-            [ Opcodes.i32_eqz ],
-            [ Opcodes.i32_const, decl._new ? 1 : 0 ],
-            [ Opcodes.i32_and ],
-            [ Opcodes.if, Blocktype.void ],
-              ...internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`),
-            [ Opcodes.end ],
+            ...(decl._new ? [
+              [ Opcodes.local_get, flags ],
+              ...number(0b10, Valtype.i32),
+              [ Opcodes.i32_and ],
+              [ Opcodes.i32_eqz ],
+              [ Opcodes.if, Blocktype.void ],
+                ...internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`),
+              [ Opcodes.end ],
+            ] : []),
 
             // [ Opcodes.local_get, funcLocal ],
             // Opcodes.i32_from_u,
@@ -2463,10 +2478,18 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
             // [ Opcodes.local_get, funcLocal ],
             // ...number(64, Valtype.i32),
             // [ Opcodes.i32_mul ],
-            // [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ],
+            // [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut')), 'read func lut' ],
             // Opcodes.i32_from_u,
             // [ Opcodes.call, 0 ],
 
+            // [ Opcodes.local_get, funcLocal ],
+            // [ Opcodes.call, includeBuiltin(scope, '__Porffor_funcLut_name').index ],
+            // Opcodes.i32_from_u,
+            // ...number(TYPES.bytestring, Valtype.i32),
+            // [ Opcodes.call, includeBuiltin(scope, '__Porffor_printString').index ],
+            // [ Opcodes.drop ],
+            // [ Opcodes.drop ],
+
             // ...number(10),
             // [ Opcodes.call, 1 ],
 
@@ -2475,7 +2498,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
               [ Opcodes.local_get, funcLocal ],
               ...number(64, Valtype.i32),
               [ Opcodes.i32_mul ],
-              [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ]
+              [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut')), 'read func lut' ]
             ], tableBc, valtypeBinary)
           ],
 
@@ -2491,7 +2514,11 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       ];
     }
 
-  const func = funcs[idx - importedFuncs.length]; // idx === scope.index ? scope : funcs.find(x => x.index === idx);
+  const func = funcByIndex(idx);
+
+  // generate func
+  if (func) func.generate?.();
+
   const userFunc = func && !func.internal;
   const typedParams = userFunc || func?.typedParams;
   const typedReturns = (userFunc && func.returnType == null) || builtinFuncs[name]?.typedReturns;
@@ -2987,7 +3014,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
       // hack for let a = function () { ... }
       if (!init.id) {
         init.id = { name };
-        generateFunc(scope, init);
+        generateFunc(scope, init, true);
         return out;
       }
     }
@@ -4774,7 +4801,8 @@ const generateMeta = (scope, decl) => {
 
 let pages = new Map();
 const allocPage = (scope, reason, type) => {
-  if (pages.has(reason)) return pages.get(reason).ind;
+  const ptr = i => i === 0 ? 16 : (i * pageSize);
+  if (pages.has(reason)) return ptr(pages.get(reason).ind);
 
   if (reason.startsWith('array:')) pages.hasArray = true;
   if (reason.startsWith('string:')) pages.hasString = true;
@@ -4787,7 +4815,7 @@ const allocPage = (scope, reason, type) => {
   scope.pages ??= new Map();
   scope.pages.set(reason, { ind, type });
 
-  return ind;
+  return ptr(ind);
 };
 
 const itemTypeToValtype = {
@@ -5257,7 +5285,7 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
     // todo: support optional
 
     if (!scope.noFastFuncMembers) {
-      const func = funcs.find(x => x.name === name);
+      const func = funcByName(name);
       if (func) return withType(scope, number(countLength(func, name)), TYPES.number);
 
       if (Object.hasOwn(builtinFuncs, name)) return withType(scope, number(countLength(builtinFuncs[name], name)), TYPES.number);
@@ -5676,6 +5704,9 @@ const generateClass = (scope, decl) => {
     type: expr ? 'FunctionExpression' : 'FunctionDeclaration'
   });
 
+  // always generate class constructor funcs
+  func.generate();
+
   if (decl.superClass) {
     out.push(
       ...generateCall(scope, {
@@ -5808,14 +5839,25 @@ const objectHack = node => {
   for (const x in node) {
     if (node[x] != null && typeof node[x] === 'object') {
       if (node[x].type) node[x] = objectHack(node[x]);
-      if (Array.isArray(node[x])) node[x] = node[x].map(y => objectHack(y));
+      if (Array.isArray(node[x])) node[x] = node[x].map(objectHack);
     }
   }
 
   return node;
 };
 
-const generateFunc = (scope, decl) => {
+const funcByIndex = idx => {
+  if (idx == null ||
+      idx < importedFuncs.length) return null;
+
+  const func = funcs[idx - importedFuncs.length];
+  if (func && func.index === idx) return func;
+
+  return funcs.find(x => x.index === idx);
+};
+const funcByName = name => funcByIndex(funcIndex[name]);
+
+const generateFunc = (scope, decl, outUnused = false) => {
   const name = decl.id ? decl.id.name : `#anonymous${uniqId()}`;
   if (decl.type.startsWith('Class')) {
     const out = generateClass(scope, {
@@ -5823,7 +5865,7 @@ const generateFunc = (scope, decl) => {
       id: { name }
     });
 
-    const func = funcs.find(x => x.name === name);
+    const func = funcByName(name);
     return [ func, out ];
   }
 
@@ -5843,25 +5885,145 @@ const generateFunc = (scope, decl) => {
       // not async or generator
       !decl.async && !decl.generator,
     _onlyConstr: decl._onlyConstr,
-    strict: scope.strict
+    strict: scope.strict,
+
+    generate() {
+      if (func.wasm) return func.wasm;
+
+      // generating, stub _wasm
+      func.wasm = [];
+
+      let body = objectHack(decl.body);
+      if (decl.type === 'ArrowFunctionExpression' && decl.expression) {
+        // hack: () => 0 -> () => return 0
+        body = {
+          type: 'ReturnStatement',
+          argument: decl.body
+        };
+      }
+
+      for (const x in defaultValues) {
+        prelude.push(
+          ...getType(func, x),
+          ...number(TYPES.undefined, Valtype.i32),
+          [ Opcodes.i32_eq ],
+          [ Opcodes.if, Blocktype.void ],
+            ...generate(func, defaultValues[x], false, x),
+            [ Opcodes.local_set, func.locals[x].idx ],
+
+            ...setType(func, x, getNodeType(func, defaultValues[x])),
+          [ Opcodes.end ]
+        );
+      }
+
+      for (const x in destructuredArgs) {
+        prelude.push(
+          ...generateVarDstr(func, 'var', destructuredArgs[x], { type: 'Identifier', name: x }, undefined, false)
+        );
+      }
+
+      if (decl.async) {
+        // make out promise local
+        allocVar(func, '#async_out_promise', false, false);
+        func.async = true;
+      }
+
+      const wasm = prelude.concat(generate(func, body));
+
+      if (decl.async) {
+        // make promise at the start
+        wasm.unshift(
+          [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_create').index ],
+          [ Opcodes.drop ],
+          [ Opcodes.local_set, func.locals['#async_out_promise'].idx ]
+        );
+
+        // todo: wrap in try and reject thrown value once supported
+      }
+
+      if (!globalThis.precompile && func.constr) {
+        wasm.unshift(
+          // opt: do not check for pure constructors
+          ...(func._onlyConstr ? [] : [
+            // if being constructed
+            [ Opcodes.local_get, func.locals['#newtarget'].idx ],
+            Opcodes.i32_to_u,
+            [ Opcodes.if, Blocktype.void ],
+          ]),
+            // set prototype of this ;)
+            ...generate(func, setObjProp({ type: 'ThisExpression' }, '__proto__', getObjProp(func.name, 'prototype'))),
+          ...(func._onlyConstr ? [] : [ [ Opcodes.end ] ])
+        );
+      }
+
+      if (name === 'main') {
+        func.gotLastType = true;
+        func.export = true;
+        func.returns = [ valtypeBinary, Valtype.i32 ];
+
+        let finalStatement = decl.body.body[decl.body.body.length - 1];
+        if (finalStatement?.type === 'EmptyStatement') finalStatement = decl.body.body[decl.body.body.length - 2];
+
+        const lastInst = wasm[wasm.length - 1] ?? [ Opcodes.end ];
+        if (lastInst[0] === Opcodes.drop) {
+          if (finalStatement.type.endsWith('Declaration')) {
+            // final statement is decl, force undefined
+            disposeLeftover(wasm);
+            wasm.push(
+              ...number(UNDEFINED),
+              ...number(TYPES.undefined, Valtype.i32)
+            );
+          } else {
+            wasm.splice(wasm.length - 1, 1);
+            wasm.push(...getNodeType(func, finalStatement));
+          }
+        }
+
+        if (lastInst[0] === Opcodes.end || lastInst[0] === Opcodes.local_set || lastInst[0] === Opcodes.global_set) {
+          if (lastInst[0] === Opcodes.local_set && lastInst[1] === func.locals['#last_type'].idx) {
+            wasm.splice(wasm.length - 1, 1);
+          } else {
+            func.returns = [];
+          }
+        }
+
+        if (lastInst[0] === Opcodes.call) {
+          const callee = funcByIndex(lastInst[1]);
+          if (callee) func.returns = callee.returns.slice();
+            else func.returns = [];
+        }
+
+        // inject promise job runner func at the end of main if job queue is used
+        if (Object.hasOwn(funcIndex, '__ecma262_HostEnqueuePromiseJob')) {
+          wasm.push(
+            [ Opcodes.call, includeBuiltin(scope, '__Porffor_promise_runJobs').index ],
+            [ Opcodes.drop ],
+            [ Opcodes.drop ]
+          );
+        }
+      } else {
+        // add end return if not found
+        if (wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
+          wasm.push(...generateReturn(func, {}));
+        }
+      }
+
+      return func.wasm = wasm;
+    }
   };
 
   funcIndex[name] = func.index;
   funcs.push(func);
 
-  const out = decl.type.endsWith('Expression') ? funcRef(func.index, func.name) : [];
-
   let errorWasm = null;
   if (decl.generator) errorWasm = todo(scope, 'generator functions are not supported');
 
   if (errorWasm) {
+    // func.params = [];
     func.wasm = errorWasm.concat([
       ...number(UNDEFINED),
       ...number(TYPES.undefined, Valtype.i32)
     ]);
-    func.params = [];
-    func.constr = false;
-    return [ func, out ];
   }
 
   if (typedInput && decl.returnType) {
@@ -5936,121 +6098,13 @@ const generateFunc = (scope, decl) => {
 
   func.params = Object.values(func.locals).map(x => x.type);
 
-  let body = objectHack(decl.body);
-  if (decl.type === 'ArrowFunctionExpression' && decl.expression) {
-    // hack: () => 0 -> () => return 0
-    body = {
-      type: 'ReturnStatement',
-      argument: decl.body
-    };
-  }
-
-  for (const x in defaultValues) {
-    prelude.push(
-      ...getType(func, x),
-      ...number(TYPES.undefined, Valtype.i32),
-      [ Opcodes.i32_eq ],
-      [ Opcodes.if, Blocktype.void ],
-        ...generate(func, defaultValues[x], false, x),
-        [ Opcodes.local_set, func.locals[x].idx ],
-
-        ...setType(func, x, getNodeType(func, defaultValues[x])),
-      [ Opcodes.end ]
-    );
-  }
-
-  for (const x in destructuredArgs) {
-    prelude.push(
-      ...generateVarDstr(func, 'var', destructuredArgs[x], { type: 'Identifier', name: x }, undefined, false)
-    );
-  }
-
-  if (decl.async) {
-    // make out promise local
-    allocVar(func, '#async_out_promise', false, false);
-    func.async = true;
-  }
-
-  const wasm = func.wasm = prelude.concat(generate(func, body));
-
-  if (decl.async) {
-    // make promise at the start
-    wasm.unshift(
-      [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_create').index ],
-      [ Opcodes.drop ],
-      [ Opcodes.local_set, func.locals['#async_out_promise'].idx ]
-    );
-
-    // todo: wrap in try and reject thrown value once supported
-  }
-
-  if (!globalThis.precompile && func.constr) {
-    wasm.unshift(
-      // opt: do not check for pure constructors
-      ...(func._onlyConstr ? [] : [
-        // if being constructed
-        [ Opcodes.local_get, func.locals['#newtarget'].idx ],
-        Opcodes.i32_to_u,
-        [ Opcodes.if, Blocktype.void ],
-      ]),
-        // set prototype of this ;)
-        ...generate(func, setObjProp({ type: 'ThisExpression' }, '__proto__', getObjProp(func.name, 'prototype'))),
-      ...(func._onlyConstr ? [] : [ [ Opcodes.end ] ])
-    );
-  }
-
-  if (name === 'main') {
-    func.gotLastType = true;
-    func.export = true;
-    func.returns = [ valtypeBinary, Valtype.i32 ];
-
-    let finalStatement = decl.body.body[decl.body.body.length - 1];
-    if (finalStatement?.type === 'EmptyStatement') finalStatement = decl.body.body[decl.body.body.length - 2];
-
-    const lastInst = func.wasm[func.wasm.length - 1] ?? [ Opcodes.end ];
-    if (lastInst[0] === Opcodes.drop) {
-      if (finalStatement.type.endsWith('Declaration')) {
-        // final statement is decl, force undefined
-        disposeLeftover(wasm);
-        func.wasm.push(
-          ...number(UNDEFINED),
-          ...number(TYPES.undefined, Valtype.i32)
-        );
-      } else {
-        func.wasm.splice(func.wasm.length - 1, 1);
-        func.wasm.push(...getNodeType(func, finalStatement));
-      }
-    }
-
-    if (lastInst[0] === Opcodes.end || lastInst[0] === Opcodes.local_set || lastInst[0] === Opcodes.global_set) {
-      if (lastInst[0] === Opcodes.local_set && lastInst[1] === func.locals['#last_type'].idx) {
-        func.wasm.splice(func.wasm.length - 1, 1);
-      } else {
-        func.returns = [];
-      }
-    }
-
-    if (lastInst[0] === Opcodes.call) {
-      const callee = funcs.find(x => x.index === lastInst[1]);
-      if (callee) func.returns = callee.returns.slice();
-        else func.returns = [];
-    }
+  // force generate for main
+  if (name === 'main') func.generate();
 
-    // inject promise job runner func at the end of main if job queue is used
-    if (Object.hasOwn(funcIndex, '__ecma262_HostEnqueuePromiseJob')) {
-      wasm.push(
-        [ Opcodes.call, includeBuiltin(scope, '__Porffor_promise_runJobs').index ],
-        [ Opcodes.drop ],
-        [ Opcodes.drop ]
-      );
-    }
-  } else {
-    // add end return if not found
-    if (wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
-      wasm.push(...generateReturn(func, {}));
-    }
-  }
+  // force generate all for precompile
+  if (globalThis.precompile) func.generate();
 
+  const out = decl.type.endsWith('Expression') && !outUnused ? funcRef(func) : [];
   return [ func, out ];
 };
 
@@ -6255,11 +6309,6 @@ export default program => {
 
   program.id = { name: 'main' };
 
-  const scope = {
-    locals: {},
-    localInd: 0
-  };
-
   program.body = {
     type: 'BlockStatement',
     body: program.body
@@ -6267,12 +6316,63 @@ export default program => {
 
   if (Prefs.astLog) console.log(JSON.stringify(program.body.body, null, 2));
 
-  const [ main ] = generateFunc(scope, program);
+  const [ main ] = generateFunc({}, program);
 
   delete globals['#ind'];
 
   // if blank main func and other exports, remove it
   if (main.wasm.length === 0 && funcs.reduce((acc, x) => acc + (x.export ? 1 : 0), 0) > 1) funcs.splice(main.index - importedFuncs.length, 1);
 
+  // make ~empty funcs for never generated funcs
+  // todo: these should just be deleted once able
+  for (let i = 0; i < funcs.length; i++) {
+    const f = funcs[i];
+    if (f.internal || f.wasm) {
+      continue;
+    }
+
+    // make wasm just return 0s for expected returns
+    f.wasm = f.returns.map(x => number(0, x)).flat();
+
+    // alternative: make func empty, may break some indirect calls
+    // f.wasm = [];
+    // f.returns = [];
+    // f.params = [];
+    // f.locals = {};
+  }
+
+  // // remove never generated functions
+  // let indexDelta = 0;
+  // const funcRemap = new Map();
+  // for (let i = 0; i < funcs.length; i++) {
+  //   const f = funcs[i];
+  //   if (f.internal || f.wasm) {
+  //     if (indexDelta) {
+  //       funcRemap.set(f.index, f.index - indexDelta);
+  //       f.index -= indexDelta;
+  //     }
+  //     continue;
+  //   }
+
+  //   funcs.splice(i--, 1);
+  //   indexDelta++;
+  // }
+
+  // // remap call ops
+  // if (indexDelta) for (let i = 0; i < funcs.length; i++) {
+  //   const wasm = funcs[i].wasm;
+  //   for (let j = 0; j < wasm.length; j++) {
+  //     const op = wasm[j];
+  //     if (op[0] === Opcodes.call) {
+  //       let idx = op[1];
+  //       wasm[j] = [ Opcodes.call, funcRemap.get(idx) ?? idx ];
+  //     }
+
+  //     if (op[0] === Opcodes.const && op[2] === 'funcref') {
+  //       wasm[j] = [ Opcodes.const, funcRemap.get(op[1] + importedFuncs.length) - importedFuncs.length ];
+  //     }
+  //   }
+  // }
+
   return { funcs, globals, tags, exceptions, pages, data };
 };

package/compiler/decompile.js

@@ -99,7 +99,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
 
     if (inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) {
       const idx = inst[1];
-      const callFunc = funcs.find(x => x.index === idx);
+      const callFunc = funcs.find(x => (x.asmIndex ?? x.index) === idx);
       if (callFunc) out += ` ;; $${callFunc.name} ${makeSignature(callFunc.params, callFunc.returns)}`;
       if (globalThis.importFuncs && idx < importFuncs.length) {
         const importFunc = importFuncs[idx];

package/compiler/precompile.js

@@ -203,15 +203,15 @@ ${funcs.map(x => {
         if (Number.isNaN(v) || v === Infinity || v === -Infinity) return v.toString();
         return v;
       })
-      .replace(/\["alloc","(.*?)","(.*?)",(.*?)\]/g, (_, reason, type, valtype) => `...number(allocPage(_,'${reason}','${type}')*pageSize,${valtype})`)
+      .replace(/\["alloc","(.*?)","(.*?)",(.*?)\]/g, (_, reason, type, valtype) => `...number(allocPage(_,'${reason}','${type}'),${valtype})`)
       .replace(/\["global",(.*?),"(.*?)",(.*?)\]/g, (_, opcode, name, valtype) => `...glbl(${opcode},'${name}',${valtype})`)
       .replace(/\"local","(.*?)",(.*?)\]/g, (_, name, valtype) => `loc('${name}',${valtype})]`)
       .replace(/\[16,"(.*?)"]/g, (_, name) => `[16,builtin('${name}')]`)
-      .replace(/\[68,"funcref","(.*?)"]/g, (_, name, offset) => `[68,builtin('${name}',1)]`)
+      .replace(/\[68,"funcref","(.*?)"]/g, (_, name) => `...funcRef('${name}')`)
       .replace(/\["throw","(.*?)","(.*?)"\]/g, (_, constructor, message) => `...internalThrow(_,'${constructor}',\`${message}\`)`)
       .replace(/\["get object","(.*?)"\]/g, (_, objName) => `...generateIdent(_,{name:'${objName}'})`);
 
-    return `(_,{${`${str.includes('allocPage(') ? 'allocPage,' : ''}${str.includes('glbl(') ? 'glbl,' : ''}${str.includes('loc(') ? 'loc,' : ''}${str.includes('builtin(') ? 'builtin,' : ''}${str.includes('internalThrow(') ? 'internalThrow,' : ''}${str.includes('generateIdent(') ? 'generateIdent,' : ''}`.slice(0, -1)}})=>`.replace('_,{}', '') + str;
+    return `(_,{${`${str.includes('allocPage(') ? 'allocPage,' : ''}${str.includes('glbl(') ? 'glbl,' : ''}${str.includes('loc(') ? 'loc,' : ''}${str.includes('builtin(') ? 'builtin,' : ''}${str.includes('funcRef(') ? 'funcRef,' : ''}${str.includes('internalThrow(') ? 'internalThrow,' : ''}${str.includes('generateIdent(') ? 'generateIdent,' : ''}`.slice(0, -1)}})=>`.replace('_,{}', '') + str;
   };
 
   const locals = Object.entries(x.locals).sort((a,b) => a[1].idx - b[1].idx)

package/compiler/wrap.js

@@ -127,7 +127,8 @@ ${flags & 0b0001 ? `    get func idx: ${get}
       if (value < 0) {
         func = importedFuncs[value + importedFuncs.length];
       } else {
-        func = funcs.find(x => ((x.originalIndex ?? x.index) - importedFuncs.length) === value);
+        value += importedFuncs.length;
+        func = funcs.find(x => x.index === value);
       }
 
       if (!func) return function () {};
@@ -502,7 +503,7 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
 
           if (exceptionMode === 'stackest') {
             const constructorIdx = e.getArg(exceptTag, 0);
-            const constructorName = constructorIdx == -1 ? null : funcs.find(x => ((x.originalIndex ?? x.index) - importedFuncs.length) === constructorIdx)?.name;
+            const constructorName = constructorIdx == -1 ? null : funcs.find(x => (x.index - importedFuncs.length) === constructorIdx)?.name;
 
             const value = e.getArg(exceptTag, 1);
             const type = e.getArg(exceptTag, 2);

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.34.6+581b45353",
+  "version": "0.34.8+3c064d5f4",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.34.6+581b45353';
+globalThis.version = '0.34.8+3c064d5f4';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {