porffor 0.0.0-c743344 → 0.0.0-ee33579

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]}`);
@@ -61,6 +76,7 @@ export default (funcs, globals, tags, pages, flags) => {
       }
     }
   }
+  globalThis.importFuncs = importFuncs;
 
   if (optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
 
@@ -74,6 +90,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 +170,7 @@ export default (funcs, globals, tags, pages, flags) => {
     ...typeSection,
     ...importSection,
     ...funcSection,
+    ...chSection,
     ...memorySection,
     ...tagSection,
     ...globalSection,

package/compiler/wrap.js

@@ -1,10 +1,11 @@
 import compile from './index.js';
 import decompile from './decompile.js';
-import fs from 'node:fs';
+// import fs from 'node:fs';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
 const typeBase = 0xffffffffffff0;
+const internalTypeBase = 0xfffffffffff0f;
 const TYPES = {
   [typeBase]: 'number',
   [typeBase + 1]: 'boolean',
@@ -16,7 +17,8 @@ const TYPES = {
   [typeBase + 7]: 'bigint',
 
   // internal
-  [typeBase + 8]: '_array'
+  [internalTypeBase]: '_array',
+  [internalTypeBase + 1]: '_regexp'
 };
 
 export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
@@ -27,7 +29,7 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   if (source.includes('export function')) flags.push('module');
 
-  fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  // 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`));

package/hi.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+
+double inline f64_f(double x, double y) {
+  return x - (int)(x / y) * y;
+}
+
+double isPrime(double number) {
+  double i;
+
+  if (number < 2e+0) {
+    return 0e+0;
+  }
+  i = 2e+0;
+  while (i < number) {
+    if (f64_f(number, i) == 0e+0) {
+      return 0e+0;
+    }
+    i = i + 1e+0;
+  }
+  return 1e+0;
+}
+
+int main() {
+  double sum;
+  double counter;
+
+  sum = 0e+0;
+  counter = 0e+0;
+  while (counter <= 1e+5) {
+    if (isPrime(counter) == 1e+0) {
+      sum = sum + counter;
+    }
+    counter = counter + 1e+0;
+  }
+  printf("%f\n", sum);
+}
+

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-ee33579",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/r.js

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

package/rhemyn/README.md

@@ -0,0 +1,37 @@
+# rhemyn
+a basic experimental wip regex engine/aot wasm compiler in js. regex engine for porffor. uses own regex parser, no dependencies (excluding porffor internals). <br>
+age: ~1 day
+
+made for use with porffor but could possibly be adapted, implementation/library notes:
+- exposes functions for each regex "operation" (eg test, match)
+- given a regex pattern string (eg `a+`), it returns a "function" object
+- wasm function returned expects an i32 pointer to a utf-16 string (can add utf-8 option later if someone else actually wants to use this)
+
+## syntax
+🟢 supported 🟡 partial 🟠 parsed only 🔴 unsupported
+
+- 🟢 literal characters (eg `a`)
+- 🟢 escaping (eg `\.\n\cJ\x0a\u000a`)
+  - 🟢 character itself (eg `\.`)
+  - 🟢 escape sequences (eg `\n`)
+  - 🟢 control character (eg `\cJ`)
+  - 🟢 unicode code points (eg `\x00`, `\u0000`)
+- 🟢 sets (eg `[ab]`)
+  - 🟢 ranges (eg `[a-z]`)
+  - 🟢 negated sets (eg `[^ab]`)
+- 🟢 metacharacters
+  - 🟢 dot (eg `a.b`)
+  - 🟢 digit, not digit (eg `\d\D`)
+  - 🟢 word, not word (eg `\w\W`)
+  - 🟢 whitespace, not whitespace (eg `\s\S`)
+- 🟠 quantifiers
+  - 🟠 star (eg `a*`)
+  - 🟠 plus (eg `a+`)
+  - 🟠 optional (eg `a?`)
+  - 🟠 lazy modifier (eg `a*?`)
+  - 🔴 n repetitions (eg `a{4}`)
+  - 🔴 n-m repetitions (eg `a{2,4}`)
+- 🔴 assertions
+  - 🔴 beginning (eg `^a`)
+  - 🔴 end (eg `a$`)
+  - 🔴 word boundary assertion (eg `\b\B`)

package/rhemyn/compile.js

