porffor 0.1.0

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "porffor",
+  "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
+  "version": "0.1.0",
+  "author": "CanadaHonk",
+  "license": "MIT",
+  "dependencies": {
+    "acorn": "^8.9.0"
+  },
+  "bin": {
+    "porf": "./runner/index.js"
+  },
+  "main": "./runner/index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CanadaHonk/porffor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/CanadaHonk/porffor/issues"
+  },
+  "homepage": "https://porffor.goose.icu"
+}

package/porf.cmd

@@ -0,0 +1,2 @@
+@echo off
+node runner %*

package/runner/compare.js

@@ -0,0 +1,35 @@
+import { execSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+import fs from 'node:fs';
+
+const [ commitsAgo, file ] = process.argv.slice(2);
+const source = fs.readFileSync(file, 'utf8');
+
+const compileNow = (await import('../compiler/index.js')).default;
+const wasmNow = compileNow(source).byteLength;
+
+execSync(`git checkout HEAD~${commitsAgo}`);
+
+let failed = false;
+
+fs.writeFileSync('tmp.js', source);
+try {
+  execSync(`node runner/index.js tmp.js`);
+} catch {
+  failed = true;
+} finally {
+  fs.rmSync('tmp.js');
+  execSync(`git checkout main`);
+}
+
+console.log();
+
+if (failed) {
+  console.log(`!! failed to compile then`);
+  process.exit();
+}
+
+const wasmThen = Buffer.byteLength(fs.readFileSync('out.wasm'));
+
+console.log(`now: ${wasmNow} bytes`);
+console.log(`${commitsAgo} commit${commitsAgo > 1 ? 's' : ''} ago: ${wasmThen} bytes`);

package/runner/index.js

@@ -0,0 +1,32 @@
+import compile from '../compiler/wrap.js';
+import fs from 'node:fs';
+
+const file = process.argv.slice(2).find(x => x[0] !== '-');
+if (!file) {
+  // run repl if no file given
+  await import('./repl.js');
+
+  // do nothing for the rest of this file
+  await new Promise(() => {});
+}
+
+const source = fs.readFileSync(file, 'utf8');
+
+let cache = '';
+const print = str => {
+  cache += str;
+
+  if (str === '\n') {
+    process.stdout.write(cache);
+    cache = '';
+  }
+};
+
+try {
+  const { exports } = await compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
+
+  exports.main();
+  if (cache) process.stdout.write(cache);
+} catch (e) {
+  console.error(`${e.constructor.name}: ${e.message}`);
+}

package/runner/info.js

@@ -0,0 +1,54 @@
+import compile from '../compiler/wrap.js';
+import fs from 'node:fs';
+
+/* if (globalThis.process) {
+  const v8 = await import('node:v8');
+  v8.setFlagsFromString('--experimental-wasm-gc');
+} */
+
+const raw = process.argv.includes('-raw');
+
+const file = process.argv.slice(2).find(x => x[0] !== '-');
+if (!file) {
+  // run repl if no file given
+  await import('./repl.js');
+
+  // do nothing for the rest of this file
+  await new Promise(() => {});
+}
+
+const source = fs.readFileSync(file, 'utf8');
+
+const underline = x => `\u001b[4m\u001b[1m${x}\u001b[0m`;
+const bold = x => `\u001b[1m${x}\u001b[0m`;
+
+if (!raw) console.log(`\n${underline('source')}\n` + source);
+if (!raw) console.log(`\n\n${underline('processing')}`);
+
+let cache = '';
+const print = str => {
+  cache += str;
+
+  if (str === '\n') {
+    process.stdout.write(cache);
+    cache = '';
+  }
+};
+
+const t0 = performance.now();
+const { wasm, exports } = await compile(source, raw ? [ 'module' ] : [ 'module', 'info' ], {}, print);
+
+if (!raw && typeof Deno === 'undefined') fs.writeFileSync('out.wasm', Buffer.from(wasm));
+
+if (!process.argv.includes('-no-run')) {
+  console.log(`\n\n${underline('output')}`);
+  const t2 = performance.now();
+
+  exports.main();
+  print('\n');
+
+  if (!raw) console.log(bold(`\n\nexecuted in ${(performance.now() - t2).toFixed(2)}ms`));
+}
+
+if (!raw) console.log(bold(`wasm binary is ${wasm.byteLength} bytes`));
+if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);

