porffor 0.0.0-579ef36

package/compiler/wrap.js

@@ -0,0 +1,119 @@
+import compile from './index.js';
+import decompile from './decompile.js';
+// import fs from 'node:fs';
+
+const bold = x => `\u001b[1m${x}\u001b[0m`;
+
+const typeBase = 0xffffffffffff0;
+const TYPES = {
+  [typeBase]: 'number',
+  [typeBase + 1]: 'boolean',
+  [typeBase + 2]: 'string',
+  [typeBase + 3]: 'undefined',
+  [typeBase + 4]: 'object',
+  [typeBase + 5]: 'function',
+  [typeBase + 6]: 'symbol',
+  [typeBase + 7]: 'bigint',
+
+  // internal
+  [typeBase + 8]: '_array'
+};
+
+export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
+  const times = [];
+
+  const t1 = performance.now();
+  const { wasm, funcs, globals, tags, exceptions, pages } = compile(source, flags);
+
+  if (source.includes('export function')) flags.push('module');
+
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
+
+  times.push(performance.now() - t1);
+  if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
+
+  const t2 = performance.now();
+  const { instance } = await WebAssembly.instantiate(wasm, {
+    '': {
+      p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
+      c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
+      a: c => { if (!Number(c)) throw new Error(`assert failed`); },
+      t: _ => performance.now(),
+      ...customImports
+    }
+  });
+
+  times.push(performance.now() - t2);
+  if (flags.includes('info')) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
+
+  const exports = {};
+
+  const exceptTag = instance.exports['0'], memory = instance.exports['$'];
+  for (const x in instance.exports) {
+    if (x === '0') continue;
+    if (x === '$') {
+      exports.$ = instance.exports.$;
+      continue;
+    }
+
+    const name = x === 'm' ? 'main' : x;
+    const func = funcs.find(x => x.name === name);
+
+    const exp = instance.exports[x];
+    exports[func.name] = exp;
+
+    exports[func.name] = function() {
+      try {
+        const ret = exp.apply(this, arguments);
+
+        if (ret >= typeBase && ret <= typeBase + 8) return ret > (typeBase + 7) ? 'object' : TYPES[ret];
+
+        switch (TYPES[func.returnType]) {
+          case 'boolean': return Boolean(ret);
+          case 'undefined': return undefined;
+          case 'object': return ret === 0 ? null : {};
+
+          case '_array': {
+            const pointer = ret;
+            const length = new Int32Array(memory.buffer, pointer, 1);
+
+            // have to slice because of memory alignment
+            const buf = memory.buffer.slice(pointer + 4, pointer + 4 + 8 * length);
+
+            return Array.from(new Float64Array(buf));
+          }
+
+          case 'string': {
+            const pointer = ret;
+            const length = new Int32Array(memory.buffer, pointer, 1);
+
+            return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
+          }
+
+          default: return ret;
+        }
+      } catch (e) {
+        if (e.is && e.is(exceptTag)) {
+          const exceptId = e.getArg(exceptTag, 0);
+          const exception = exceptions[exceptId];
+
+          const constructorName = exception.constructor;
+
+          // no constructor, just throw message
+          if (!constructorName) throw exception.message;
+
+          const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+          throw new constructor(exception.message);
+        }
+
+        throw e;
+      }
+    };
+  }
+
+  if (flags.includes('decomp')) {
+    return { exports, wasm, times, decomps: funcs.map(x => decompile(x.wasm, x.name, x.index, x.locals, x.params, x.returns, funcs, globals, exceptions)) };
+  }
+
+  return { exports, wasm, times, pages };
+};

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.0.0-579ef36",
+  "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/publish.js

@@ -0,0 +1,13 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+
+const rev = fs.readFileSync('.git/refs/heads/main', 'utf8').trim().slice(0, 7);
+
+const packageJson = fs.readFileSync('package.json', 'utf8');
+fs.writeFileSync('package.json', packageJson.replace('"0.0.0"', `"0.0.0-${rev}"`));
+
+console.log(rev, packageJson);
+
+execSync(`npm publish`, { stdio: 'inherit' });
+
+fs.writeFileSync('package.json', packageJson);

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,34 @@
+#!/usr/bin/env node
+
+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,104 @@
+import compile from '../compiler/wrap.js';
+
+import repl from 'node:repl';
+import fs from 'node:fs';
+
+let rev = 'unknown';
+try {
+  rev = fs.readFileSync(new URL('../.git/refs/heads/main', import.meta.url), 'utf8').trim().slice(0, 7);
+} catch {
+  rev = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version.split('-')[1];
+}
+
+// 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/util/enum.js

@@ -0,0 +1,20 @@
+export const enumify = (...args) => {
+  const obj = {};
+
+  for (let i = 0; i < args.length; i++) {
+    obj[i] = args[i];
+    obj[args[i]] = i;
+  }
+
+  return obj;
+};
+
+// a procedural enum ;)
+export const procEnum = () => {
+  let n = 0;
+  return new Proxy({}, {
+    get(target, p) {
+      return target[p] ?? (target[p] = n++);
+    }
+  });
+};