@@ -0,0 +1,214 @@
+import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from '../compiler/wasmSpec.js';
+import { number } from '../compiler/embedding.js';
+import { signedLEB128, unsignedLEB128 } from '../compiler/encoding.js';
+import parse from './parse.js';
+
+// local indexes
+const BasePointer = 0; // base string pointer
+const IterPointer = 1; // this iteration base pointer
+const EndPointer = 2; // pointer for the end
+const Counter = 3; // what char we are running on
+const Pointer = 4; // next char BYTE pointer
+const Length = 5;
+const Tmp = 6;
+
+let exprLastGet = false;
+const generate = (node, negated = false, get = true, func = 'test') => {
+  let out = [];
+  switch (node.type) {
+    case 'Expression':
+      exprLastGet = false;
+      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
+        ...node.body.flatMap((x, i) => {
+          exprLastGet = x.type !== 'Group' && i === (node.body.length - 1);
+          return generate(x, negated);
+        }),
+
+        // reached end without branching out, successful match
+        ...({
+          test: number(1, Valtype.i32),
+          search: [
+            [ Opcodes.local_get, Counter ]
+          ]
+        })[func],
+        [ 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, 0 ],
+        [ Opcodes.end ],
+
+        // no match, return 0
+        ...number(({
+          test: 0,
+          search: -1
+        })[func], Valtype.i32)
+      ];
+
+      if (globalThis.regexLog) {
+        const underline = x => `\u001b[4m\u001b[1m${x}\u001b[0m`;
+        console.log(`\n${underline('ast')}`);
+        console.log(node);
+        console.log(`\n${underline('wasm bytecode')}\n` + decompile(out) + '\n');
+      }
+
+      break;
+
+    case 'Character':
+      out = generateChar(node, node.negated ^ negated, get);
+      break;
+
+    case 'Set':
+      out = generateSet(node, node.negated, get);
+      break;
+
+    case 'Group':
+      out = generateGroup(node, negated, get);
+      break;
+
+    case 'Range':
+      out = generateRange(node, negated, 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) ],
+
+  ...(exprLastGet ? [] : [
+    // 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_if, 0 ]
+];
+
+const generateChar = (node, negated, get) => {
+  return [
+    ...(get ? getNextChar() : []),
+    ...number(node.char.charCodeAt(0), Valtype.i32),
+    negated ? [ Opcodes.i32_eq ] : [ Opcodes.i32_ne ],
+    ...(get ? checkFailure(): [])
+  ];
+};
+
+const generateSet = (node, negated, get) => {
+  // for a single char we do not need a tmp, it is like just
+  const singleChar = node.body.length === 1 && node.body[0].type === 'Character';
+
+  let out = [
+    ...(get ? getNextChar() : []),
+    ...(singleChar ? [] : [ [ Opcodes.local_set, Tmp ] ]),
+  ];
+
+  for (const x of node.body) {
+    out = [
+      ...out,
+      ...(singleChar ? [] : [ [ Opcodes.local_get, Tmp ] ]),
+      ...generate(x, negated, false)
+    ];
+  }
+
+  out = out.concat(new Array(node.body.length - 1).fill(negated ? [ Opcodes.i32_or ] : [ Opcodes.i32_and ]));
+
+  return [
+    ...out,
+    ...checkFailure()
+  ];
+};
+
+const generateRange = (node, negated, get) => {
+  return [
+    ...(get ? getNextChar() : []),
+    ...(get ? [ [ Opcodes.local_tee, Tmp ] ] : []),
+
+    ...number(node.from.charCodeAt(0), Valtype.i32),
+    // negated ? [ Opcodes.i32_lt_s ] : [ Opcodes.i32_ge_s ],
+    negated ? [ Opcodes.i32_ge_s ] : [ Opcodes.i32_lt_s ],
+
+    [ Opcodes.local_get, Tmp ],
+    ...number(node.to.charCodeAt(0), Valtype.i32),
+    // negated ? [ Opcodes.i32_gt_s ] : [ Opcodes.i32_le_s ],
+    negated ? [ Opcodes.i32_le_s ] : [ Opcodes.i32_gt_s ],
+
+    negated ? [ Opcodes.i32_and ] : [ Opcodes.i32_or ],
+    ...(get ? checkFailure(): [])
+  ];
+};
+
+const generateGroup = (node, negated, get) => {
+
+};
+
+export const test = (regex, index = 0, name = 'regex_test_' + regex) => outputFunc(generate(parse(regex), false, true, 'test'), name, index);
+export const search = (regex, index = 0, name = 'regex_search_' + regex) => outputFunc(generate(parse(regex), false, true, 'search'), name, index);
+
+const outputFunc = (wasm, name, index) => ({
+  name,
+  index,
+  wasm,
+
+  export: true,
+  params: [ Valtype.i32 ],
+  returns: [ Valtype.i32 ],
+  returnType: 0xffffffffffff1, // boolean - todo: do not hardcode this
+  locals: {
+    basePointer: { idx: 0, type: Valtype.i32 },
+    iterPointer: { idx: 1, type: Valtype.i32 },
+    endPointer: { idx: 2, type: Valtype.i32 },
+    counter: { idx: 3, type: Valtype.i32 },
+    pointer: { idx: 4, type: Valtype.i32 },
+    length: { idx: 5, type: Valtype.i32 },
+    tmp: { idx: 6, type: Valtype.i32 },
+  }
+});