porffor 0.14.0-b481bfc5f → 0.14.0-bb0b06c17

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 [];
@@ -1048,14 +1050,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 +1065,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 = [], 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 +1083,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,25 +1117,14 @@ 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);
+      inst.push(...unsignedLEB128(allocPage({}, 'func argc lut') * pageSize));
     }
   }
 
-  funcs.push(func);
-  funcIndex[name] = func.index;
+  func.wasm = wasm;
 
   return func;
 };
@@ -1470,16 +1476,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
@@ -1632,6 +1633,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);
@@ -1803,11 +1805,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
@@ -1859,36 +1856,128 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       const [ local, global ] = lookupName(scope, name);
       if (!Prefs.indirectCalls || local == null) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
 
-      // todo: only works when:
-      //   1. arg count matches arg count of function
-      //   2. function uses typedParams and typedReturns
+      // todo: only works when function uses typedParams and typedReturns
+
+      const indirectMode = Prefs.indirectCallMode ?? 'vararg';
+      // options: vararg, strict
+      // - strict: simpler, smaller size usage, no func argc lut needed.
+      //   ONLY works when arg count of call == arg count of function being called
+      // - vararg: large size usage, cursed.
+      //   works when arg count of call != arg count of function being called*
+      //   * most of the time, some edgecases
 
       funcs.table = true;
+      scope.table = true;
 
       let args = decl.arguments;
-      let argWasm = [];
+      let out = [];
+
+      let locals = [];
+
+      if (indirectMode === 'vararg') {
+        const minArgc = Prefs.indirectCallMinArgc ?? 3;
+
+        if (args.length < minArgc) {
+          args = args.concat(new Array(minArgc - args.length).fill(DEFAULT_VALUE));
+        }
+      }
 
       for (let i = 0; i < args.length; i++) {
         const arg = args[i];
-        argWasm = argWasm.concat(generate(scope, arg));
+        out = out.concat(generate(scope, arg));
 
         if (valtypeBinary !== Valtype.i32 && (
           (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
           (importedFuncs[name] && name.startsWith('profile'))
         )) {
-          argWasm.push(Opcodes.i32_to);
+          out.push(Opcodes.i32_to);
+        }
+
+        out = out.concat(getNodeType(scope, arg));
+
+        if (indirectMode === 'vararg') {
+          const typeLocal = localTmp(scope, `#indirect_arg${i}_type`, Valtype.i32);
+          const valLocal = localTmp(scope, `#indirect_arg${i}_val`);
+
+          locals.push([valLocal, typeLocal]);
+
+          out.push(
+            [ Opcodes.local_set, typeLocal ],
+            [ Opcodes.local_set, valLocal ]
+          );
         }
+      }
+
+      if (indirectMode === 'strict') {
+        return typeSwitch(scope, getNodeType(scope, decl.callee), {
+          [TYPES.function]: [
+            ...argWasm,
+            [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+            Opcodes.i32_to_u,
+            [ Opcodes.call_indirect, args.length, 0 ],
+            ...setLastType(scope)
+          ],
+          default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
+        });
+      }
+
+      // hi, I will now explain how vararg mode works:
+      // wasm's indirect_call instruction requires you know the func type at compile-time
+      // since we have varargs (variable argument count), we do not know it.
+      // we could just store args in memory and not use wasm func args,
+      // but that is slow (probably) and breaks js exports.
+      // instead, we generate every* possibility of argc and use different indirect_call
+      // ops for each one, with type depending on argc for that branch.
+      // then we load the argc for the wanted function from a memory lut,
+      // and call the branch with the matching argc we require.
+      // sorry, yes it is very cursed (and size inefficient), but indirect calls
+      // are kind of rare anyway (mostly callbacks) so I am not concerned atm.
+      // *for argc 0-3, in future (todo:) the max number should be
+      // dynamically changed to the max argc of any func in the js file.
+
+      const funcLocal = localTmp(scope, `#indirect_func`, Valtype.i32);
+
+      const gen = argc => {
+        const out = [];
+        for (let i = 0; i < argc; i++) {
+          out.push(
+            [ Opcodes.local_get, locals[i][0] ],
+            [ Opcodes.local_get, locals[i][1] ]
+          );
+        }
+
+        out.push(
+          [ Opcodes.local_get, funcLocal ],
+          [ Opcodes.call_indirect, argc, 0 ],
+          ...setLastType(scope)
+        )
+
+        return out;
+      };
 
-        argWasm = argWasm.concat(getNodeType(scope, arg));
+      const tableBc = {};
+      for (let i = 0; i <= args.length; i++) {
+        tableBc[i] = gen(i);
       }
 
+      // todo/perf: check if we should use br_table here or just generate our own big if..elses
+
       return typeSwitch(scope, getNodeType(scope, decl.callee), {
         [TYPES.function]: [
-          ...argWasm,
+          ...out,
+
           [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
           Opcodes.i32_to_u,
-          [ Opcodes.call_indirect, args.length, 0 ],
-          ...setLastType(scope)
+          [ Opcodes.local_set, funcLocal ],
+
+          ...brTable([
+            // get argc of func we are calling
+            [ Opcodes.local_get, funcLocal ],
+            ...number(ValtypeSize.i16, Valtype.i32),
+            [ Opcodes.i32_mul ],
+
+            [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func argc lut') * pageSize), 'read_argc' ]
+          ], tableBc, valtypeBinary)
         ],
         default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
       });
@@ -1897,11 +1986,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;
@@ -2046,16 +2134,17 @@ const brTable = (input, bc, returns) => {
   }
 
   for (let i = 0; i < count; i++) {
-    if (i === 0) out.push([ Opcodes.block, returns, 'br table start' ]);
+    // if (i === 0) out.push([ Opcodes.block, returns, 'br table start' ]);
+    if (i === 0) out.push([ Opcodes.block, returns ]);
       else out.push([ Opcodes.block, Blocktype.void ]);
   }
 
-  const nums = keys.filter(x => +x);
+  const nums = keys.filter(x => +x >= 0);
   const offset = Math.min(...nums);
   const max = Math.max(...nums);
 
   const table = [];
-  let br = 1;
+  let br = 0;
 
   for (let i = offset; i <= max; i++) {
     // if branch for this num, go to that block
@@ -2095,10 +2184,9 @@ const brTable = (input, bc, returns) => {
     br--;
   }
 
-  return [
-    ...out,
-    [ Opcodes.end, 'br table end' ]
-  ];
+  out.push([ Opcodes.end ]);
+
+  return out;
 };
 
 const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
@@ -3043,14 +3131,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();
@@ -3058,6 +3150,7 @@ const generateTry = (scope, decl) => {
 
     out.push([ Opcodes.catch_all ]);
     out.push(...generate(scope, decl.handler.body));
+    out.push(...finalizer);
   }
 
   out.push([ Opcodes.end ]);
@@ -3365,8 +3458,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);
     }
 
@@ -3592,33 +3684,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) {
-      innerScope.returnType = type;
-      innerScope.returns = [ valtypeBinary ];
+    // if (type != null && !Prefs.indirectCalls) {
+    if (type != null) {
+      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
@@ -3628,37 +3726,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;
 };
 
@@ -3907,9 +3991,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 ];
 
@@ -3936,7 +4019,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 };
 };