porffor 0.0.0-c743344 → 0.0.0-ebc0491

package/README.md

@@ -101,17 +101,29 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
 - intrinsic functions (see below)
 - inlining wasm via ``asm`...``\` "macro"
 
-## soon todo
+## todo
+no particular order and no guarentees, just what could happen soon™
+
 - arrays
   - member setting (`arr[0] = 2`)
   - more of `Array` prototype
   - arrays/strings inside arrays
+  - destructuring
+  - for .. of
 - strings
   - member setting
+- objects
+  - basic object expressions (eg `{}`, `{ a: 0 }`)
+- wasm
+  - *basic* wasm engine (interpreter) in js
+- regex
+  - *basic* regex engine (in wasm compiled aot or js interpreter?)
 - more math operators (`**`, etc)
 - `do { ... } while (...)`
+- rewrite `console.log` to work with strings/arrays
 - exceptions
-  - `try { } finally {}`
+  - rewrite to use actual strings (optional?)
+  - `try { } finally { }`
   - rethrowing inside catch
 - optimizations
   - rewrite local indexes per func for smallest local header and remove unused idxs
@@ -119,6 +131,11 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
   - remove const ifs (`if (true)`, etc)
   - use data segments for initing arrays
 
+## porfformance
+*for the things it supports*, porffor is blazingly faster compared to most interpreters, and engines running without JIT. for those with JIT, it is not that much slower like a traditional interpreter would be.
+
+![Screenshot of comparison chart](https://github.com/CanadaHonk/porffor/assets/19228318/76c75264-cc68-4be1-8891-c06dc389d97a)
+
 ## test262
 porffor can run test262 via some hacks/transforms which remove unsupported features whilst still doing the same asserts (eg simpler error messages using literals only). it currently passes >10% (see latest commit desc for latest and details). use `node test262` to test, it will also show a difference of overall results between the last commit and current results.
 
@@ -192,11 +209,12 @@ you can also use deno (`deno run -A ...` instead of `node ...`), or bun (`bun ..
 - `-no-run` to not run wasm output, just compile
 - `-opt-log` to log some opts
 - `-code-log` to log some codegen (you probably want `-funcs`)
-- `-funcs` to log funcs (internal representations)
+- `-funcs` to log funcs
 - `-opt-funcs` to log funcs after opt
 - `-sections` to log sections as hex
 - `-opt-no-inline` to not inline any funcs