package/runner/profile.js

@@ -0,0 +1,47 @@
+import compile from '../compiler/index.js';
+import fs from 'node:fs';
+
+let csv = `phase,time\n`;
+
+csv += `node,${performance.now()}\n`;
+
+const t0 = performance.now();
+const file = process.argv.slice(2).find(x => x[0] !== '-');
+const source = fs.readFileSync(file, 'utf8');
+csv += `read,${performance.now() - t0}\n`;
+
+console.log = x => {
+  if (x.includes(' in ')) {
+    csv += [ 'parse', 'codegen', 'opt', 'sections' ][parseInt(x[0]) - 1] + ',' + x.split(' in ')[1].slice(0, -2) + '\n';
+  }
+};
+
+const wasm = compile(source, [ 'info' ]);
+
+let cache = '';
+const print = str => {
+  cache += str;
+
+  if (str === '\n') {
+    process.stdout.write(cache);
+    cache = '';
+  }
+};
+
+const t1 = performance.now();
+const { instance } = await WebAssembly.instantiate(wasm, {
+  '': {
+    p: i => print(Number(i).toString()),
+    c: i => print(String.fromCharCode(Number(i))),
+    a: c => { if (!Number(c)) throw new Error(`assert failed`); }
+  }
+});
+csv += `inst,${performance.now() - t1}\n`;
+
+const t2 = performance.now();
+instance.exports.m();
+print('\n');
+
+csv += `exec,${performance.now() - t2}`;
+
+fs.writeFileSync(`profile.csv`, csv);

package/runner/repl.js

@@ -0,0 +1,99 @@
+import compile from '../compiler/wrap.js';
+
+import repl from 'node:repl';
+import fs from 'node:fs';
+
+const rev = fs.readFileSync('.git/refs/heads/main', 'utf8').trim();
+
+// process.argv.push('-O0'); // disable opts
+
+globalThis.valtype = 'f64';
+
+const valtypeOpt = process.argv.find(x => x.startsWith('-valtype='));
+if (valtypeOpt) valtype = valtypeOpt.split('=')[1];
+
+console.log(`welcome to porffor rev ${rev.slice(0, 7)}`);
+console.log(`info: using opt ${process.argv.find(x => x.startsWith('-O')) ?? '-O1'} and valtype ${valtype}`);
+console.log();
+
+let lastMemory, lastPages;
+const PageSize = 65536;
+const memoryToString = mem => {
+  let out = '';
+  const pages = lastPages.length;
+  const wasmPages = mem.buffer.byteLength / PageSize;
+
+  out += `\x1B[1mallocated ${mem.buffer.byteLength / 1024}KiB\x1B[0m for ${pages} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}\n`;
+
+  const buf = new Uint8Array(mem.buffer);
+
+  for (let i = 0; i < pages; i++) {
+    out += `\x1B[36m${lastPages[i]}\x1B[2m | \x1B[0m`;
+
+    for (let j = 0; j < 50; j++) {
+      const val = buf[i * pageSize + j];
+      if (val === 0) out += '\x1B[2m';
+      out += val.toString(16).padStart(2, '0');
+      if (val === 0) out += '\x1B[0m';
+      out += ' ';
+    }
+    out += '\n';
+  }
+
+  return out;
+};
+
+let prev = '';
+const run = async (source, _context, _filename, callback, run = true) => {
+  let toRun = prev + source.trim();
+  prev = toRun + ';\n';
+
+  const { exports, wasm, pages } = await compile(toRun, []);
+  fs.writeFileSync('out.wasm', Buffer.from(wasm));
+
+  if (exports.$) {
+    lastMemory = exports.$;
+    lastPages = [...pages.keys()];
+  }
+
+  const ret = run ? exports.main() : undefined;
+  callback(null, ret);
+
+  // if (source.includes(' = ') || source.includes('let ') || source.includes('var ') || source.includes('const ')) prev += source + ';\n';
+  // prev = toRun + ';\n';
+};
+
+const replServer = repl.start({ prompt: '> ', eval: run });
+
+replServer.setupHistory('.repl_history', () => {});
+
+replServer.defineCommand('memory', {
+  help: 'Log Wasm memory',
+  action() {
+    this.clearBufferedCommand();
+    console.log(memoryToString(lastMemory));
+    this.displayPrompt();
+  }
+});
+replServer.defineCommand('asm', {
+  help: 'Log Wasm decompiled bytecode',
+  async action() {
+    this.clearBufferedCommand();
+
+    try {
+      process.argv.push('-opt-funcs');
+      await run('', null, null, () => {}, false);
+      process.argv.pop();
+    } catch { }
+
+    this.displayPrompt();
+  }
+});
+replServer.defineCommand('js', {
+  help: 'Log JS being actually ran',
+  async action() {
+    this.clearBufferedCommand();
+    console.log(prev);
+    this.displayPrompt();
+  }
+});

