porffor 0.0.0-828ee15 → 0.0.0-a2afb57

package/compiler/sections.js

@@ -1,5 +1,5 @@
 import { Valtype, FuncType, Empty, ExportDesc, Section, Magic, ModuleVersion, Opcodes, PageSize } from './wasmSpec.js';
-import { encodeVector, encodeString, encodeLocal } from './encoding.js';
+import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128 } from './encoding.js';
 import { number } from './embedding.js';
 import { importedFuncs } from './builtins.js';
 
@@ -8,11 +8,26 @@ const createSection = (type, data) => [
   ...encodeVector(data)
 ];
 
-export default (funcs, globals, tags, pages, flags) => {
+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, data, 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]}`);
@@ -36,7 +51,7 @@ export default (funcs, globals, tags, pages, flags) => {
     // tree shake imports
     for (const f of funcs) {
       for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] < importedFuncs.length) {
+        if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] < importedFuncs.length) {
           const idx = inst[1];
           const func = importedFuncs[idx];
 
@@ -51,15 +66,17 @@ export default (funcs, globals, tags, pages, flags) => {
     // fix call indexes for non-imports
     const delta = importedFuncs.length - importFuncs.length;
     for (const f of funcs) {
+      f.originalIndex = f.index;
       f.index -= delta;
 
       for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] >= importedFuncs.length) {
+        if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] >= importedFuncs.length) {
           inst[1] -= delta;
         }
       }
     }
   }
+  globalThis.importFuncs = importFuncs;
 
   if (optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
 
@@ -73,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 ]))
@@ -80,6 +105,8 @@ export default (funcs, globals, tags, pages, flags) => {
 
   const exports = funcs.filter(x => x.export).map((x, i) => [ ...encodeString(x.name === 'main' ? 'm' : x.name), ExportDesc.func, x.index ]);
 
+  if (process.argv.includes('-always-memory') && pages.size === 0) pages.set('-always-memory', 0);
+
   const usesMemory = pages.size > 0;
   const memorySection = !usesMemory ? [] : createSection(
     Section.memory,
@@ -130,13 +157,24 @@ export default (funcs, globals, tags, pages, flags) => {
     encodeVector(types)
   );
 
+  const dataSection = data.length === 0 ? [] : createSection(
+    Section.data,
+    encodeVector(data.map(x => [ 0x00, Opcodes.i32_const, ...signedLEB128(x.offset), Opcodes.end, ...encodeVector(x.bytes) ]))
+  );
+
+  const dataCountSection = data.length === 0 ? [] : createSection(
+    Section.data_count,
+    unsignedLEB128(data.length)
+  );
+
   if (process.argv.includes('-sections')) console.log({
     typeSection: typeSection.map(x => x.toString(16)),
     importSection: importSection.map(x => x.toString(16)),
     funcSection: funcSection.map(x => x.toString(16)),
     globalSection: globalSection.map(x => x.toString(16)),
     exportSection: exportSection.map(x => x.toString(16)),
-    codeSection: codeSection.map(x => x.toString(16))
+    codeSection: codeSection.map(x => x.toString(16)),
+    dataSection: dataSection.map(x => x.toString(16)),
   });
 
   return Uint8Array.from([
@@ -145,10 +183,13 @@ export default (funcs, globals, tags, pages, flags) => {
     ...typeSection,
     ...importSection,
     ...funcSection,
+    ...chSection,
     ...memorySection,
     ...tagSection,
     ...globalSection,
     ...exportSection,
-    ...codeSection
+    ...dataCountSection,
+    ...codeSection,
+    ...dataSection
   ]);
 };

package/compiler/wrap.js

@@ -5,6 +5,7 @@ import decompile from './decompile.js';
 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)) => {
@@ -90,6 +92,15 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
             return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
           }
 
+          case 'function': {
+            // wasm func index, including all imports
+            const func = funcs.find(x => (x.originalIndex ?? x.index) === ret);
+            if (!func) return ret;
+
+            // make fake empty func for repl/etc
+            return {[func.name]() {}}[func.name];
+          }
+
           default: return ret;
         }
       } catch (e) {

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-828ee15",
+  "version": "0.0.0-a2afb57",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/r.js

@@ -0,0 +1,39 @@
+compareArray.isSameValue = function(a, b) {
+  if (a === 0 && b === 0) return 1 / a === 1 / b;
+  if (a !== a && b !== b) return true;
+
+  return a === b;
+};
+
+function compareArray(a, b) {
+  // if either are nullish
+  if (a == null || b == null) return false;
+
+  // megahack: all arrays from now on will be >0 pointer
+  const _hack = '';
+
+  // hack: enforce type inference of being arrays
+  a ??= [];
+  b ??= [];
+
+  if (b.length !== a.length) {
+    return false;
+  }
+
+  for (var i = 0; i < a.length; i++) {
+    if (!compareArray.isSameValue(b[i], a[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+console.log(compareArray(null, []));
+console.log(compareArray(undefined, []));
+
+console.log(compareArray([], []));
+console.log(compareArray([ 1 ], []));
+console.log(compareArray([ 1 ], [ 1 ]));
+console.log(compareArray([ 1, 2 ], [ 1 ]));
+console.log(compareArray([ 1, 2 ], [ 1, 2 ]));

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, 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 },
+  }
+});