-- `-tail-call` to enable tail calls (not widely implemented)
+- `-tail-call` to enable tail calls (experimental + not widely implemented)
+- `-compile-hints` to enable V8 compilation hints (experimental + doesn't seem to do much?)
 
 ## vscode extension
 there is a vscode extension in `porffor-for-vscode` which tweaks js syntax highlighting to be nicer with porffor features (eg highlighting wasm inside of inline asm).

package/compiler/rhemyn/compile.js

@@ -0,0 +1,173 @@
+import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from '../wasmSpec.js';
+import { signedLEB128, unsignedLEB128 } from '../encoding.js';
+import parse from './parse.js';
+
+// local indexes
+const BasePointer = 0; // base string pointer
+const IterPointer = 1; // this iteration base pointer
+const Counter = 2; // what char we are running on
+const Pointer = 3; // next char BYTE pointer
+const Length = 4;
+const Tmp = 5;
+
+const generate = (node, get = true) => {
+  let out = [];
+  switch (node.type) {
+    case 'Expression':
+      out = [
+        // set length local
+        [ Opcodes.local_get, BasePointer ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(0) ],
+        [ Opcodes.local_set, Length ],
+
+        // set iter pointer local as base + sizeof i32 initially
+        [ Opcodes.local_get, BasePointer ],
+        ...number(ValtypeSize.i32, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_set, IterPointer ],
+
+        [ Opcodes.loop, Blocktype.void ],
+
+        // reset pointer as iter pointer
+        [ Opcodes.local_get, IterPointer ],
+        [ Opcodes.local_set, Pointer ],
+
+        [ Opcodes.block, Blocktype.void ],
+        // generate checks
+        ...generate(x),
+
+        // reached end without branching out, successful match
+        ...number(1, Valtype.i32),
+        [ Opcodes.return ],
+
+        [ Opcodes.end ],
+
+        // increment iter pointer by sizeof i16
+        [ Opcodes.local_get, IterPointer ],
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_set, IterPointer ],
+
+        // increment counter by 1, check if eq length, if not loop
+        [ Opcodes.local_get, Counter ],
+        ...number(1, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_tee, Counter ],
+
+        [ Opcodes.local_get, Length ],
+        [ Opcodes.i32_ne ],
+        [ Opcodes.br_if, 1 ],
+
+        [ Opcodes.end ],
+
+        // no match, return 0
+        ...number(0, Valtype.i32)
+      ];
+
+      break;
+
+    case 'Character':
+      out = generateChar(node, get);
+      break;
+
+    case 'Set':
+      out = generateSet(node, get);
+      break;
+
+    case 'Group':
+      out = generateGroup(node, get);
+      break;
+
+    case 'Range':
+      out = generateRange(node, get);
+      break;
+  }
+
+  return out;
+};
+
+const getNextChar = () => [
+  // get char from pointer
+  [ Opcodes.local_get, Pointer ],
+  [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(0) ],
+
+  // pointer += sizeof i16
+  [ Opcodes.local_get, Pointer ],
+  ...number(ValtypeSize.i16, Valtype.i32),
+  [ Opcodes.i32_add ],
+  [ Opcodes.local_set, Pointer ]
+];
+
+const checkFailure = () => [
+  // surely we do not need to do this for every single mismatch, right?
+  /* [ Opcodes.if, Blocktype.void ],
+  ...number(0, Valtype.i32),
+  [ Opcodes.return ],
+  [ Opcodes.end ], */
+
+  [ Opcodes.br, 1 ]
+];
+
+const generateChar = (node, get) => {
+  return [
+    ...(get ? getNextChar() : []),
+    ...number(String.fromCharCode(node.char), Valtype.i32),
+    [ Opcodes.i32_ne ],
+    ...checkFailure()
+  ];
+};
+
+const generateSet = (node, get) => {
+  const out = [
+    ...(get ? getNextChar() : []),
+    [ Opcodes.local_set, Tmp ],
+  ];
+
+  for (const x of node.body) {
+    out = [
+      ...out,
+      [ Opcodes.local_get, Tmp ],
+      ...generate(x, false)
+    ];
+  }
+
+  out = out.concat(new Array(node.body.length - 1).fill([ Opcodes.i32_or ]));
+
+  return [
+    ...out,
+    ...checkFailure()
+  ];
+};
+
+const generateGroup = (node, get) => {
+
+};
+
+const generateRange = (node, get) => {
+
+};
+
+
+export const match = regex => {
+
+};
+
+export const test = regex => {
+  const code = generate(parse(regex));
+};
+
+const wasmify = code => {
+  const funcs = [{
+    name: 'exp',
+    export: true,
+    params: [ Valtype.i32 ],
+    returns: [ Valtype.i32 ],
+    locals: {
+      iterPointer: { idx: 1, type: Valtype.i32 },
+      counter: { idx: 2, type: Valtype.i32 },
+      pointer: { idx: 3, type: Valtype.i32 },
+      length: { idx: 4, type: Valtype.i32 },
+      tmp: { idx: 5, type: Valtype.i32 },
+    }
+  }]
+};

package/compiler/rhemyn/parse.js

@@ -0,0 +1,125 @@
+const State = {
+  none: 0,
+  insideSet: 1
+};
+
+const Quantifiers = {
+  '*': [ 0 ], // 0 -
+  '+': [ 1 ], // 1 -
+  '?': [ 0, 1 ], // 0 - 1
+};
+const QuantifierKeys = Object.keys(Quantifiers);
+
+export default str => {
+  const out = {
+    type: 'Expression',
+    body: []
+  };
+  let node = out, parents = [];
+
+  let state = State.none, escape = false;
+  for (let i = 0; i < str.length; i++) {
+    const c = str[i];
+
+    const addChar = () => {
+      node.body.push({
+        type: 'Character',
+        char: c
+      });
+    };
+
+    const seek = () => {
+      const cNext = str[++i];
+
+      if (cNext === '\\') return str[++i];
+      return cNext;
+    };
+
+    if (escape) {
+      addChar();
+
+      escape = false;
+      continue;
+    }
+
+    if (c === '\\') {
+      escape = true;
+      continue;
+    }
+
+    switch (state) {
+      case State.none:
+        if (c === '[') {
+          parents.push(node);
+          node = {
+            type: 'Set',
+            body: []
+          };
+
+          parents.at(-1).body.push(node);
+
+          state = State.insideSet;
+          continue;
+        }
+
+        if (c === '(') {
+          parents.push(node);
+          node = {
+            type: 'Group',
+            body: []
+          };
+
+          parents.at(-1).body.push(node);
+          continue;
+        }
+
+        if (c === ')') {
+          if (node.type !== 'Group') throw new SyntaxError('Unmatched closing parenthesis');
+
+          node = parents.pop();
+          continue;
+        }
+
+        if (QuantifierKeys.includes(c)) {
+          const amount = Quantifiers[c];
+          node.body.at(-1).quantifier = amount;
+          continue;
+        }
+
+        addChar();
+        break;
+
+      case State.insideSet:
+        if (c === ']') {
+          state = State.none;
+          node = parents.pop();
+
+          continue;
+        }
+
+        // range
+        if (c === '-') {
+          const from = node.body.pop().char;
+          const to = seek();
+
+          node.body.push({
+            type: 'Range',
+            from,
+            to
+          });
+          continue;
+        }
+
+        addChar();
+        break;
+    }
+  }
+
+  // still in a group by the end
+  if (node.type !== 'Expression') throw new SyntaxError('Unmatched opening parenthesis');
+
+  // still in a set by the end
+  if (state === State.insideSet) throw new SyntaxError('Unmatched opening square bracket');
+
+  return out;
+};

