porffor 0.0.0-8c0bdaa → 0.0.0-ba812f2

package/compiler/decompile.js

@@ -42,8 +42,8 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       out += ` ${read_ieee754_binary64(inst.slice(1))}`;
     } else if (inst[0] === Opcodes.i32_const || inst[0] === Opcodes.i64_const) {
       out += ` ${read_signedLEB128(inst.slice(1))}`;
-    } else if (inst[0] === Opcodes.i32_load || inst[0] === Opcodes.i64_load || inst[0] === Opcodes.f64_load || inst[0] === Opcodes.i32_store || inst[0] === Opcodes.i64_store || inst[0] === Opcodes.f64_store) {
-      out += ` ${inst[1]} ${read_unsignedLEB128(inst.slice(2))}`
+    } else if (inst[0] === Opcodes.i32_load || inst[0] === Opcodes.i64_load || inst[0] === Opcodes.f64_load || inst[0] === Opcodes.i32_store || inst[0] === Opcodes.i64_store || inst[0] === Opcodes.f64_store || inst[0] === Opcodes.i32_store16 || inst[0] === Opcodes.i32_load16_u) {
+      out += ` ${inst[1]} ${read_unsignedLEB128(inst.slice(2))}`;
     } else for (const operand of inst.slice(1)) {
       if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block) {
         if (operand === Blocktype.void) continue;
@@ -57,7 +57,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       out += ` ;; label @${depth}`;
     }
 
