porffor 0.16.0-e5b6b94c8 → 0.16.0-f9dde1759

package/compiler/decompile.js

@@ -4,6 +4,8 @@ import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from '.
 const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
 const invOpcodes = inv(Opcodes);
 const invValtype = inv(Valtype);
+globalThis.invOpcodes = invOpcodes;
+globalThis.invValtype = invValtype;
 
 export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = [], funcs = [], globals = {}, exceptions = []) => {
   const invLocals = inv(locals, x => x.idx);
@@ -91,7 +93,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       if (callFunc) out += ` ;; $${callFunc.name} ${makeSignature(callFunc.params, callFunc.returns)}`;
       if (globalThis.importFuncs && inst[1] < importFuncs.length) {
         const importFunc = importFuncs[inst[1]];
-        out += ` ;; import ${importFunc.name} ${makeSignature(new Array(importFunc.params).fill(valtypeBinary), new Array(importFunc.returns).fill(valtypeBinary),)}`;
+        out += ` ;; import ${importFunc.name} ${makeSignature(typeof importFunc.params === 'object' ? importFunc.params : new Array(importFunc.params).fill(valtypeBinary), new Array(importFunc.returns).fill(valtypeBinary),)}`;
       }
     }
 

package/compiler/generated_builtins.js

@@ -1748,7 +1748,7 @@ export const BuiltinFuncs = function() {
     localNames: ["iterable","iterable#type","out","type","forof_base_pointer","forof_length","forof_counter","x","x#type","#last_type","#typeswitch_tmp"],
   };
   this.__Set_prototype_union = {
-    wasm: (scope, {builtin,internalThrow,}) => [[32,2],[32,3],[16, builtin('__Porffor_rawType')],[68,0,0,0,0,0,0,52,64],[98],[4,64],...internalThrow(scope, 'TypeError', `Set.union requires 'Set'`),[11],[32,0],[65,20],[16, builtin('Set$constructor')],[33,4],[32,2],[252,3],[33,5],[65,0],[33,7],[32,5],[40,1,0],[33,6],[32,3],[33,11],[2,64],[32,11],[65,2],[70],[4,64,"TYPESWITCH|String"],[65,2],[33,9],[3,64],[65,0],[32,5],[47,0,4],[59,0,3],[68,0,0,0,0,0,0,240,191],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,2],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,16],[70],[4,64,"TYPESWITCH|Array"],[3,64],[32,5],[43,0,4],[32,5],[45,0,12],[33,9],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,9],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,18],[70],[4,64,"TYPESWITCH|ByteString"],[65,18],[33,9],[3,64],[65,0],[32,5],[32,7],[106],[45,0,4],[58,0,3],[68,0,0,0,0,0,0,240,191],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,20],[70],[4,64,"TYPESWITCH|Set"],[3,64],[32,5],[43,0,4],[32,5],[45,0,12],[33,9],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,9],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],...internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`),[11,"TYPESWITCH_end"],[32,4],[65,20],[15]],
+    wasm: (scope, {builtin,internalThrow,}) => [[32,2],[32,3],[16, builtin('__Porffor_rawType')],[68,0,0,0,0,0,0,52,64],[98],[4,64],...internalThrow(scope, 'TypeError', `Set.prototype.union's 'other' argument must be a Set`),[11],[32,0],[65,20],[16, builtin('Set$constructor')],[33,4],[32,2],[252,3],[33,5],[65,0],[33,7],[32,5],[40,1,0],[33,6],[32,3],[33,11],[2,64],[32,11],[65,2],[70],[4,64,"TYPESWITCH|String"],[65,2],[33,9],[3,64],[65,0],[32,5],[47,0,4],[59,0,3],[68,0,0,0,0,0,0,240,191],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,2],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,16],[70],[4,64,"TYPESWITCH|Array"],[3,64],[32,5],[43,0,4],[32,5],[45,0,12],[33,9],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,9],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,18],[70],[4,64,"TYPESWITCH|ByteString"],[65,18],[33,9],[3,64],[65,0],[32,5],[32,7],[106],[45,0,4],[58,0,3],[68,0,0,0,0,0,0,240,191],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,20],[70],[4,64,"TYPESWITCH|Set"],[3,64],[32,5],[43,0,4],[32,5],[45,0,12],[33,9],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,9],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],...internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`),[11,"TYPESWITCH_end"],[32,4],[65,20],[15]],
     params: [124,127,124,127],
     typedParams: true,
     returns: [124,127],