package/compiler/rhemyn/test/parse.js

@@ -0,0 +1,20 @@
+import util from 'node:util';
+
+import parse from '../parse.js';
+
+const tests = {
+  'a': {},
+  'a(b)': {},
+  'a(b(c))': {},
+  'ab': {},
+  '[ab]': {},
+  '[a-z]': {},
+  'a*': {},
+  'a+': {},
+  'a?': {},
+  'a(b)+': {}
+}
+
+for (const str in tests) {
+  console.log(str, util.inspect(parse(str), false, null, true));
+}

package/compiler/sections.js

@@ -8,11 +8,26 @@ const createSection = (type, data) => [
   ...encodeVector(data)
 ];
 
+const customSection = (name, data) => [
+  Section.custom,
+  ...encodeVector([...encodeString(name), ...data])
+];
+
+const chHint = (topTier, baselineTier, strategy) => {
+  // 1 byte of 4 2 bit components: spare, top tier, baseline tier, compilation strategy
+  // tiers: 0x00 = default, 0x01 = baseline (liftoff), 0x02 = optimized (turbofan)
+  // strategy: 0x00 = default, 0x01 = lazy, 0x02 = eager, 0x03 = lazy baseline, eager top tier
+  return (strategy | (baselineTier << 2) | (topTier << 4));
+};
+
 export default (funcs, globals, tags, pages, flags) => {
   const types = [], typeCache = {};
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
 
+  const compileHints = process.argv.includes('-compile-hints');
+  if (compileHints) log('sections', 'warning: compile hints is V8 only w/ experimental arg! (you used -compile-hints)');
+
   const getType = (params, returns) => {
     const hash = `${params.join(',')}_${returns.join(',')}`;
     if (optLog) log('sections', `getType(${JSON.stringify(params)}, ${JSON.stringify(returns)}) -> ${hash} | cache: ${typeCache[hash]}`);
@@ -74,6 +89,14 @@ export default (funcs, globals, tags, pages, flags) => {
     encodeVector(funcs.map(x => getType(x.params, x.returns))) // type indexes
   );
 
+  // compilation hints section - unspec v8 only
+  // https://github.com/WebAssembly/design/issues/1473#issuecomment-1431274746
+  const chSection = !compileHints ? [] : customSection(
+    'compilationHints',
+    // for now just do everything as optimise eager
+    encodeVector(funcs.map(_ => chHint(0x02, 0x02, 0x02)))
+  );
+
   const globalSection = Object.keys(globals).length === 0 ? [] : createSection(
     Section.global,
     encodeVector(Object.keys(globals).map(x => [ globals[x].type, 0x01, ...number(globals[x].init ?? 0, globals[x].type).flat(), Opcodes.end ]))
@@ -146,6 +169,7 @@ export default (funcs, globals, tags, pages, flags) => {
     ...typeSection,
     ...importSection,
     ...funcSection,
+    ...chSection,
     ...memorySection,
     ...tagSection,
     ...globalSection,

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.0.0-c743344",
+  "version": "0.0.0-ebc0491",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/r.js

@@ -0,0 +1 @@
+/a(b)/.test('hi');

package/runner/index.js

@@ -3,6 +3,18 @@
 import compile from '../compiler/wrap.js';
 import fs from 'node:fs';
 
+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)
+}
+
 const file = process.argv.slice(2).find(x => x[0] !== '-');
 if (!file) {
   if (process.argv.includes('-v')) {

package/runner/transform.js

@@ -8,7 +8,8 @@ const source = fs.readFileSync(file, 'utf8');
 const { wasm } = await compile(source);
 
 // const out = `(async () => { const print = str => process.stdout.write(str); (await WebAssembly.instantiate(Uint8Array.from([${wasm.toString()}]), {'': { p: i => print(i.toString()), c: i => print(String.fromCharCode(i))}})).instance.exports.m()})()`;
-const out = `new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([${wasm.toString()}])),{'':{p:i=>process.stdout.write(i.toString())}}).exports.m()`;
+// const out = `new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([${wasm.toString()}])),{'':{p:i=>process.stdout.write(i.toString())}}).exports.m()`;
+const out = `const a=new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([${wasm.toString()}])));const b=a.exports.m();console.log(Array.from(new Uint16Array(a.exports.$.buffer,b+4,new Int32Array(a.exports.$.buffer,b,1))).map(x=>String.fromCharCode(x)).join(''))`;
 
 console.log(out);
 eval(out);