package/runner/sizes.js

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import compile from '../compiler/index.js';
+
+// deno compat
+const textEncoder = new TextEncoder();
+if (typeof process === 'undefined') globalThis.process = { argv: ['', '', ...Deno.args], stdout: { write: str => Deno.writeAllSync(Deno.stdout, textEncoder.encode(str)) } };
+
+let csv = `file,porffor i32 -O0,porffor i32 -O1,porffor i32 -O2,porffor i32 -O3,porffor i64 -O0,porffor i64 -O1,porffor i64 -O2,porffor i64 -O3,porffor f64 -O0, porffor f64 -O1, porffor f64 -O2, porffor f64 -O3\n`;
+const perform = async (file, args) => {
+  process.argv = process.argv.slice(0, 2).concat(args);
+  const source = fs.readFileSync(file, 'utf8');
+
+  const { wasm } = compile(source, []);
+  const size = wasm.byteLength;
+
+  const label = `${file} ${args.join(' ')}`;
+  csv += `${size},`;
+  console.log(label, ' '.repeat(40 - label.length), `${size}b`);
+};
+
+const argsValtypes = [ '-valtype=i32', '-valtype=i64', '-valtype=f64' ];
+const argsOptlevels = [ '-O0', '-O1', '-O2', '-O3' ];
+
+for (const file of [ 'bench/prime_basic.js', 'bench/fib_iter.js', 'test/math_1.js', 'test/math_3.js', 'test/while_1.js', 'test/for_2.js', 'test/unary_3.js', 'test/updateexp_1.js', 'test/eq_3.js', 'test/empty.js' ]) {
+  const niceFile = file.split('/')[1].slice(0, -3);
+  csv += `${niceFile},`;
+
+  for (const x of argsValtypes) {
+    for (const y of argsOptlevels) {
+      await perform(file, [ x, y ]);
+    }
+  }
+
+  csv = csv.slice(0, -1) + '\n';
+}
+
+fs.writeFileSync('sizes.csv', csv);
+console.log(csv);

package/runner/transform.js

@@ -0,0 +1,36 @@
+import compile from '../compiler/wrap.js';
+import fs from 'node:fs';
+
+const file = process.argv.slice(2).find(x => x[0] !== '-');
+
+const source = fs.readFileSync(file, 'utf8');
+
+const underline = x => `\u001b[4m\u001b[1m${x}\u001b[0m`;
+const bold = x => `\u001b[1m${x}\u001b[0m`;
+
+let cache = '';
+const print = str => {
+  cache += str;
+
+  if (str === '\n') {
+    process.stdout.write(cache);
+    cache = '';
+  }
+};
+
+const { wasm } = await compile(source);
+
+if (!raw && typeof Deno === 'undefined') fs.writeFileSync('out.wasm', Buffer.from(wasm));
+
+if (!process.argv.includes('-no-run')) {
+  console.log(`\n\n${underline('output')}`);
+  const t2 = performance.now();
+
+  exports.main();
+  print('\n');
+
+  if (!raw) console.log(bold(`\n\nexecuted in ${(performance.now() - t2).toFixed(2)}ms`));
+}
+
+if (!raw) console.log(bold(`wasm binary is ${wasm.byteLength} bytes`));
+if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);