package/compiler/havoc.js

@@ -0,0 +1,93 @@
+// havoc: wasm rewrite library (it wreaks havoc upon wasm bytecode hence "havoc")
+import { Opcodes, Valtype } from './wasmSpec.js';
+
+export const localsToConsts = (func, targets, consts, { localKeys }) => {
+  const { wasm, locals } = func;
+
+  // update locals object
+  localKeys ??= Object.keys(locals).sort((a, b) => a.idx - b.idx);
+  for (const x of targets) {
+    delete locals[localKeys[x]];
+  }
+
+  const idxLut = {};
+  for (const x in locals) {
+    let i = locals[x].idx;
+    const o = i;
+    for (let j = 0; j < targets.length; j++) {
+      if (o > targets[j]) i--;
+    }
+
+    locals[x].idx = i;
+    idxLut[o] = i;
+  }
+
+  // update wasm
+  for (let i = 0; i < wasm.length; i++) {
+    const op = wasm[i];
+    const opcode = op[0];
+    const idx = op[1];
+
+    if (opcode >= 0x20 && opcode <= 0x22) { // local.* op
+      if (targets.includes(idx)) {
+        if (opcode === Opcodes.local_get || opcode === Opcodes.local_tee) {
+          // get/tee -> const
+          const c = consts[targets.indexOf(idx)];
+          wasm.splice(i, 1, c);
+          continue;
+        }
+
+        // set -> drop
+        wasm.splice(i, 1, [ Opcodes.drop ]);
+        continue;
+      }
+
+      // adjust index to compensate for removed
+      wasm[i] = [ opcode, idxLut[idx] ];
+    }
+  }
+};
+
+export const f64ToI32s = (func, targets) => {
+  const { wasm, locals } = func;
+
+  // update locals object
+  for (const x in locals) {
+    let i = locals[x].idx;
+    if (targets.includes(i)) {
+      locals[x].type = Valtype.i32;
+    }
+  }
+
+  // update wasm
+  for (let i = 0; i < wasm.length; i++) {
+    const op = wasm[i];
+    const opcode = op[0];
+    const idx = op[1];
+
+    if (opcode >= 0x20 && opcode <= 0x22 && targets.includes(idx)) { // local.* op
+      if (opcode === Opcodes.local_get) {
+        // add i32 -> f64 after
+        wasm.splice(i + 1, 0, Opcodes.i32_from);
+        continue;
+      }
+
+      if (opcode === Opcodes.local_set) {
+        // add f64 -> i32 before
+        wasm.splice(i, 0, Opcodes.i32_to);
+        i++;
+        continue;
+      }
+
+      if (opcode === Opcodes.local_tee) {
+        // add f64 -> i32 before
+        wasm.splice(i, 0, Opcodes.i32_to);
+        i++;
+
+        // add i32 -> f64 after
+        wasm.splice(i + 1, 0, Opcodes.i32_from);
+        continue;
+      }
+    }
+  }
+};

package/compiler/index.js

@@ -1,10 +1,13 @@
 import { underline, bold, log } from './log.js';
+import { Valtype, PageSize } from './wasmSpec.js';
 import parse from './parse.js';
 import codegen from './codegen.js';
 import opt from './opt.js';
 import assemble from './assemble.js';
 import decompile from './decompile.js';
 import toc from './2c.js';
+import * as pgo from './pgo.js';
+import cyclone from './cyclone.js';
 import Prefs from './prefs.js';
 
 globalThis.decompile = decompile;
