porffor 0.48.3 → 0.48.5

package/compiler/codegen.js

@@ -31,7 +31,7 @@ const todo = (scope, msg, expectsValue = undefined) => {
       throw new TodoError(msg);
 
     case 'runtime':
-      return internalThrow(scope, '__Porffor_TodoError', msg, expectsValue);
+      return internalThrow(scope, 'TodoError', msg, expectsValue);
   }
 };
 
@@ -389,6 +389,8 @@ const generateIdent = (scope, decl) => {
       if (builtinVars[name].floatOnly && valtype[0] === 'i') throw new Error(`Cannot use ${unhackName(name)} with integer valtype`);
 
       let wasm = builtinVars[name];
+      if (wasm.usesImports) scope.usesImports = true;
+
       if (typeof wasm === 'function') wasm = asmFuncToAsm(scope, wasm);
       return wasm.slice();
     }
@@ -1207,7 +1209,7 @@ const asmFuncToAsm = (scope, func) => {
   });
 };
 
-const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTypes = [], globals: globalTypes = [], globalInits = [], returns = [], returnType, localNames = [], globalNames = [], data: _data = [], table = false, constr = false, hasRestArgument = false, usesTag = false, usedTypes = [] } = {}) => {
+const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTypes = [], globals: globalTypes = [], globalInits = [], returns = [], returnType, localNames = [], globalNames = [], data: _data = [], table = false, constr = false, hasRestArgument = false, usesTag = false, usesImports = false, usedTypes = [] } = {}) => {
   if (wasm == null) { // called with no builtin
     log.warning('codegen', `${name} has no built-in!`);
     wasm = [];
@@ -1282,6 +1284,7 @@ const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTy
 
   if (hasRestArgument) func.hasRestArgument = true;
   if (usesTag) ensureTag();
+  if (usesImports) func.usesImports = true;
 
   for (const x of usedTypes) typeUsed(func, x);
 
@@ -2271,155 +2274,158 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   let idx;
-  if (Object.hasOwn(funcIndex, name)) idx = funcIndex[name];
-    else if (Object.hasOwn(importedFuncs, name)) idx = importedFuncs[name];
-    else if (Object.hasOwn(builtinFuncs, name)) {
-      if (builtinFuncs[name].floatOnly && valtype !== 'f64') throw new Error(`Cannot use built-in ${unhackName(name)} with integer valtype`);
-      if (decl._new && !builtinFuncs[name].constr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
-
-      includeBuiltin(scope, name);
-      idx = funcIndex[name];
-    } else if (Object.hasOwn(internalConstrs, name)) {
-      if (decl._new && internalConstrs[name].notConstr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
-      return internalConstrs[name].generate(scope, decl, _global, _name);
-    } else if (!decl._new && name && name.startsWith('__Porffor_wasm_')) {
-      const wasmOps = {
-        // pointer, align, offset
-        i32_load: { imms: 2, args: [ true ], returns: 1 },
-        // pointer, value, align, offset
-        i32_store: { imms: 2, args: [ true, true ], returns: 0 },
-        // pointer, align, offset
-        i32_load8_u: { imms: 2, args: [ true ], returns: 1 },
-        // pointer, value, align, offset
-        i32_store8: { imms: 2, args: [ true, true ], returns: 0 },
-        // pointer, align, offset
-        i32_load16_u: { imms: 2, args: [ true ], returns: 1 },
-        // pointer, value, align, offset
-        i32_store16: { imms: 2, args: [ true, true ], returns: 0 },
-
-        // pointer, align, offset
-        f64_load: { imms: 2, args: [ true ], returns: 0 }, // 0 due to not i32
-        // pointer, value, align, offset
-        f64_store: { imms: 2, args: [ true, false ], returns: 0 },
-
-        // value
-        i32_const: { imms: 1, args: [], returns: 0 },
-
-        // dst, src, size, _, _
-        memory_copy: { imms: 2, args: [ true, true, true ], returns: 0 }
-      };
+  if (Object.hasOwn(funcIndex, name)) {
+    idx = funcIndex[name];
+  } else if (Object.hasOwn(importedFuncs, name)) {
+    idx = importedFuncs[name];
+    scope.usesImports = true;
+  } else if (Object.hasOwn(builtinFuncs, name)) {
+    if (builtinFuncs[name].floatOnly && valtype !== 'f64') throw new Error(`Cannot use built-in ${unhackName(name)} with integer valtype`);
+    if (decl._new && !builtinFuncs[name].constr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
+
+    includeBuiltin(scope, name);
+    idx = funcIndex[name];
+  } else if (Object.hasOwn(internalConstrs, name)) {
+    if (decl._new && internalConstrs[name].notConstr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
+    return internalConstrs[name].generate(scope, decl, _global, _name);
+  } else if (!decl._new && name && name.startsWith('__Porffor_wasm_')) {
+    const wasmOps = {
+      // pointer, align, offset
+      i32_load: { imms: 2, args: [ true ], returns: 1 },
+      // pointer, value, align, offset
+      i32_store: { imms: 2, args: [ true, true ], returns: 0 },
+      // pointer, align, offset
+      i32_load8_u: { imms: 2, args: [ true ], returns: 1 },
+      // pointer, value, align, offset
+      i32_store8: { imms: 2, args: [ true, true ], returns: 0 },
+      // pointer, align, offset
+      i32_load16_u: { imms: 2, args: [ true ], returns: 1 },
+      // pointer, value, align, offset
+      i32_store16: { imms: 2, args: [ true, true ], returns: 0 },
+
+      // pointer, align, offset
+      f64_load: { imms: 2, args: [ true ], returns: 0 }, // 0 due to not i32
+      // pointer, value, align, offset
+      f64_store: { imms: 2, args: [ true, false ], returns: 0 },
+
+      // value
+      i32_const: { imms: 1, args: [], returns: 0 },
+
+      // dst, src, size, _, _
+      memory_copy: { imms: 2, args: [ true, true, true ], returns: 0 }
+    };
 
-      const opName = name.slice('__Porffor_wasm_'.length);
+    const opName = name.slice('__Porffor_wasm_'.length);
 
-      if (wasmOps[opName]) {
-        const op = wasmOps[opName];
+    if (wasmOps[opName]) {
+      const op = wasmOps[opName];
 
-        const argOut = [];
-        for (let i = 0; i < op.args.length; i++) {
-          if (!op.args[i]) globalThis.noi32F64CallConv = true;
+      const argOut = [];
+      for (let i = 0; i < op.args.length; i++) {
+        if (!op.args[i]) globalThis.noi32F64CallConv = true;
 
-          argOut.push(
-            ...generate(scope, decl.arguments[i]),
-            ...(op.args[i] ? [ Opcodes.i32_to ] : [])
-          );
+        argOut.push(
+          ...generate(scope, decl.arguments[i]),
+          ...(op.args[i] ? [ Opcodes.i32_to ] : [])
+        );
 
-          globalThis.noi32F64CallConv = false;
-        }
+        globalThis.noi32F64CallConv = false;
+      }
 
-        // literals only
-        const imms = decl.arguments.slice(op.args.length).map(x => x.value);
+      // literals only
+      const imms = decl.arguments.slice(op.args.length).map(x => x.value);
 
-        let opcode = Opcodes[opName];
-        if (!Array.isArray(opcode)) opcode = [ opcode ];
+      let opcode = Opcodes[opName];
+      if (!Array.isArray(opcode)) opcode = [ opcode ];
 
-        return [
-          ...argOut,
-          [ ...opcode, ...imms ],
-          ...(new Array(op.returns).fill(Opcodes.i32_from))
-        ];
-      }
-    } else {
-      if (!Prefs.indirectCalls) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+      return [
+        ...argOut,
+        [ ...opcode, ...imms ],
+        ...(new Array(op.returns).fill(Opcodes.i32_from))
+      ];
+    }
+  } else {
+    if (!Prefs.indirectCalls) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
 
-      funcs.table = true;
-      scope.table = true;
+    funcs.table = true;
+    scope.table = true;
 
-      let args = decl.arguments;
-      const wrapperArgc = Prefs.indirectWrapperArgc ?? 8;
-      if (args.length < wrapperArgc) {
-        args = args.concat(new Array(wrapperArgc - args.length).fill(DEFAULT_VALUE()));
-      }
+    let args = decl.arguments;
+    const wrapperArgc = Prefs.indirectWrapperArgc ?? 8;
+    if (args.length < wrapperArgc) {
+      args = args.concat(new Array(wrapperArgc - args.length).fill(DEFAULT_VALUE()));
+    }
 
-      for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        out = out.concat(generate(scope, arg), valtypeBinary === Valtype.i32 && scope.locals[arg.name]?.type !== Valtype.f64 ? [ [ Opcodes.f64_convert_i32_s ] ] : [], getNodeType(scope, arg));
-      }
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      out = out.concat(generate(scope, arg), valtypeBinary === Valtype.i32 && scope.locals[arg.name]?.type !== Valtype.f64 ? [ [ Opcodes.f64_convert_i32_s ] ] : [], getNodeType(scope, arg));
+    }
 
-      let knownThis = undefined, getCallee = undefined;
-      const calleeLocal = localTmp(scope, '#indirect_callee');
+    let knownThis = undefined, getCallee = undefined;
+    const calleeLocal = localTmp(scope, '#indirect_callee');
 
-      // hack: this should be more thorough, Function.bind, etc
-      if (decl.callee.type === 'MemberExpression' && !decl._new) {
-        const thisLocal = localTmp(scope, '#indirect_caller');
-        const thisLocalType = localTmp(scope, '#indirect_caller#type', Valtype.i32);
+    // hack: this should be more thorough, Function.bind, etc
+    if (decl.callee.type === 'MemberExpression' && !decl._new) {
+      const thisLocal = localTmp(scope, '#indirect_caller');
+      const thisLocalType = localTmp(scope, '#indirect_caller#type', Valtype.i32);
 
-        knownThis = [
-          [ Opcodes.local_get, thisLocal ],
-          [ Opcodes.local_get, thisLocalType ]
-        ];
-        getCallee = [
-          ...generate(scope, decl.callee.object),
-          [ Opcodes.local_set, thisLocal ],
-          ...getNodeType(scope, decl.callee.object),
-          [ Opcodes.local_set, thisLocalType ],
+      knownThis = [
+        [ Opcodes.local_get, thisLocal ],
+        [ Opcodes.local_get, thisLocalType ]
+      ];
+      getCallee = [
+        ...generate(scope, decl.callee.object),
+        [ Opcodes.local_set, thisLocal ],
+        ...getNodeType(scope, decl.callee.object),
+        [ Opcodes.local_set, thisLocalType ],
 
-          ...generate(scope, {
-            type: 'MemberExpression',
-            object: { type: 'Identifier', name: '#indirect_caller' },
-            property: decl.callee.property,
-            computed: decl.callee.computed,
-            optional: decl.callee.optional
-          })
-        ];
-      }
+        ...generate(scope, {
+          type: 'MemberExpression',
+          object: { type: 'Identifier', name: '#indirect_caller' },
+          property: decl.callee.property,
+          computed: decl.callee.computed,
+          optional: decl.callee.optional
+        })
+      ];
+    }
 
-      let callee = decl.callee, callAsNew = decl._new;
-      if (callee.type === 'Super') {
-        // call super constructor with direct super() call
-        callee = getObjProp(callee, 'constructor');
-        callAsNew = true;
-        knownThis = [
-          ...generate(scope, { type: 'ThisExpression' }),
-          ...getNodeType(scope, { type: 'ThisExpression' })
-        ];
-      }
+    let callee = decl.callee, callAsNew = decl._new;
+    if (callee.type === 'Super') {
+      // call super constructor with direct super() call
+      callee = getObjProp(callee, 'constructor');
+      callAsNew = true;
+      knownThis = [
+        ...generate(scope, { type: 'ThisExpression' }),
+        ...getNodeType(scope, { type: 'ThisExpression' })
+      ];
+    }
 
-      const newTargetWasm = decl._newTargetWasm ?? createNewTarget(scope, decl, [
-        [ Opcodes.local_get, calleeLocal ]
-      ], callAsNew);
-      const thisWasm = decl._thisWasm ?? knownThis ?? createThisArg(scope, decl);
+    const newTargetWasm = decl._newTargetWasm ?? createNewTarget(scope, decl, [
+      [ Opcodes.local_get, calleeLocal ]
+    ], callAsNew);
+    const thisWasm = decl._thisWasm ?? knownThis ?? createThisArg(scope, decl);
 
-      return [
-        ...(getCallee ? getCallee : generate(scope, callee)),
-        [ Opcodes.local_set, calleeLocal ],
+    return [
+      ...(getCallee ? getCallee : generate(scope, callee)),
+      [ Opcodes.local_set, calleeLocal ],
 
-        ...typeSwitch(scope, getNodeType(scope, callee), {
-          [TYPES.function]: () => [
-            ...forceDuoValtype(scope, newTargetWasm, Valtype.f64),
-            ...forceDuoValtype(scope, thisWasm, Valtype.f64),
-            ...out,
+      ...typeSwitch(scope, getNodeType(scope, callee), {
+        [TYPES.function]: () => [
+          ...forceDuoValtype(scope, newTargetWasm, Valtype.f64),
+          ...forceDuoValtype(scope, thisWasm, Valtype.f64),
+          ...out,
 
-            [ Opcodes.local_get, calleeLocal ],
-            Opcodes.i32_to_u,
-            [ Opcodes.call_indirect, args.length + 2, 0 ],
-            ...setLastType(scope)
-          ],
+          [ Opcodes.local_get, calleeLocal ],
+          Opcodes.i32_to_u,
+          [ Opcodes.call_indirect, args.length + 2, 0 ],
+          ...setLastType(scope)
+        ],
 
-          default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, Valtype.f64)
-        }, Valtype.f64),
-        ...(valtypeBinary === Valtype.i32 && scope.returns[0] !== Valtype.f64 ? [ [ Opcodes.f64_convert_i32_s ] ] : [])
-      ];
-    }
+        default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, Valtype.f64)
+      }, Valtype.f64),
+      ...(valtypeBinary === Valtype.i32 && scope.returns[0] !== Valtype.f64 ? [ [ Opcodes.f64_convert_i32_s ] ] : [])
+    ];
+  }
 
   const func = funcByIndex(idx);
 
@@ -6426,6 +6432,8 @@ const internalConstrs = {
 
   __Porffor_printStatic: {
     generate: (scope, decl) => {
+      scope.usesImports = true;
+
       const str = decl.arguments[0].value;
       return printStaticStr(str);
     },

package/compiler/precompile.js

@@ -251,7 +251,7 @@ params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.retu
 locals:${JSON.stringify(locals.slice(x.params.length).map(x => x[1].type))},localNames:${JSON.stringify(locals.map(x => x[0]))},
 ${usedTypes.length > 0 ? `usedTypes:${JSON.stringify(usedTypes)},` : ''}
 ${x.globalInits ? `globalInits:{${Object.keys(x.globalInits).map(y => `${y}:${rewriteWasm(x.globalInits[y])}`).join(',')}},` : ''}${x.data && Object.keys(x.data).length > 0 ? `data:${JSON.stringify(x.data)},` : ''}
-${x.table ? `table:1,` : ''}${x.constr ? `constr:1,` : ''}${x.hasRestArgument ? `hasRestArgument:1,` : ''}${x.usesTag ? `usesTag:1,` : ''}
+${x.table ? `table:1,` : ''}${x.constr ? `constr:1,` : ''}${x.hasRestArgument ? `hasRestArgument:1,` : ''}${x.usesTag ? `usesTag:1,` : ''}${x.usesImports ? `usesImports:1,` : ''}
 }`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll('\n\n', '\n');
 }).join('\n')}
 }`;

package/compiler/types.js

@@ -87,7 +87,7 @@ registerInternalType('RangeError');
 registerInternalType('EvalError');
 registerInternalType('URIError');
 registerInternalType('Test262Error');
-registerInternalType('__Porffor_TodoError');
+registerInternalType('TodoError');
 
 registerInternalType('__Porffor_Generator');
 registerInternalType('__Porffor_AsyncGenerator');

package/compiler/wasmSpec.js

@@ -226,8 +226,7 @@ export const Opcodes = {
 export const FuncType = 0x60;
 export const Empty = 0x00;
 
-export const Magic = [0x00, 0x61, 0x73, 0x6d];
-export const ModuleVersion = [0x01, 0x00, 0x00, 0x00];
+export const Magic = [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ];
 
 export const PageSize = 65536; // 64KiB (1024 * 8)
 

package/compiler/wrap.js

@@ -8,8 +8,6 @@ import './prefs.js';
 
 const fs = (typeof process?.version !== 'undefined' ? (await import('node:fs')) : undefined);
 
-const bold = x => `\u001b[1m${x}\u001b[0m`;
-
 const checkOOB = (memory, ptr) => ptr >= memory.buffer.byteLength;
 
 let dv;
@@ -315,7 +313,7 @@ ${flags & 0b0001 ? `    get func idx: ${get}
     case TYPES.evalerror:
     case TYPES.urierror:
     case TYPES.test262error:
-    case TYPES.__porffor_todoerror: {
+    case TYPES.todoerror: {
       const obj = porfToJSValue({ memory, funcs, pages }, value, TYPES.object);
       const err = new (globalThis[TYPE_NAMES[type]] ?? Error)(obj.message);
 
@@ -352,7 +350,7 @@ export default (source, module = undefined, customImports = {}, print = str => p
   // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
-  if (Prefs.profileCompiler && !globalThis.onProgress) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
+  if (Prefs.profileCompiler && !globalThis.onProgress) console.log(`\u001b[1mcompiled in ${times[0].toFixed(2)}ms\u001b[0m`);
 
   const printDecomp = (middleIndex, func, funcs, globals, exceptions) => {
     console.log(`\x1B[35m\x1B[1mporffor backtrace\u001b[0m`);

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.48.3",
+  "version": "0.48.5",
   "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.48.3';
+globalThis.version = '0.48.5';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -9,18 +9,6 @@ if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
 
 const start = performance.now();
 
-if (process.argv.includes('--compile-hints')) {
-  const v8 = await import('node:v8');
-  v8.setFlagsFromString(`--experimental-wasm-compilation-hints`);
-
-  // see also these flags:
-  // --experimental-wasm-branch-hinting
-  // --experimental-wasm-extended-const
-  // --experimental-wasm-inlining (?)
-  // --experimental-wasm-js-inlining (?)
-  // --experimental-wasm-return-call (on by default)
-}
-
 if (process.argv.includes('--help')) {
   // description + version
   console.log(`\x1B[1m\x1B[35mPorffor\x1B[0m is a JavaScript engine/runtime/compiler. \x1B[90m(${globalThis.version})\x1B[0m`);