porffor 0.25.2 → 0.25.4

package/compiler/codegen.js

@@ -333,7 +333,10 @@ 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 number(funcIndex[name] - importedFuncs.length);
+      if (Object.hasOwn(funcIndex, name)) {
+        if (globalThis.precompile) return [ [ Opcodes.const, 'funcref', name ] ];
+        return number(funcIndex[name] - importedFuncs.length);
+      }
     }
 
     if (local?.idx === undefined && rawName.startsWith('__')) {
@@ -845,6 +848,11 @@ const nullish = (scope, wasm, type, intIn = false, intOut = false) => {
     ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
+      [TYPES.empty]: [
+        // empty
+        ...(!useTmp ? [ [ Opcodes.drop ] ] : []),
+        ...number(1, intOut ? Valtype.i32 : valtypeBinary)
+      ],
       [TYPES.undefined]: [
         // undefined
         ...(!useTmp ? [ [ Opcodes.drop ] ] : []),
@@ -1190,7 +1198,7 @@ const asmFuncToAsm = (scope, func) => {
   return func(scope, {
     TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage, internalThrow,
     getNodeType, generate, generateIdent,
-    builtin: n => {
+    builtin: (n, float = false, offset = false) => {
       let idx = funcIndex[n] ?? importedFuncs[n];
       if (idx == null && builtinFuncs[n]) {
         includeBuiltin(null, n);
@@ -1198,7 +1206,9 @@ const asmFuncToAsm = (scope, func) => {
       }
 
       if (idx == null) throw new Error(`builtin('${n}') failed to find a func (inside ${scope.name})`);
-      return unsignedLEB128(idx);
+      if (offset) idx -= importedFuncs.length;
+
+      return float ? ieee754_binary64(idx) : unsignedLEB128(idx);
     },
     glbl: (opcode, name, type) => {
       const globalName = '#porf#' + name; // avoid potential name clashing with user js
@@ -2352,6 +2362,23 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
               ...internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`),
             [ Opcodes.end ],
 
+            // [ Opcodes.local_get, funcLocal ],
+            // Opcodes.i32_from_u,
+            // [ Opcodes.call, 0 ],
+
+            // ...number(32),
+            // [ Opcodes.call, 1 ],
+
+            // [ Opcodes.local_get, funcLocal ],
+            // ...number(128, Valtype.i32),
+            // [ Opcodes.i32_mul ],
+            // [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ],
+            // Opcodes.i32_from_u,
+            // [ Opcodes.call, 0 ],
+
+            // ...number(10),
+            // [ Opcodes.call, 1 ],
+
             ...brTable([
               // get argc of func we are calling
               [ Opcodes.local_get, funcLocal ],
@@ -5228,11 +5255,53 @@ const generateFunc = (scope, decl) => {
 
   const wasm = func.wasm = prelude.concat(generate(func, body));
 
-  if (name === 'main') func.gotLastType = true;
+  if (name === 'main') {
+    func.gotLastType = true;
+
+    func.export = true;
+    func.returns = [ valtypeBinary, Valtype.i32 ];
+
+    const lastInst = func.wasm[func.wasm.length - 1] ?? [ Opcodes.end ];
+    if (lastInst[0] === Opcodes.drop) {
+      func.wasm.splice(func.wasm.length - 1, 1);
+
+      const finalStatement = decl.body.body[decl.body.body.length - 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(main.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 = [];
+    }
 
-  // add end return if not found
-  if (name !== 'main' && wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
-    wasm.push(...generateReturn(func, {}));
+    // inject promise job runner func at the end of main if used
+    if (Object.hasOwn(funcIndex, 'Promise')) {
+      wasm.push(
+        ...generateCall(func, {
+          callee: {
+            type: 'Identifier',
+            name: '__Porffor_promise_runJobs'
+          },
+          arguments: []
+        }).slice(0, -1), // remove set last type
+        [ 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, {}));
+    }
   }
 
   if (func.constr) {
@@ -5483,31 +5552,6 @@ export default program => {
 
   const main = generateFunc(scope, program);
 
-  main.export = true;
-  main.returns = [ valtypeBinary, Valtype.i32 ];
-
-  const lastInst = main.wasm[main.wasm.length - 1] ?? [ Opcodes.end ];
-  if (lastInst[0] === Opcodes.drop) {
-    main.wasm.splice(main.wasm.length - 1, 1);
-
-    const finalStatement = program.body.body[program.body.body.length - 1];
-    main.wasm.push(...getNodeType(main, finalStatement));
-  }
-
-  if (lastInst[0] === Opcodes.end || lastInst[0] === Opcodes.local_set || lastInst[0] === Opcodes.global_set) {
-    if (lastInst[0] === Opcodes.local_set && lastInst[1] === main.locals['#last_type'].idx) {
-      main.wasm.splice(main.wasm.length - 1, 1);
-    } else {
-      main.returns = [];
-    }
-  }
-
-  if (lastInst[0] === Opcodes.call) {
-    const func = funcs.find(x => x.index === lastInst[1]);
-    if (func) main.returns = func.returns.slice();
-      else main.returns = [];
-  }
-
   delete globals['#ind'];
 
   // if blank main func and other exports, remove it

package/compiler/decompile.js

@@ -11,17 +11,26 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
   const invLocals = inv(locals, x => x.idx);
   const invGlobals = inv(globals, x => x.idx);
 
-  const makeSignature = (params, returns) => `(${params.map(x => invValtype[x]).join(', ')}) -> (${returns.map(x => invValtype[x]).join(', ')})`;
+  const makeSignature = (params, returns, locals) => {
+    if (locals) {
+      const localNames = inv(locals, x => x.idx);
+      return `(${params.map((x, i) => `${localNames[i]}(${i}): ${invValtype[x]}`).join(', ')}) -> (${returns.map(x => invValtype[x]).join(', ')})`;
+    }
+
+    return `(${params.map((x, i) => invValtype[x]).join(', ')}) -> (${returns.map(x => invValtype[x]).join(', ')})`;
+  }
 
-  let out = '', depth = name ? 1 : 0;
-  if (name) out += `${makeSignature(params, returns)} ;; $${name} (${ind})\n`;
+  let out = '', depth = 0;
+  if (name) out += `${name}(${ind}) ${makeSignature(params, returns, locals)}\n`;
 
   const justLocals = Object.values(locals).sort((a, b) => a.idx - b.idx).slice(params.length);
-  if (name && justLocals.length > 0) out += `  local ${justLocals.map(x => invValtype[x.type]).join(' ')}\n`;
+  for (const x of justLocals) {
+    out += `;; local ${invLocals[x.idx]}(${x.idx}): ${invValtype[x.type]}\n`
+  }
 
   let i = -1, lastInst;
   let byte = 0;
-  for (let inst of wasm.concat(name ? [ [ Opcodes.end ] ] : [])) {
+  for (let inst of wasm) {
     i++;
     if (inst[0] === null) continue;
 
@@ -102,6 +111,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       const name = invLocals[inst[1]];
       const type = invValtype[locals[name]?.type];
       if (name) out += ` ;; $${name}${type !== valtype ? ` (${type})` : ''}`;
+        else out += ` ;; unknown local`
     }
 
     if (inst[0] === Opcodes.global_get || inst[0] === Opcodes.global_set) {
@@ -130,4 +140,4 @@ export const highlightAsm = asm => asm
   .replace(/(block|loop|if|end|else|try|catch_all|catch|delegate)/g, _ => `\x1B[95m${_}\x1B[0m`)
   .replace(/unreachable/g, _ => `\x1B[91m${_}\x1B[0m`)
   .replace(/ \-?[0-9\.]+/g, _ => ` \x1B[33m${_.slice(1)}\x1B[0m`)
-  .replace(/ ;;.*$/gm, _ => `\x1B[90m${_.replaceAll(/\x1B\[[0-9]+m/g, '')}\x1B[0m`);
+  .replace(/;;.*$/gm, _ => `\x1B[90m${_.replaceAll(/\x1B\[[0-9]+m/g, '')}\x1B[0m`);

package/compiler/opt.js

@@ -347,7 +347,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           continue;
         }
 
-        if (lastInst[0] === Opcodes.i32_const && (inst[0] === Opcodes.i32_from[0] || inst[0] === Opcodes.i32_from_u[0])) {
+        if (lastInst[0] === Opcodes.i32_const && (inst[0] === Opcodes.i32_from[0] || inst[0] === Opcodes.i32_from_u[0]) && (typeof lastInst[1] !== 'string')) {
           // change i32 const and immediate convert to const (opposite way of previous)
           // i32.const 0
           // f64.convert_i32_s || f64.convert_i32_u

package/compiler/precompile.js

@@ -191,7 +191,7 @@ const precompile = async () => {
   }
 
   const total = performance.now() - t;
-  console.log(`\r${' '.repeat(100)}\r\u001b[90m${`[${total.toFixed(2)}ms]`.padEnd(12, ' ')}\u001b[0m\u001b[92mcompiled ${fileCount} files (${funcs.length} funcs)\u001b[0m \u001b[90m(${['parse', 'codegen', 'opt'].map(x => `${x}: ${((timing[x] / total) * 100).toFixed(2)}%`).join(', ')})\u001b[0m`);
+  console.log(`\r${' '.repeat(100)}\r\u001b[90m${`[${total.toFixed(2)}ms]`.padEnd(12, ' ')}\u001b[0m\u001b[92mcompiled ${fileCount} files (${funcs.length} funcs)\u001b[0m \u001b[90m(${['parse', 'codegen', 'opt'].map(x => `${x}: ${((timing[x] / total) * 100).toFixed(0)}%`).join(', ')})\u001b[0m`);
 
   return `// autogenerated by compiler/precompile.js
 import { number } from './embedding.js';
@@ -204,6 +204,7 @@ ${funcs.map(x => {
       .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}', true, true)]`)
       .replace(/\["throw","(.*?)","(.*?)"\]/g, (_, constructor, message) => `...internalThrow(scope, '${constructor}', \`${message}\`)`)
       .replace(/\["get object","(.*?)"\]/g, (_, objName) => `...generateIdent(scope, { name: '${objName}' })`);
 

package/compiler/types.js

@@ -72,6 +72,8 @@ registerInternalType('WeakRef');
 registerInternalType('WeakSet');
 registerInternalType('WeakMap');
 
+registerInternalType('Promise');
+
 if (Prefs.largestTypes) {
   const typeKeys = Object.keys(TYPES);
   const typeVals = Object.values(TYPES);

package/compiler/wrap.js

@@ -35,7 +35,7 @@ export const writeByteStr = (memory, ptr, str) => {
   }
 };
 
-const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
+const porfToJSValue = ({ memory, funcs, pages }, value, type, override = undefined) => {
   switch (type) {
     case TYPES.empty:
     case TYPES.undefined:
@@ -138,7 +138,8 @@ ${flags & 0b0001 ? `    get func idx: ${get}
     }
 
     case TYPES.array: {
-      const length = read(Uint32Array, memory, value, 1)[0];
+      let length = read(Uint32Array, memory, value, 1)[0];
+      if (override) length = override;
 
       const out = [];
       for (let i = 0; i < length; i++) {
@@ -258,6 +259,30 @@ ${flags & 0b0001 ? `    get func idx: ${get}
       return out;
     }
 
+    case TYPES.promise: {
+      const [ result, _state, fulfillReactions, rejectReactions ] = porfToJSValue({ memory, funcs, pages }, value, TYPES.array, 4);
+
+      const state = ({
+        0: 'pending',
+        1: 'fulfilled',
+        2: 'rejected'
+      })[_state];
+      const stateColor = ({
+        0: '\x1B[93m',
+        1: '\x1B[32m',
+        2: '\x1B[31m'
+      })[_state];
+
+      const out = { state, result };
+      Object.defineProperty(out, Symbol.for('nodejs.util.inspect.custom'), {
+        value(depth, opts, inspect) {
+          return `${opts.colors ? '\x1B[36m' : ''}Promise${opts.colors ? '\x1B[0m' : ''} (state: ${opts.colors ? stateColor : ''}<${state}>${opts.colors ? '\x1B[0m' : ''}, result: ${inspect(result, opts)})`;
+        }
+      });
+
+      return out;
+    }
+
     default: return value;
   }
 };
@@ -280,10 +305,6 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
   const printDecomp = (middleIndex, func, funcs, globals, exceptions) => {
     console.log(`\x1B[35m\x1B[1mporffor backtrace\u001b[0m`);
 
-    const strParams = func.params.map(v => invValtype[v]);
-    const strReturns = func.returns.map(v => invValtype[v]);
-    console.log(`\x1B[1m${func.name}\x1B[0m \x1B[90m(${strParams.join(', ')}) -> (${strReturns.join(', ')})\x1B[0m`);
-
     const surrounding = Prefs.backtraceSurrounding ?? 5;
     let min = middleIndex - surrounding;
     let max = middleIndex + surrounding + 1;
@@ -292,7 +313,7 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
       max = func.wasm.length;
     }
 
-    const decomp = decompile(func.wasm.slice(min, max), '', 0, func.locals, func.params, func.returns, funcs, globals, exceptions).slice(0, -1).split('\n');
+    const decomp = decompile(func.wasm.slice(min, max), func.name, 0, func.locals, func.params, func.returns, funcs, globals, exceptions).slice(0, -1).split('\n');
 
     const noAnsi = s => s.replace(/\u001b\[[0-9]+m/g, '');
     let longest = 0;

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.25.2+bd0735a02",
+  "version": "0.25.4+3aca9688e",
   "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.25.2+bd0735a02';
+globalThis.version = '0.25.4+3aca9688e';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -108,7 +108,33 @@ if (['precompile', 'run', 'wasm', 'native', 'c', 'profile', 'debug', 'debug-wasm
 
 globalThis.file = file;
 
-if (!file) {
+let source = '', printOutput = false;
+if (process.argv.length >= 4) {
+  let evalIndex = process.argv.indexOf('-e');
+  if (evalIndex === -1) evalIndex = process.argv.indexOf('--eval');
+  if (evalIndex !== -1) {
+    source = process.argv[evalIndex + 1];
+    if (source) {
+      if (source.startsWith('"') || source.startsWith("'")) source = source.slice(1, -1);
+      process.argv.splice(evalIndex, 2); // remove flag and value
+    }
+  }
+
+  let printIndex = process.argv.indexOf('-p');
+  if (printIndex === -1) printIndex = process.argv.indexOf('--print');
+  if (printIndex !== -1) {
+    process.argv.push('--no-opt-unused');
+    source = process.argv[printIndex + 1];
+    if (source) {
+      if (source.startsWith('"') || source.startsWith("'")) source = source.slice(1, -1);
+      process.argv.splice(printIndex, 2); // remove flag and value
+    }
+
+    printOutput = true;
+  }
+}
+
+if (!file && !source) {
   if (process.argv.includes('-v') || process.argv.includes('--version')) {
     // just print version
     console.log(globalThis.version);
@@ -120,7 +146,7 @@ if (!file) {
   await done();
 }
 
-const source = fs.readFileSync(file, 'utf8');
+source ||= fs.readFileSync(file, 'utf8');
 
 const compile = (await import('../compiler/wrap.js')).default;
 
@@ -137,19 +163,20 @@ const print = str => {
 };
 
 let runStart;
+let ret;
 try {
   if (process.argv.includes('-b')) {
     const { wasm, exports } = compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
 
     runStart = performance.now();
-    if (!process.argv.includes('--no-run')) exports.main();
+    if (!process.argv.includes('--no-run')) ret = exports.main();
 
     console.log(`\n\nwasm size: ${wasm.byteLength} bytes`);
   } else {
     const { exports } = compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
 
     runStart = performance.now();
-    if (!process.argv.includes('--no-run')) exports.main();
+    if (!process.argv.includes('--no-run')) ret = exports.main();
   }
   // if (cache) process.stdout.write(cache);
 } catch (e) {
@@ -159,4 +186,12 @@ try {
   console.error(out);
 }
 
-if (process.argv.includes('-t')) console.log(`${process.argv.includes('-b') ? '' : '\n\n'}total time: ${(performance.now() - start).toFixed(2)}ms\nexecution time: ${(performance.now() - runStart).toFixed(2)}ms`);
+if (process.argv.includes('-t')) console.log(`${process.argv.includes('-b') ? '' : '\n\n'}total time: ${(performance.now() - start).toFixed(2)}ms\nexecution time: ${(performance.now() - runStart).toFixed(2)}ms`);
+
+if (printOutput) {
+  if (process.argv.includes('-d') && ret?.type != null) {
+    ret = ret.js;
+  }
+
+  console.log(ret);
+}