@@ -13,6 +16,7 @@ const logFuncs = (funcs, globals, exceptions) => {
   console.log('\n' + underline(bold('funcs')));
 
   for (const f of funcs) {
+    if (f.internal) continue;
     console.log(decompile(f.wasm, f.name, f.index, f.locals, f.params, f.returns, funcs, globals, exceptions));
   }
 
@@ -23,6 +27,24 @@ const fs = (typeof process?.version !== 'undefined' ? (await import('node:fs'))
 const execSync = (typeof process?.version !== 'undefined' ? (await import('node:child_process')).execSync : undefined);
 
 export default (code, flags) => {
+  let target = Prefs.target ?? 'wasm';
+  if (Prefs.native) target = 'native';
+
+  let outFile = Prefs.o;
+
+  globalThis.valtype = 'f64';
+  const valtypeOpt = process.argv.find(x => x.startsWith('--valtype='));
+  if (valtypeOpt) valtype = valtypeOpt.split('=')[1];
+  globalThis.valtypeBinary = Valtype[valtype];
+
+  globalThis.pageSize = PageSize;
+  const pageSizeOpt = process.argv.find(x => x.startsWith('--page-size='));
+  if (pageSizeOpt) pageSize = parseInt(pageSizeOpt.split('=')[1]) * 1024;
+
+  // enable pgo by default for c/native
+  if (target !== 'wasm') Prefs.pgo = Prefs.pgo === false ? false : true;
+  if (Prefs.pgo) pgo.setup();
+
   const t0 = performance.now();
   const program = parse(code, flags);
   if (Prefs.profileCompiler) console.log(`1. parsed in ${(performance.now() - t0).toFixed(2)}ms`);
@@ -35,9 +57,49 @@ export default (code, flags) => {
 
   const t2 = performance.now();
   opt(funcs, globals, pages, tags, exceptions);
-  if (Prefs.profileCompiler) console.log(`3. optimized in ${(performance.now() - t2).toFixed(2)}ms`);
 
-  // if (Prefs.optFuncs) logFuncs(funcs, globals, exceptions);
+  if (Prefs.pgo) {
+    if (Prefs.pgoLog) {
+      const oldSize = assemble(funcs, globals, tags, pages, data, flags, true).byteLength;
+      const t = performance.now();
+
+      pgo.run({ funcs, globals, tags, exceptions, pages, data });
+      opt(funcs, globals, pages, tags, exceptions);
+
+      console.log(`PGO total time: ${(performance.now() - t).toFixed(2)}ms`);
+
+      const newSize = assemble(funcs, globals, tags, pages, data, flags, true).byteLength;
+      console.log(`PGO size diff: ${oldSize - newSize} bytes (${oldSize} -> ${newSize})\n`);
+    } else {
+      pgo.run({ funcs, globals, tags, exceptions, pages, data });
+      opt(funcs, globals, pages, tags, exceptions);
+    }
+  }
+
+  if (Prefs.cyclone) {
+    if (Prefs.cycloneLog) {
+      const oldSize = assemble(funcs, globals, tags, pages, data, flags, true).byteLength;
+      const t = performance.now();
+
+      for (const x of funcs) {
+        const preOps = x.wasm.length;
+        cyclone(x.wasm);
+
+        console.log(`${x.name}: ${preOps} -> ${x.wasm.length} ops`);
+      }
+
+      console.log(`cyclone total time: ${(performance.now() - t).toFixed(2)}ms`);
+
+      const newSize = assemble(funcs, globals, tags, pages, data, flags, true).byteLength;
+      console.log(`cyclone size diff: ${oldSize - newSize} bytes (${oldSize} -> ${newSize})\n`);
+    } else {
+      for (const x of funcs) {
+        cyclone(x.wasm);
+      }
+    }
+  }
+
+  if (Prefs.profileCompiler) console.log(`3. optimized in ${(performance.now() - t2).toFixed(2)}ms`);
 
   const t3 = performance.now();
   const wasm = assemble(funcs, globals, tags, pages, data, flags);
@@ -54,9 +116,6 @@ export default (code, flags) => {
 
   const out = { wasm, funcs, globals, tags, exceptions, pages, data };
 
-  const target = Prefs.target ?? 'wasm';
-  const outFile = Prefs.o;
-
   if (target === 'wasm' && outFile) {
     fs.writeFileSync(outFile, Buffer.from(wasm));
 
@@ -77,6 +136,8 @@ export default (code, flags) => {
   }
 
   if (target === 'native') {
+    outFile ??= Prefs.native ? './porffor_tmp' : file.split('/').at(-1).split('.').at(0, -1).join('.');
+
     let compiler = Prefs.compiler ?? 'clang';
     const cO = Prefs._cO ?? 'Ofast';
 
@@ -95,7 +156,29 @@ export default (code, flags) => {
 
     fs.unlinkSync(tmpfile);
 
-    if (process.version) process.exit();
+    if (process.version) {
+      if (Prefs.native) {
+        const cleanup = () => {
+          try {
+            fs.unlinkSync(outFile);
+          } catch {}
+        };
+
+        process.on('exit', cleanup);
+        process.on('beforeExit', cleanup);
+        process.on('SIGINT', () => {
+          cleanup();
+          process.exit();
+        });
+
+        const runArgs = process.argv.slice(2).filter(x => !x.startsWith('-'));
+        try {
+          execSync([ outFile, ...runArgs.slice(1) ].join(' '), { stdio: 'inherit' });
+        } catch {}
+      }
+
+      process.exit();
+    }
   }
 
   return out;

package/compiler/opt.js

@@ -108,7 +108,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
   for (const f of funcs) {
     const wasm = f.wasm;
 
-    const lastType = f.locals['#last_type'];
+    const lastType = f.locals['#last_type']?.idx;
 
     let runs = (+Prefs.optWasmRuns) || 2; // todo: how many by default?
     while (runs > 0) {
@@ -248,7 +248,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
         }
 
         // remove setting last type if it is never gotten
-        if (!f.gotLastType && inst[0] === Opcodes.local_set && inst[1] === lastType?.idx) {
+        if (!f.gotLastType && inst[0] === Opcodes.local_set && inst[1] === lastType) {
           // replace this inst with drop
           wasm.splice(i, 1, [ Opcodes.drop ]); // remove this and last inst
           if (i > 0) i--;
@@ -354,7 +354,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           continue;
         }
 
-        if (lastInst[0] === Opcodes.const && (inst === Opcodes.i32_to || inst === Opcodes.i32_to_u)) {
+        if (lastInst[0] === Opcodes.const && inst[0] === Opcodes.i32_to[0] && (inst[1] === Opcodes.i32_to[1] || inst[1] === Opcodes.i32_to_u[1])) {
           // change const and immediate i32 convert to i32 const
           // f64.const 0
           // i32.trunc_sat_f64_s || i32.trunc_sat_f64_u
@@ -504,42 +504,6 @@ export default (funcs, globals, pages, tags, exceptions) => {
       const useCount = {};
       for (const x in f.locals) useCount[f.locals[x].idx] = 0;
 
-      // final pass
-      depth = [];
-      for (let i = 0; i < wasm.length; i++) {
-        let inst = wasm[i];
-        if (inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) useCount[inst[1]]++;
-
-        if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block) depth.push(inst[0]);
-        if (inst[0] === Opcodes.end) depth.pop();
-
-        if (i < 2) continue;
-        const lastInst = wasm[i - 1];
-        const lastLastInst = wasm[i - 2];
-
-        // todo: add more math ops
-        if (optLevel >= 3 && (inst[0] === Opcodes.add || inst[0] === Opcodes.sub || inst[0] === Opcodes.mul) && lastLastInst[0] === Opcodes.const && lastInst[0] === Opcodes.const) {
-          // inline const math ops
-          // i32.const a
-          // i32.const b
-          // i32.add
-          // -->
-          // i32.const a + b
-
-          // does not work with leb encoded
-          if (lastInst.length > 2 || lastLastInst.length > 2) continue;
-
-          let a = lastLastInst[1];
-          let b = lastInst[1];
-
-          const val = performWasmOp(inst[0], a, b);
-          if (Prefs.optLog) log('opt', `inlined math op (${a} ${inst[0].toString(16)} ${b} -> ${val})`);
-
-          wasm.splice(i - 2, 3, ...number(val)); // remove consts, math op and add new const
-          i -= 2;
-        }
-      }
-
       const localIdxs = Object.values(f.locals).map(x => x.idx);
       // remove unused locals (cleanup)
       for (const x in useCount) {

package/compiler/parse.js

@@ -10,7 +10,7 @@ if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
 const file = process.argv.slice(2).find(x => x[0] !== '-' && !['run', 'wasm', 'native', 'c', 'profile', 'debug', 'debug-wasm'].includes(x));
 
 // should we try to support types (while parsing)
-const types = Prefs.parseTypes || file?.endsWith('.ts');
+const types = Prefs.parseTypes || Prefs.t || file?.endsWith('.ts');
 globalThis.typedInput = types && Prefs.optTypes;
 
 // todo: review which to use by default
@@ -43,7 +43,7 @@ export default (input, flags) => {
       webcompat: true,
 
       // babel
-      plugins: types ? ['estree', 'typescript'] : ['estree'],
+      plugins: types || flags.includes('typed') ? ['estree', 'typescript'] : ['estree'],
 
       // multiple
       sourceType: flags.includes('module') ? 'module' : 'script',

package/compiler/pgo.js

@@ -0,0 +1,207 @@
+import { Opcodes, Valtype } from './wasmSpec.js';
+import { number } from './embedding.js';
+import { importedFuncs } from './builtins.js';
+import Prefs from './prefs.js';
+import assemble from './assemble.js';
+import wrap, { writeByteStr } from './wrap.js';
+import * as Havoc from './havoc.js';
+
+export const setup = () => {
+  importedFuncs[importedFuncs.profile2].params = [ Valtype.i32, valtypeBinary ];
+
+  // enable these prefs by default for pgo
+  Prefs.typeswitchUniqueTmp = Prefs.typeswitchUniqueTmp === false ? false : true;
+  Prefs.cyclone = Prefs.cyclone === false ? false : true;
+};
+
+export const run = obj => {
+  const wasmFuncs = obj.funcs;
+
+  let starts = {};
+  const time = (id, msg) => {
+    if (!Prefs.pgoLog) return;
+
+    if (!starts[id]) {
+      process.stdout.write(msg);
+      starts[id] = performance.now();
+    } else {
+      process.stdout.write(`\r${' '.repeat(50)}\r[${(performance.now() - starts[id]).toFixed(2)}ms] ${msg}\n`);
+    }
+  };
+
+  time(0, `injecting PGO logging...`);
+
+  let funcs = [];
+  for (let i = 0; i < wasmFuncs.length; i++) {
+    const { name, internal, params, locals, wasm } = wasmFuncs[i];
+    if (internal) continue; // ignore internal funcs
+    wasmFuncs[i].originalWasm = structuredClone(wasm);
+
+    const invLocals = Object.keys(locals).reduce((acc, x) => { acc[locals[x].idx] = locals[x]; return acc; }, {});
+
+    const id = funcs.length;
+    funcs.push({ name, id, locals, params, invLocals });
+
+    wasm.unshift(
+      // mark active func
+      ...number(i, Valtype.i32),
+      [ Opcodes.call, importedFuncs.profile1 ],
+
+      // log args
+      ...params.flatMap((_, i) => [
+        ...number(i, Valtype.i32),
+        [ Opcodes.local_get, i ],
+        ...(invLocals[i].type !== Valtype.f64 ? [ Opcodes.i32_from ] : []),
+        [ Opcodes.call, importedFuncs.profile2 ]
+      ])
+    );
+
+    for (let j = 0; j < wasm.length; j++) {
+      const inst = wasm[j];
+      if (inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) {
+        wasm.splice(j + 1, 0,
+          ...number(inst[1], Valtype.i32),
+          [ Opcodes.local_get, inst[1] ],
+          ...(invLocals[inst[1]].type !== Valtype.f64 ? [ Opcodes.i32_from ] : []),
+          [ Opcodes.call, importedFuncs.profile2 ]
+        );
+      }
+    }
+  }
+
+  let localData = funcs.map(x => new Array(Object.keys(x.locals).length).fill(0).map(() => []));
+
+  time(0, `injected PGO logging`);
+  time(1, `running with PGO logging...`);
+
+  let activeFunc = null, abort = false;
+  try {
+    obj.wasm = assemble(obj.funcs, obj.globals, obj.tags, obj.pages, obj.data, obj.flags, true);
+
+    const { exports } = wrap(obj, [], {
+      y: n => {
+        activeFunc = n;
+      },
+      z: (i, n) => {
+        if (activeFunc == null) throw 'fail';
+        localData[activeFunc][i].push(n);
+      },
+      w: (ind, outPtr) => { // readArgv
+        const pgoInd = process.argv.indexOf('--pgo');
+        const args = process.argv.slice(pgoInd).filter(x => !x.startsWith('-'));
+        const str = args[ind - 1];
+        if (pgoInd === -1 || !str) {
+          if (Prefs.pgoLog) console.log('\nPGO warning: script was expecting arguments, please specify args to use for PGO after --pgo arg');
+          return -1;
+        }
+
+        writeByteStr(exports.$, outPtr, str);
+        return str.length;
+      }
+    }, () => {});
+
+    exports.main();
+  } catch (e) {
+    throw e;
+  }
+
+  for (const x of funcs) {
+    const wasmFunc = wasmFuncs.find(y => y.name === x.name);
+    wasmFunc.wasm = wasmFunc.originalWasm;
+    delete wasmFunc.originalWasm;
+  }
+
+  if (abort) {
+    console.log('aborting PGO!');
+    return false;
+  }
+
+  time(1, `ran with PGO logging`);
+  time(2, 'processing PGO data...');
+
+  // process data
+  let log = '';
+  for (let i = 0; i < localData.length; i++) {
+    const func = funcs[i];
+    const total = localData[i].length;
+
+    const localKeys = Object.keys(func.locals).sort((a, b) => a.idx - b.idx);
+    const localValues = Object.values(func.locals).sort((a, b) => a.idx - b.idx);
+    func.localKeys = localKeys;
+    func.localValues = localValues;
+
+    let counts = new Array(10).fill(0);
+    const consistents = localData[i].map((x, j) => {
+      if (j < func.params.length) return false; // param
+      if (x.length === 0 || !x.every((y, i) => i < 1 ? true : y === x[i - 1])) return false; // not consistent
+
+      counts[0]++;
+      return x[0];
+    });
+
+    const integerOnlyF64s = localData[i].map((x, j) => {
+      if (j < func.params.length) return false; // param
+      if (localValues[j].type === Valtype.i32) return false; // already i32
+      if (x.length === 0 || !x.every(y => Number.isInteger(y))) return false; // not all integer values
+
+      counts[1]++;
+      return true;
+    });
+
+    func.consistents = consistents;
+    func.integerOnlyF64s = integerOnlyF64s;
+
+    log += `  ${func.name}: identified ${counts[0]}/${total} locals as consistent${Prefs.verbosePgo ? ':' : ''}\n`;
+    if (Prefs.verbosePgo) {
+      for (let j = func.params.length; j < localData[i].length; j++) {
+        log += `    ${consistents[j] !== false ? '\u001b[92m' : '\u001b[91m'}${localKeys[j]}\u001b[0m: ${new Set(localData[i][j]).size} unique values set\n`;
+      }
+    }
+
+    log += `  ${func.name}: identified ${counts[1]}/${localValues.reduce((acc, x) => acc + (x.type === Valtype.f64 ? 1 : 0), 0)} f64 locals as integer usage only${Prefs.verbosePgo ? ':' : ''}\n`;
+    if (Prefs.verbosePgo) {
+      for (let j = func.params.length; j < localData[i].length; j++) {
+        if (localValues[j].type !== Valtype.f64) continue;
+        log += `    ${integerOnlyF64s[j] ? '\u001b[92m' : '\u001b[91m'}${localKeys[j]}\u001b[0m\n`;
+      }
+
+      log += '\n';
+    }
+  }
+
+  time(2, 'processed PGO data' + log);
+  time(3, 'optimizing using PGO data...');
+
+  log = '';
+  for (const x of funcs) {
+    const wasmFunc = wasmFuncs.find(y => y.name === x.name);
+
+    let targets = [];
+    for (let i = 0; i < x.integerOnlyF64s.length; i++) {
+      const c = x.integerOnlyF64s[i];
+      if (c === false) continue;
+
+      targets.push(i);
+    }
+
+    log += `  ${x.name}: replaced ${targets.length} f64 locals with i32s\n`;
+    if (targets.length > 0) Havoc.f64ToI32s(wasmFunc, targets);
+
+    targets = [];
+    let consts = [];
+    for (let i = 0; i < x.consistents.length; i++) {
+      const c = x.consistents[i];
+      if (c === false) continue;
+
+      targets.push(i);
+
+      const valtype = x.localValues[i].type;
+      consts.push(number(c, valtype)[0]);
+    }
+
+    log += `  ${x.name}: replaced ${targets.length} locals with consts\n`;
+    if (targets.length > 0) Havoc.localsToConsts(wasmFunc, targets, consts, { localKeys: x.localKeys });
+  }
+
+  time(3, 'optimized using PGO data' + log);
+};

package/compiler/precompile.js

@@ -26,7 +26,7 @@ const compile = async (file, [ _funcs, _globals ]) => {
 
   const porfCompile = (await import(`./index.js?_=${Date.now()}`)).default;
 
-  let { funcs, globals, data, exceptions } = porfCompile(source, ['module']);
+  let { funcs, globals, data, exceptions } = porfCompile(source, ['module', 'typed']);
 
   const allocated = new Set();
 
@@ -87,6 +87,8 @@ const compile = async (file, [ _funcs, _globals ]) => {
 };
 
 const precompile = async () => {
+  if (globalThis._porf_loadParser) await globalThis._porf_loadParser('@babel/parser');
+
   const dir = join(__dirname, 'builtins');
 
   let funcs = [], globals = [];

package/compiler/prefs.js

@@ -23,9 +23,14 @@ const obj = new Proxy({}, {
     // do not cache in web demo as args are changed live
     if (!globalThis.document) cache[p] = ret;
     return ret;
+  },
+
+  set(_, p, v) {
+    cache[p] = v;
+    return true;
   }
 });
 
-obj.uncache = () => cache = {};
+export const uncache = () => cache = {};
 
 export default obj;