-    if (inst[0] === Opcodes.br) {
+    if (inst[0] === Opcodes.br || inst[0] === Opcodes.br_if) {
       out += ` ;; goto @${depth - inst[1]}`;
     }
 

package/compiler/encoding.js

@@ -22,15 +22,15 @@ export const encodeLocal = (count, type) => [
   type
 ];
 
+// todo: this only works with integers within 32 bit range
 export const signedLEB128 = n => {
-  // todo: this only works with integers within 32 bit range
+  n |= 0;
 
   // just input for small numbers (for perf as common)
   if (n >= 0 && n <= 63) return [ n ];
   if (n >= -64 && n <= 0) return [ 128 + n ];
 
   const buffer = [];
-  n |= 0;
 
   while (true) {
     let byte = n & 0x7f;
@@ -50,6 +50,8 @@ export const signedLEB128 = n => {
 };
 
 export const unsignedLEB128 = n => {
+  n |= 0;
+
   // just input for small numbers (for perf as common)
   if (n >= 0 && n <= 127) return [ n ];
 

package/compiler/index.js

@@ -4,6 +4,8 @@ import opt from './opt.js';
 import produceSections from './sections.js';
 import decompile from './decompile.js';
 import { BuiltinPreludes } from './builtins.js';
+import toc from './2c.js';
+
 
 globalThis.decompile = decompile;
 
@@ -14,7 +16,9 @@ const bold = x => `\u001b[1m${x}\u001b[0m`;
 const areaColors = {
   codegen: [ 20, 80, 250 ],
   opt: [ 250, 20, 80 ],
-  sections: [ 20, 250, 80 ]
+  sections: [ 20, 250, 80 ],
+  alloc: [ 250, 250, 20 ],
+  '2c': [ 20, 250, 250 ]
 };
 
 globalThis.log = (area, ...args) => console.log(`\u001b[90m[\u001b[0m${rgb(...areaColors[area], area)}\u001b[90m]\u001b[0m`, ...args);
@@ -35,9 +39,16 @@ const logFuncs = (funcs, globals, exceptions) => {
   console.log();
 };
 
+const getArg = name => process.argv.find(x => x.startsWith(`-${name}=`))?.slice(name.length + 2);
+
+const writeFileSync = (typeof process !== 'undefined' ? (await import('node:fs')).writeFileSync : undefined);
+const execSync = (typeof process !== 'undefined' ? (await import('node:child_process')).execSync : undefined);
+
 export default (code, flags) => {
   globalThis.optLog = process.argv.includes('-opt-log');
   globalThis.codeLog = process.argv.includes('-code-log');
+  globalThis.allocLog = process.argv.includes('-alloc-log');
+  globalThis.regexLog = process.argv.includes('-regex-log');
 
   for (const x in BuiltinPreludes) {
     if (code.indexOf(x + '(') !== -1) code = BuiltinPreludes[x] + code;
@@ -63,5 +74,45 @@ export default (code, flags) => {
   const sections = produceSections(funcs, globals, tags, pages, flags);
   if (flags.includes('info')) console.log(`4. produced sections in ${(performance.now() - t3).toFixed(2)}ms`);
 
-  return { wasm: sections, funcs, globals, tags, exceptions, pages };
+  if (allocLog) {
+    const wasmPages = Math.ceil((pages.size * pageSize) / 65536);
+    const bytes = wasmPages * 65536;
+    log('alloc', `\x1B[1mallocated ${bytes / 1024}KiB\x1B[0m for ${pages.size} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}`);
+    // console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n'));
+  }
+
+  const out = { wasm: sections, funcs, globals, tags, exceptions, pages };
+
+  const target = getArg('target') ?? getArg('t') ?? 'wasm';
+  const outFile = getArg('o');
+
+  if (target === 'c') {
+    const c = toc(out);
+
+    if (outFile) {
+      writeFileSync(outFile, c);
+    } else {
+      console.log(c);
+    }
+
+    process.exit();
+  }
+
+  if (target === 'native') {
+    const compiler = getArg('compiler') ?? 'clang';
+    const cO = getArg('cO') ?? 'O3';
+
+    const tmpfile = 'tmp.c';
+    const args = [ compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO ];
+
+    const c = toc(out);
+    writeFileSync(tmpfile, c);
+
+    // obvious command escape is obvious
+    execSync(args.join(' '), { stdio: 'inherit' });
+
+    process.exit();
+  }
+
+  return out;
 };

package/compiler/opt.js

@@ -1,5 +1,6 @@
 import { Opcodes, Valtype } from "./wasmSpec.js";
 import { number } from "./embedding.js";
+import { read_signedLEB128, read_ieee754_binary64 } from "./encoding.js";
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -20,7 +21,7 @@ export default (funcs, globals) => {
   if (optLevel === 0) return;
 
   const tailCall = process.argv.includes('-tail-call');
-  if (tailCall) log('opt', 'tail call proposal is not widely implemented! (you used -tail-call)');
+  if (tailCall) log('opt', 'warning: tail call proposal is not widely implemented! (you used -tail-call)');
 
   if (optLevel >= 2 && !process.argv.includes('-opt-no-inline')) {
     // inline pass (very WIP)
@@ -95,7 +96,6 @@ export default (funcs, globals) => {
         }
 
         if (t.index > c.index) t.index--; // adjust index if after removed func
-        if (c.memory) t.memory = true;
       }
 
       funcs.splice(funcs.indexOf(c), 1); // remove func from funcs
@@ -142,7 +142,7 @@ export default (funcs, globals) => {
             depth--;
             if (depth <= 0) break;
           }
-          if (op === Opcodes.br) {
+          if (op === Opcodes.br || op === Opcodes.br_if) {
             hasBranch = true;
             break;
           }
@@ -213,9 +213,9 @@ export default (funcs, globals) => {
         // i32.const 0
         // drop
         // -->
-        // <nothing>>
+        // <nothing>
 
-        wasm.splice(i - 1, 2); // remove this inst
+        wasm.splice(i - 1, 2); // remove these inst
         i -= 2;
         continue;
       }
@@ -259,6 +259,36 @@ export default (funcs, globals) => {
         continue;
       }
 
+      if (lastInst[0] === Opcodes.const && (inst === Opcodes.i32_to || inst === Opcodes.i32_to_u)) {
+        // change const and immediate i32 convert to i32 const
+        // f64.const 0
+        // i32.trunc_sat_f64_s || i32.trunc_sat_f64_u
+        // -->
+        // i32.const 0
+
+        wasm[i - 1] = number((valtype === 'f64' ? read_ieee754_binary64 : read_signedLEB128)(lastInst.slice(1)), Valtype.i32)[0]; // f64.const -> i32.const
+
+        wasm.splice(i, 1); // remove this inst
+        i--;
+        if (optLog) log('opt', `converted const -> i32 convert into i32 const`);
+        continue;
+      }
+
+      if (lastInst[0] === Opcodes.i32_const && (inst === Opcodes.i32_from || inst === Opcodes.i32_from_u)) {
+        // change i32 const and immediate convert to const (opposite way of previous)
+        // i32.const 0
+        // f64.convert_i32_s || f64.convert_i32_u
+        // -->
+        // f64.const 0
+
+        wasm[i - 1] = number(read_signedLEB128(lastInst.slice(1)))[0]; // i32.const -> f64.const
+
+        wasm.splice(i, 1); // remove this inst
+        i--;
+        if (optLog) log('opt', `converted i32 const -> convert into const`);
+        continue;
+      }
+
       if (tailCall && lastInst[0] === Opcodes.call && inst[0] === Opcodes.return) {
         // replace call, return with tail calls (return_call)
         // call X

package/compiler/parse.js

@@ -1,4 +1,5 @@
-const { parse } = (await import(globalThis.document ? 'https://esm.sh/acorn' : 'acorn'));
+import { parse } from 'acorn';
+// const { parse } = (await import(globalThis.document ? 'https://esm.sh/acorn' : 'acorn'));
 
 export default (input, flags) => {
   return parse(input, {

package/compiler/prototype.js

@@ -15,7 +15,8 @@ const TYPES = {
   bigint: 0xffffffffffff7,
 
   // these are not "typeof" types but tracked internally
-  _array: 0xffffffffffff8
+  _array: 0xfffffffffff0f,
+  _regexp: 0xfffffffffff1f
 };
 
 // todo: turn these into built-ins once arrays and these become less hacky
@@ -25,7 +26,6 @@ export const PrototypeFuncs = function() {
 
   this[TYPES._array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
-    // todo: out of bounds (>) properly
     at: (pointer, length, wIndex, iTmp) => [
       ...wIndex,
       Opcodes.i32_to,
@@ -147,7 +147,6 @@ export const PrototypeFuncs = function() {
   this[TYPES._array].push.noArgRetLength = true;
 
   this[TYPES.string] = {
-    // todo: out of bounds properly
     at: (pointer, length, wIndex, iTmp, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
@@ -157,9 +156,9 @@ export const PrototypeFuncs = function() {
         [ Opcodes.drop ],
 
         ...number(0, Valtype.i32), // base 0 for store later
-        Opcodes.i32_to_u,
 
         ...wIndex,
+        Opcodes.i32_to_u,
         [ Opcodes.local_tee, iTmp ],
 
         // if index < 0: access index + array length
@@ -265,7 +264,7 @@ export const PrototypeFuncs = function() {
     },
   };
 
-  this[TYPES.string].at.local = valtypeBinary;
+  this[TYPES.string].at.local = Valtype.i32;
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
   this[TYPES.string].charCodeAt.local = Valtype.i32;

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]}`);
@@ -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 ]))
@@ -145,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`));
@@ -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-8c0bdaa",
+  "version": "0.0.0-ba812f2",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/publish.js

@@ -6,6 +6,8 @@ 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' });
 
-execSync(`git checkout HEAD -- package.json`, { stdio: 'inherit' });
+fs.writeFileSync('package.json', packageJson);

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}`)
+- 🔴 anchors
+  - 🔴 beginning (eg `^a`)
+  - 🔴 end (eg `a$`)
+  - 🔴 word boundary assertion (eg `\b\B`)