porffor 0.14.0-c6edfd328 → 0.14.0-d6c141d91

package/compiler/builtins/string.ts

@@ -1,4 +1,5 @@
 // @porf --valtype=i32
+import type {} from './porffor.d.ts';
 
 export const __String_fromCharCode = (code: i32) => {
   // todo: support >1 arg

package/compiler/builtins/symbol.ts

@@ -1,3 +1,5 @@
+import type {} from './porffor.d.ts';
+
 export const __Porffor_symbol_descStore = (op: boolean, value: any): any => {
   const ptr: bytestring = '';
 

package/compiler/builtins.js

@@ -40,6 +40,18 @@ export const importedFuncs = [
     import: 'z',
     params: 1,
     returns: 0
+  },
+  {
+    name: '__Porffor_readArgv',
+    import: 'w',
+    params: 2,
+    returns: 0
+  },
+  {
+    name: '__Porffor_readFile',
+    import: 'q',
+    params: 2,
+    returns: 0
   }
 ];
 
@@ -221,8 +233,7 @@ export const BuiltinFuncs = function() {
     typedParams: true,
     locals: [ Valtype.i32, Valtype.i32 ],
     returns: [],
-    callsSelf: true,
-    wasm: (scope, { typeSwitch }) => [
+    wasm: (scope, { typeSwitch, builtin }) => [
       ...typeSwitch(scope, [ [ Opcodes.local_get, 1 ] ], {
         [TYPES.number]: [
           [ Opcodes.local_get, 0 ],
@@ -327,14 +338,14 @@ export const BuiltinFuncs = function() {
 
           [ Opcodes.loop, Blocktype.void ],
 
-          // print current char
+          // print current array element
           [ Opcodes.local_get, 2 ],
           [ Opcodes.load, 0, ValtypeSize.i32 ],
 
           [ Opcodes.local_get, 2 ],
           [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
 
-          [ Opcodes.call, -1 ],
+          [ Opcodes.call, builtin('__Porffor_print') ],
 
           // increment pointer by sizeof valtype
           [ Opcodes.local_get, 2 ],
@@ -1084,5 +1095,16 @@ export const BuiltinFuncs = function() {
     ]
   };
 
+
+  this.__fs_readFileSync = {
+    params: [ valtypeBinary, valtypeBinary ],
+    locals: [],
+    returns: [ valtypeBinary ],
+    returnType: TYPES.bytestring,
+    wasm: [
+      [ Opcodes.call, importedFuncs.__Porffor_readFile ],
+    ]
+  };
+
   GeneratedBuiltins.BuiltinFuncs.call(this);
 };

package/compiler/codegen.js

@@ -40,11 +40,11 @@ const todo = (scope, msg, expectsValue = undefined) => {
   }
 };
 
-const isFuncType = type => type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
-const hasFuncWithName = name => {
-  const func = funcs.find(x => x.name === name);
-  return !!(func || builtinFuncs[name] || importedFuncs[name] || internalConstrs[name]);
-};
+const isFuncType = type =>
+  type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
+const hasFuncWithName = name =>
+  funcIndex[name] != null || builtinFuncs[name] != null || importedFuncs[name] != null || internalConstrs[name] != null;
+
 const generate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
   switch (decl.type) {
     case 'BinaryExpression':
@@ -147,14 +147,16 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
       return generateMember(scope, decl, global, name);
 
     case 'ExportNamedDeclaration':
-      // hack to flag new func for export
-      const funcsBefore = funcs.length;
+      const funcsBefore = funcs.map(x => x.name);
       generate(scope, decl.declaration);
 
-      if (funcsBefore !== funcs.length) {
-        // new func added
-        const newFunc = funcs[funcs.length - 1];
-        newFunc.export = true;
+      // set new funcs as exported
+      if (funcsBefore.length !== funcs.length) {
+        const newFuncs = funcs.filter(x => !funcsBefore.includes(x.name)).filter(x => !x.internal);
+
+        for (const x of newFuncs) {
+          x.export = true;
+        }
       }
 
       return [];
@@ -361,7 +363,7 @@ const localTmp = (scope, name, type = valtypeBinary) => {
 };
 
 const isIntOp = op => op && ((op[0] >= 0x45 && op[0] <= 0x4f) || (op[0] >= 0x67 && op[0] <= 0x78) || op[0] === 0x41);
-const isFloatToIntOp = op => op && (op[0] >= 0xb7 && op[0] <= 0xba);
+const isIntToFloatOp = op => op && (op[0] >= 0xb7 && op[0] <= 0xba);
 
 const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   const checks = {
@@ -378,10 +380,10 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
 
   // if we can, use int tmp and convert at the end to help prevent unneeded conversions
   // (like if we are in an if condition - very common)
-  const leftIsInt = isFloatToIntOp(left[left.length - 1]);
-  const rightIsInt = isFloatToIntOp(right[right.length - 1]);
+  const leftWasInt = isIntToFloatOp(left[left.length - 1]);
+  const rightWasInt = isIntToFloatOp(right[right.length - 1]);
 
-  const canInt = leftIsInt && rightIsInt;
+  const canInt = leftWasInt && rightWasInt;
 
   if (canInt) {
     // remove int -> float conversions from left and right
@@ -646,9 +648,9 @@ const compareStrings = (scope, left, right, bytestrings = false) => {
     [ Opcodes.i32_add ],
     [ Opcodes.local_tee, index ],
 
-    // if index != index end (length * sizeof valtype), loop
+    // if index < index end (length * sizeof valtype), loop
     [ Opcodes.local_get, indexEnd ],
-    [ Opcodes.i32_ne ],
+    [ Opcodes.i32_lt_s ],
     [ Opcodes.br_if, 0 ],
     [ Opcodes.end ],
 
@@ -666,8 +668,8 @@ const compareStrings = (scope, left, right, bytestrings = false) => {
   ];
 };
 
-const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
-  if (isFloatToIntOp(wasm[wasm.length - 1])) return [
+const truthy = (scope, wasm, type, intIn = false, intOut = false, forceTruthyMode = undefined) => {
+  if (isIntToFloatOp(wasm[wasm.length - 1])) return [
     ...wasm,
     ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
   ];
@@ -676,47 +678,38 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
   const useTmp = knownType(scope, type) == null;
   const tmp = useTmp && localTmp(scope, `#logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
 
-  const def = [
-    // if value != 0
-    ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
+  const def = (truthyMode => {
+    if (truthyMode === 'full') return [
+      // if value != 0 or NaN
+      ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
+      ...(intIn ? [ ] : [ Opcodes.i32_to ]),
 
-    // ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
-    // [ Opcodes.i32_eqz ],
+      [ Opcodes.i32_eqz ],
+      [ Opcodes.i32_eqz ],
 
-    // ...(intIn ? [
-    //   ...number(0, Valtype.i32),
-    //   [ Opcodes.i32_gt_s ]
-    // ] : [
-    //   ...number(0),
-    //   [ Opcodes.f64_gt ]
-    // ]),
-
-    // ...(intOut ? [] : [ Opcodes.i32_from ]),
-
-    // ...(intIn ? [] : [ Opcodes.i32_to ]),
-    // [ Opcodes.if, intOut ? Valtype.i32 : valtypeBinary ],
-    // ...number(1, intOut ? Valtype.i32 : valtypeBinary),
-    // [ Opcodes.else ],
-    // ...number(0, intOut ? Valtype.i32 : valtypeBinary),
-    // [ Opcodes.end ],
-
-    ...(!intOut || (intIn && intOut) ? [] : [ Opcodes.i32_to_u ]),
-
-    /* Opcodes.eqz,
-    [ Opcodes.i32_eqz ],
-    Opcodes.i32_from */
-  ];
+      ...(intOut ? [] : [ Opcodes.i32_from ]),
+    ];
+
+    if (truthyMode === 'no_negative') return [
+      // if value != 0 or NaN, non-binary output. negative numbers not truthy :/
+      ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
+      ...(intIn ? [] : [ Opcodes.i32_to ]),
+      ...(intOut ? [] : [ Opcodes.i32_from ])
+    ];
+
+    if (truthyMode === 'no_nan_negative') return [
+      // simpler and faster but makes NaN truthy and negative numbers not truthy,
+      // plus non-binary output
+      ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
+      ...(!intOut || (intIn && intOut) ? [] : [ Opcodes.i32_to_u ])
+    ];
+  })(forceTruthyMode ?? Prefs.truthy ?? 'full');
 
   return [
     ...wasm,
     ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
-      // [TYPES.number]: def,
-      [TYPES.array]: [
-        // arrays are always truthy
-        ...number(1, intOut ? Valtype.i32 : valtypeBinary)
-      ],
       [TYPES.string]: [
         ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
@@ -752,10 +745,6 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
     ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
-      [TYPES.array]: [
-        // arrays are always truthy
-        ...number(0, intOut ? Valtype.i32 : valtypeBinary)
-      ],
       [TYPES.string]: [
         ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
@@ -999,7 +988,7 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
       // if both are true
       [ Opcodes.i32_and ],
       [ Opcodes.if, Blocktype.void ],
-      ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ]),
+      ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ], false),
       ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : []),
       [ Opcodes.br, 1 ],
       [ Opcodes.end ],
@@ -1048,14 +1037,14 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
   return out;
 };
 
-const asmFuncToAsm = (func, { name = '#unknown_asm_func', params = [], locals = [], returns = [], localInd = 0 }) => {
-  return func({ name, params, locals, returns, localInd }, {
+const asmFuncToAsm = (func, scope) => {
+  return func(scope, {
     TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage, internalThrow,
-    builtin: name => {
-      let idx = funcIndex[name] ?? importedFuncs[name];
-      if (idx === undefined && builtinFuncs[name]) {
-        includeBuiltin(null, name);
-        idx = funcIndex[name];
+    builtin: n => {
+      let idx = funcIndex[n] ?? importedFuncs[n];
+      if (idx == null && builtinFuncs[n]) {
+        includeBuiltin(null, n);
+        idx = funcIndex[n];
       }
 
       return idx;
@@ -1063,7 +1052,7 @@ const asmFuncToAsm = (func, { name = '#unknown_asm_func', params = [], locals =
   });
 };
 
-const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [], data: _data = [], table = false, callsSelf = false }) => {
+const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [], data: _data = [], table = false }) => {
   const existing = funcs.find(x => x.name === name);
   if (existing) return existing;
 
@@ -1081,7 +1070,22 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     data.push(copy);
   }
 
-  if (typeof wasm === 'function') wasm = asmFuncToAsm(wasm, { name, params, locals, returns, localInd: allLocals.length });
+  const func = {
+    name,
+    params,
+    locals,
+    localInd: allLocals.length,
+    returns,
+    returnType: returnType ?? TYPES.number,
+    internal: true,
+    index: currentFuncIndex++,
+    table
+  };
+
+  funcs.push(func);
+  funcIndex[name] = func.index;
+
+  if (typeof wasm === 'function') wasm = asmFuncToAsm(wasm, func);
 
   let baseGlobalIdx, i = 0;
   for (const type of globalTypes) {
@@ -1100,23 +1104,6 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     }
   }
 
-  const func = {
-    name,
-    params,
-    locals,
-    returns,
-    returnType: returnType ?? TYPES.number,
-    wasm,
-    internal: true,
-    index: currentFuncIndex++
-  };
-
-  if (callsSelf) for (const inst of wasm) {
-    if (inst[0] === Opcodes.call && inst[1] === -1) {
-      inst[1] = func.index;
-    }
-  }
-
   if (table) for (const inst of wasm) {
     if (inst[0] === Opcodes.i32_load16_u && inst.at(-1) === 'read_argc') {
       inst.splice(2, 99);
@@ -1124,10 +1111,7 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     }
   }
 
-  funcs.push(func);
-  funcIndex[name] = func.index;
-
-  if (table) funcs.table = true;
+  func.wasm = wasm;
 
   return func;
 };
@@ -1479,16 +1463,11 @@ const countLeftover = wasm => {
         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] === -1) {
-            // todo: count for calling self
-          } else if (!func && inst[1] < importedFuncs.length) {
-            count -= importedFuncs[inst[1]].params;
-            count += importedFuncs[inst[1]].returns;
+          if (inst[1] < importedFuncs.length) {
+            func = importedFuncs[inst[1]];
+            count = count - func.params + func.returns;
           } else {
-            if (func) {
-              count -= func.params.length;
-            } else count--;
-            if (func) count += func.returns.length;
+            count = count - func.params.length + func.returns.length;
           }
         } else if (inst[0] === Opcodes.call_indirect) {
           count--; // funcidx
@@ -1641,6 +1620,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
       if (!funcIndex[rhemynName]) {
         const func = Rhemyn[funcName](regex, currentFuncIndex++, rhemynName);
+        func.internal = true;
 
         funcIndex[func.name] = func.index;
         funcs.push(func);
@@ -1812,11 +1792,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
   if (idx === undefined && internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
 
-  if (idx === undefined && name === scope.name) {
-    // hack: calling self, func generator will fix later
-    idx = -1;
-  }
-
   if (idx === undefined && name.startsWith('__Porffor_wasm_')) {
     const wasmOps = {
       // pointer, align, offset
@@ -1998,11 +1973,10 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
   }
 
-  const func = funcs.find(x => x.index === idx);
-
-  const userFunc = (funcIndex[name] && !importedFuncs[name] && !builtinFuncs[name] && !internalConstrs[name]) || idx === -1;
+  const func = funcs[idx - importedFuncs.length]; // idx === scope.index ? scope : funcs.find(x => x.index === idx);
+  const userFunc = func && !func.internal;
   const typedParams = userFunc || builtinFuncs[name]?.typedParams;
-  const typedReturns = (func ? func.returnType == null : userFunc) || builtinFuncs[name]?.typedReturns;
+  const typedReturns = (func && func.returnType == null) || builtinFuncs[name]?.typedReturns;
   const paramCount = func && (typedParams ? func.params.length / 2 : func.params.length);
 
   let args = decl.arguments;
@@ -2605,6 +2579,7 @@ const generateUnary = (scope, decl) => {
       ];
 
     case '!':
+      // todo/perf: optimize !!
       // !=
       return falsy(scope, generate(scope, decl.argument), getNodeType(scope, decl.argument), false, false);
 
@@ -3144,14 +3119,18 @@ const generateThrow = (scope, decl) => {
 };
 
 const generateTry = (scope, decl) => {
-  if (decl.finalizer) return todo(scope, 'try finally not implemented yet');
+  // todo: handle control-flow pre-exit for finally
+  // "Immediately before a control-flow statement (return, throw, break, continue) is executed in the try block or catch block."
 
   const out = [];
 
+  const finalizer = decl.finalizer ? generate(scope, decl.finalizer) : [];
+
   out.push([ Opcodes.try, Blocktype.void ]);
   depth.push('try');
 
   out.push(...generate(scope, decl.block));
+  out.push(...finalizer);
 
   if (decl.handler) {
     depth.pop();
@@ -3159,6 +3138,7 @@ const generateTry = (scope, decl) => {
 
     out.push([ Opcodes.catch_all ]);
     out.push(...generate(scope, decl.handler.body));
+    out.push(...finalizer);
   }
 
   out.push([ Opcodes.end ]);
@@ -3256,8 +3236,13 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     // todo: can we just have 1 undeclared array? probably not? but this is not really memory efficient
     const uniqueName = name === '$undeclared' ? name + Math.random().toString().slice(2) : name;
 
-    if (Prefs.scopedPageNames) scope.arrays.set(name, allocPage(scope, `${getAllocType(itemType)}: ${scope.name}/${uniqueName}`, itemType) * pageSize);
-      else scope.arrays.set(name, allocPage(scope, `${getAllocType(itemType)}: ${uniqueName}`, itemType) * pageSize);
+    let page;
+    if (Prefs.scopedPageNames) page = allocPage(scope, `${getAllocType(itemType)}: ${scope.name}/${uniqueName}`, itemType);
+      else page = allocPage(scope, `${getAllocType(itemType)}: ${uniqueName}`, itemType);
+
+    // hack: use 1 for page 0 pointer for fast truthiness
+    const ptr = page === 0 ? 1 : (page * pageSize);
+    scope.arrays.set(name, ptr);
   }
 
   const pointer = scope.arrays.get(name);
@@ -3444,8 +3429,19 @@ const withType = (scope, wasm, type) => [
 
 const generateMember = (scope, decl, _global, _name) => {
   const name = decl.object.name;
-  const pointer = scope.arrays?.get(name);
 
+  // hack: process.argv[n]
+  if (name === '__process_argv') {
+    const setPointer = scope.arrays?.get(_name);
+
+    return [
+      ...number(decl.property.value - 1),
+      ...(setPointer ? number(setPointer) : allocPage(scope, `__process_argv out (${randId()})`)),
+      [ Opcodes.call, importedFuncs.__Porffor_readArgv ]
+    ];
+  }
+
+  const pointer = scope.arrays?.get(name);
   const aotPointer = Prefs.aotPointerOpt && pointer;
 
   // hack: .name
@@ -3466,8 +3462,7 @@ const generateMember = (scope, decl, _global, _name) => {
   if (decl.property.name === 'length') {
     const func = funcs.find(x => x.name === name);
     if (func) {
-      const userFunc = funcIndex[name] && !importedFuncs[name] && !builtinFuncs[name] && !internalConstrs[name];
-      const typedParams = userFunc || builtinFuncs[name]?.typedParams;
+      const typedParams = !func.internal || builtinFuncs[name]?.typedParams;
       return withType(scope, number(typedParams ? func.params.length / 2 : func.params.length), TYPES.number);
     }
 
@@ -3693,34 +3688,39 @@ const generateFunc = (scope, decl) => {
   const name = decl.id ? decl.id.name : `anonymous_${randId()}`;
   const params = decl.params ?? [];
 
-  // const innerScope = { ...scope };
   // TODO: share scope/locals between !!!
-  const innerScope = {
+  const func = {
     locals: {},
     localInd: 0,
     // value, type
     returns: [ valtypeBinary, Valtype.i32 ],
     throws: false,
-    name
+    name,
+    index: currentFuncIndex++
   };
 
   if (typedInput && decl.returnType) {
     const { type } = extractTypeAnnotation(decl.returnType);
     // if (type != null && !Prefs.indirectCalls) {
     if (type != null) {
-      innerScope.returnType = type;
-      innerScope.returns = [ valtypeBinary ];
+      func.returnType = type;
+      func.returns = [ valtypeBinary ];
     }
   }
 
   for (let i = 0; i < params.length; i++) {
-    allocVar(innerScope, params[i].name, false);
+    const name = params[i].name;
+    // if (name == null) return todo('non-identifier args are not supported');
+
+    allocVar(func, name, false);
 
     if (typedInput && params[i].typeAnnotation) {
-      addVarMetadata(innerScope, params[i].name, false, extractTypeAnnotation(params[i]));
+      addVarMetadata(func, name, false, extractTypeAnnotation(params[i]));
     }
   }
 
+  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
@@ -3730,37 +3730,23 @@ const generateFunc = (scope, decl) => {
     };
   }
 
-  const wasm = generate(innerScope, body);
-  const func = {
-    name,
-    params: Object.values(innerScope.locals).slice(0, params.length * 2).map(x => x.type),
-    index: currentFuncIndex++,
-    ...innerScope
-  };
   funcIndex[name] = func.index;
+  funcs.push(func);
 
-  if (name === 'main') func.gotLastType = true;
+  const wasm = generate(func, body);
+  func.wasm = wasm;
 
-  // quick hack fixes
-  for (const inst of wasm) {
-    if (inst[0] === Opcodes.call && inst[1] === -1) {
-      inst[1] = func.index;
-    }
-  }
+  if (name === 'main') func.gotLastType = true;
 
   // add end return if not found
   if (name !== 'main' && wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
     wasm.push(
       ...number(0),
-      ...(innerScope.returnType != null ? [] : number(TYPES.undefined, Valtype.i32)),
+      ...(func.returnType != null ? [] : number(TYPES.undefined, Valtype.i32)),
       [ Opcodes.return ]
     );
   }
 
-  func.wasm = wasm;
-
-  funcs.push(func);
-
   return func;
 };
 
@@ -3864,7 +3850,7 @@ const internalConstrs = {
     generate: (scope, decl) => {
       // todo: boolean object when used as constructor
       const arg = decl.arguments[0] ?? DEFAULT_VALUE;
-      return truthy(scope, generate(scope, arg), getNodeType(scope, arg));
+      return truthy(scope, generate(scope, arg), getNodeType(scope, arg), false, false, 'full');
     },
     type: TYPES.boolean,
     length: 1
@@ -4009,9 +3995,8 @@ export default program => {
 
   if (Prefs.astLog) console.log(JSON.stringify(program.body.body, null, 2));
 
-  generateFunc(scope, program);
+  const main = generateFunc(scope, program);
 
-  const main = funcs[funcs.length - 1];
   main.export = true;
   main.returns = [ valtypeBinary, Valtype.i32 ];
 
@@ -4038,7 +4023,7 @@ export default program => {
   }
 
   // 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(funcs.length - 1, 1);
+  if (main.wasm.length === 0 && funcs.reduce((acc, x) => acc + (x.export ? 1 : 0), 0) > 1) funcs.splice(main.index - importedFuncs.length, 1);
 
   return { funcs, globals, tags, exceptions, pages, data };
 };