package/sw.js

@@ -0,0 +1,26 @@
+self.addEventListener('install', () => self.skipWaiting());
+self.addEventListener('activate', e => e.waitUntil(self.clients.claim()));
+
+const handleFetch = async request => {
+  const r = await fetch(request.mode === 'no-cors' ? new Request(request, { credentials: 'omit' }) : request).catch(e => console.error(e));
+
+  if (r.status === 0) {
+    return r;
+  }
+
+  const headers = new Headers(r.headers);
+  headers.set('Cross-Origin-Embedder-Policy', 'credentialless');
+  headers.set('Cross-Origin-Opener-Policy', 'same-origin');
+  // headers.set('Cross-Origin-Resource-Policy', 'cross-origin');
+
+  return new Response(r.body, { status: r.status, statusText: r.statusText, headers });
+};
+
+self.addEventListener('fetch', e => {
+  const { request } = e;
+  if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') {
+    return;
+  }
+
+  e.respondWith(handleFetch(request));
+});

package/test/array_1.js

@@ -0,0 +1,8 @@
+// "42468"
+let a = [ 2, 4, 6, 8 ];
+print(a.length);
+
+print(a[0]);
+print(a[1]);
+print(a[2]);
+print(a[3]);

package/test/array_push.js

@@ -0,0 +1,8 @@
+// "1224"
+let a = [];
+
+print(a.push(2));
+print(a[0]);
+
+print(a.push(4));
+print(a[1]);

package/test/assignop_1.js

@@ -0,0 +1,15 @@
+// "13284"
+let a = 1;
+print(a);
+
+a += 2;
+print(a);
+
+a -= 1;
+print(a);
+
+a *= 4;
+print(a);
+
+a /= 2;
+print(a);

package/test/bitwise_1.js

@@ -0,0 +1,6 @@
+// "161717-62"
+print(0x010 & 0x110);
+print(0x10 | 0x01);
+print(0x110 ^ 0x101);
+print(~5);
+print(~-3);

package/test/bool_1.js

@@ -0,0 +1,3 @@
+// "10"
+print(true);
+print(false);

package/test/boolean.js

@@ -0,0 +1,6 @@
+// "0\n1\n1\n1\n"
+
+console.log(Boolean(0));
+console.log(Boolean(1));
+console.log(Boolean(2));
+console.log(Boolean(-1));

package/test/break_1.js

@@ -0,0 +1,6 @@
+// "01"
+
+for (let i = 0; i < 5; i++) {
+  if (i === 2) break;
+  print(i);
+}

package/test/break_2.js

@@ -0,0 +1,12 @@
+// "0101"
+for (let i = 0; i < 5; i++) {
+  if (i === 2) break;
+
+  let j = 0;
+  while (j < 5) {
+    if (j === 2) break;
+    print(j);
+
+    j++;
+  }
+}

package/test/conditional_1.js

@@ -0,0 +1,3 @@
+// "24"
+print(true ? 2 : 4);
+print(false ? 2 : 4);

package/test/conditional_2.js

@@ -0,0 +1,4 @@
+// "10"
+let a = 3;
+print(a === 3 ? 1 : 0);
+print(a !== 3 ? 1 : 0);

package/test/console_1.js

@@ -0,0 +1,2 @@
+// "1\n"
+console.log(1);

package/test/continue_1.js

@@ -0,0 +1,6 @@
+// "0134"
+
+for (let i = 0; i < 5; i++) {
+  if (i === 2) continue;
+  print(i);
+}

package/test/continue_2.js

@@ -0,0 +1,10 @@
+// "0002101230324042"
+for (let i = 0; i < 5; i++) {
+  if (i === 2) continue;
+
+  for (let j = 0; j < 3; j++) {
+    if (j === 1) continue;
+    print(i);
+    print(j);
+  }
+}

package/test/empty.js

@@ -0,0 +1 @@
+// ""

package/test/ending_exp_1.js

@@ -0,0 +1,2 @@
+// ""
+2

package/test/ending_exp_2.js

@@ -0,0 +1,6 @@
+// ""
+function a() {
+  return 2;
+}
+
+a();

package/test/eq_1.js

@@ -0,0 +1,4 @@
+// "100"
+print(1 == 1);
+print(0 == 1);
+print(1 == 0);

package/test/eq_2.js

@@ -0,0 +1,4 @@
+// "111"
+print(1 != 0);
+print(1 === 1);
+print(2 !== 1);

package/test/eq_3.js

@@ -0,0 +1,5 @@
+// "1111"
+print(2 > 1);
+print(2 >= 2);
+print(2 < 3);
+print(2 <= 2);

package/test/export_1.js

@@ -0,0 +1,9 @@
+// ""
+
+export function a() {}
+export const b = () => {};
+
+export function c(foo) { return foo; }
+export const d = _ => 1;
+
+a();

package/test/factorial.js

@@ -0,0 +1,3 @@
+// "479001600\n"
+const factorial = n => n === 0 ? 1 : (n * factorial(n - 1));
+console.log(factorial(12));

package/test/fibonacci.js

@@ -0,0 +1,16 @@
+// "0 1 1 2 3 5 8 13 21 34 55 "
+const p = x => {
+  print(x);
+  printChar(32);
+};
+
+let a = 0, b = 1;
+p(a); p(b);
+
+for (let i = 2; i <= 10; i++) {
+  let t = b + a;
+  a = b;
+  b = t;
+
+  p(t);
+}

package/test/float_div0.js

@@ -0,0 +1,2 @@
+// "Infinity"
+print(1 / 0);

package/test/float_frac.js

@@ -0,0 +1,2 @@
+// "1"
+print((1/3) * 3);

package/test/float_isfinite.js

@@ -0,0 +1,29 @@
+// "1100000011000000"
+
+let a = Infinity;
+let b = -Infinity;
+let c = NaN;
+
+print(isFinite(0));
+print(isFinite(1));
+
+print(isFinite(Infinity));
+print(isFinite(a));
+
+print(isFinite(-Infinity));
+print(isFinite(b));
+
+print(isFinite(NaN));
+print(isFinite(c));
+
+print(Number.isFinite(0));
+print(Number.isFinite(1));
+
+print(Number.isFinite(Infinity));
+print(Number.isFinite(a));
+
+print(Number.isFinite(-Infinity));
+print(Number.isFinite(b));
+
+print(Number.isFinite(NaN));
+print(Number.isFinite(c));

package/test/float_isinteger.js

@@ -0,0 +1,13 @@
+// "111000"
+
+print(Number.isInteger(-1));
+print(Number.isInteger(0));
+print(Number.isInteger(1));
+
+print(Number.isInteger(-1.1));
+print(Number.isInteger(1.1));
+
+// print(Number.isInteger(Infinity));
+// print(Number.isInteger(-Infinity));
+
+print(Number.isInteger(NaN));

package/test/float_isnan.js

@@ -0,0 +1,20 @@
+// "000011000011"
+let a = NaN;
+
+print(isNaN(0));
+print(isNaN(1));
+
+print(isNaN(Infinity));
+print(isNaN(-Infinity));
+
+print(isNaN(NaN));
+print(isNaN(a));
+
+print(Number.isNaN(0));
+print(Number.isNaN(1));
+
+print(Number.isNaN(Infinity));
+print(Number.isNaN(-Infinity));
+
+print(Number.isNaN(NaN));
+print(Number.isNaN(a));

package/test/float_issafeinteger.js

@@ -0,0 +1,11 @@
+// "1\n1\n1\n1\n1\n0\n0\n"
+
+console.log(Number.isSafeInteger(0));
+console.log(Number.isSafeInteger(1));
+console.log(Number.isSafeInteger(-1));
+
+console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER));
+console.log(Number.isSafeInteger(Number.MIN_SAFE_INTEGER));
+
+console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1));
+console.log(Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1));

package/test/float_large.js

@@ -0,0 +1,2 @@
+// "1e+99"
+print(1e99);