porffor 0.2.0-aea77ff → 0.2.0-b9abe0d

package/compiler/prototype.js

@@ -2,29 +2,16 @@ import { Opcodes, Blocktype, Valtype, ValtypeSize, PageSize } from "./wasmSpec.j
 import { number } from "./embedding.js";
 import { unsignedLEB128 } from "./encoding.js";
 import { UNDEFINED } from "./builtins.js";
-
-// todo: do not duplicate this
-const TYPES = {
-  number: 0x00,
-  boolean: 0x01,
-  string: 0x02,
-  undefined: 0x03,
-  object: 0x04,
-  function: 0x05,
-  symbol: 0x06,
-  bigint: 0x07,
-
-  // these are not "typeof" types but tracked internally
-  _array: 0x10,
-  _regexp: 0x11
-};
+import Prefs from './prefs.js';
+import { TYPES } from './types.js';
 
 // todo: turn these into built-ins once arrays and these become less hacky
 
 export const PrototypeFuncs = function() {
-  const noUnlikelyChecks = process.argv.includes('-funsafe-no-unlikely-proto-checks');
-  let zeroChecks = process.argv.find(x => x.startsWith('-funsafe-zero-proto-checks='));
-  if (zeroChecks) zeroChecks = zeroChecks.split('=')[1].split(',').reduce((acc, x) => { acc[x.toLowerCase()] = true; return acc; }, {});
+  const noUnlikelyChecks = Prefs.funsafeNoUnlikelyProtoChecks;
+
+  let zeroChecks;
+  if (Prefs.zeroChecks) zeroChecks = Prefs.zeroChecks.split('=')[1].split(',').reduce((acc, x) => { acc[x.toLowerCase()] = true; return acc; }, {});
     else zeroChecks = {};
 
   this[TYPES._array] = {
@@ -71,7 +58,7 @@ export const PrototypeFuncs = function() {
     ],
 
     // todo: only for 1 argument
-    push: (pointer, length, wNewMember) => [
+    push: (pointer, length, wNewMember, _1, _2, _3, unusedValue) => [
       // get memory offset of array at last index (length)
       ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
@@ -92,22 +79,28 @@ export const PrototypeFuncs = function() {
         ...number(1, Valtype.i32),
         [ Opcodes.i32_add ],
 
-        ...length.setCachedI32(),
-        ...length.getCachedI32(),
+        ...(unusedValue() ? [] : [
+          ...length.setCachedI32(),
+          ...length.getCachedI32(),
+        ])
       ]),
 
-      ...length.getCachedI32(),
-      Opcodes.i32_from_u
+      ...(unusedValue() ? [] : [
+        ...length.getCachedI32(),
+        Opcodes.i32_from_u
+      ])
 
       // ...length.get()
     ],
 
-    pop: (pointer, length) => [
+    pop: (pointer, length, _1, _2, _3, _4, unusedValue) => [
       // if length == 0, noop
       ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
-      ...number(UNDEFINED),
+      ...(unusedValue() ? [] : [
+        ...number(UNDEFINED),
+      ]),
       [ Opcodes.br, 1 ],
       [ Opcodes.end ],
 
@@ -119,25 +112,29 @@ export const PrototypeFuncs = function() {
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ],
 
-        ...length.setCachedI32(),
-        ...length.getCachedI32(),
+        ...(unusedValue() ? [] : [
+          ...length.setCachedI32(),
+          ...length.getCachedI32(),
+        ])
       ]),
 
       // load last element
-      ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
-      [ Opcodes.i32_mul ],
+      ...(unusedValue() ? [] : [
+        ...length.getCachedI32(),
+        ...number(ValtypeSize[valtype], Valtype.i32),
+        [ Opcodes.i32_mul ],
 
-      ...pointer,
-      [ Opcodes.i32_add ],
+        ...pointer,
+        [ Opcodes.i32_add ],
 
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+        [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+      ])
     ],
 
     shift: (pointer, length) => [
       // if length == 0, noop
       ...length.getCachedI32(),
-      Opcodes.i32_eqz,
+      [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
       [ Opcodes.br, 1 ],
@@ -331,8 +328,8 @@ export const PrototypeFuncs = function() {
         ...number(0, Valtype.i32), // base 0 for store later
 
         ...wIndex,
-
         Opcodes.i32_to,
+
         ...number(ValtypeSize.i16, Valtype.i32),
         [ Opcodes.i32_mul ],
 
@@ -372,7 +369,7 @@ export const PrototypeFuncs = function() {
 
           ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
           [ Opcodes.if, Blocktype.void ],
-          ...number(NaN),
+          ...number(valtype === 'i32' ? -1 : NaN),
           [ Opcodes.br, 1 ],
           [ Opcodes.end ],
 
@@ -472,8 +469,151 @@ export const PrototypeFuncs = function() {
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
   this[TYPES.string].charCodeAt.local = Valtype.i32;
+  this[TYPES.string].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
   this[TYPES.string].isWellFormed.local = Valtype.i32;
   this[TYPES.string].isWellFormed.local2 = Valtype.i32;
   this[TYPES.string].isWellFormed.returnType = TYPES.boolean;
+
+  if (Prefs.bytestring) {
+    this[TYPES._bytestring] = {
+      at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
+        const [ newOut, newPointer ] = arrayShell(1, 'i8');
+
+        return [
+          // setup new/out array
+          ...newOut,
+          [ Opcodes.drop ],
+
+          ...number(0, Valtype.i32), // base 0 for store later
+
+          ...wIndex,
+          Opcodes.i32_to_u,
+          [ Opcodes.local_tee, iTmp ],
+
+          // if index < 0: access index + array length
+          ...number(0, Valtype.i32),
+          [ Opcodes.i32_lt_s ],
+          [ Opcodes.if, Blocktype.void ],
+          [ Opcodes.local_get, iTmp ],
+          ...length.getCachedI32(),
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_set, iTmp ],
+          [ Opcodes.end ],
+
+          // if still < 0 or >= length: return undefined
+          [ Opcodes.local_get, iTmp ],
+          ...number(0, Valtype.i32),
+          [ Opcodes.i32_lt_s ],
+
+          [ Opcodes.local_get, iTmp ],
+          ...length.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
+          [ Opcodes.i32_or ],
+
+          [ Opcodes.if, Blocktype.void ],
+          ...number(UNDEFINED),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
+
+          [ Opcodes.local_get, iTmp ],
+
+          ...pointer,
+          [ Opcodes.i32_add ],
+
+          // load current string ind {arg}
+          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+          // store to new string ind 0
+          [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+          // return new string (pointer)
+          ...number(newPointer)
+        ];
+      },
+
+      // todo: out of bounds properly
+      charAt: (pointer, length, wIndex, _1, _2, arrayShell) => {
+        const [ newOut, newPointer ] = arrayShell(1, 'i8');
+
+        return [
+          // setup new/out array
+          ...newOut,
+          [ Opcodes.drop ],
+
+          ...number(0, Valtype.i32), // base 0 for store later
+
+          ...wIndex,
+          Opcodes.i32_to,
+
+          ...pointer,
+          [ Opcodes.i32_add ],
+
+          // load current string ind {arg}
+          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+          // store to new string ind 0
+          [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+          // return new string (page)
+          ...number(newPointer)
+        ];
+      },
+
+      charCodeAt: (pointer, length, wIndex, iTmp) => {
+        return [
+          ...wIndex,
+          Opcodes.i32_to,
+
+          ...(zeroChecks.charcodeat ? [] : [
+            [ Opcodes.local_set, iTmp ],
+
+            // index < 0
+            ...(noUnlikelyChecks ? [] : [
+              [ Opcodes.local_get, iTmp ],
+              ...number(0, Valtype.i32),
+              [ Opcodes.i32_lt_s ],
+            ]),
+
+            // index >= length
+            [ Opcodes.local_get, iTmp ],
+            ...length.getCachedI32(),
+            [ Opcodes.i32_ge_s ],
+
+            ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+            [ Opcodes.if, Blocktype.void ],
+            ...number(valtype === 'i32' ? -1 : NaN),
+            [ Opcodes.br, 1 ],
+            [ Opcodes.end ],
+
+            [ Opcodes.local_get, iTmp ],
+          ]),
+
+          ...pointer,
+          [ Opcodes.i32_add ],
+
+          // load current string ind {arg}
+          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+          Opcodes.i32_from_u
+        ];
+      },
+
+      isWellFormed: () => {
+        return [
+          // we know it must be true as it is a bytestring lol
+          ...number(1)
+        ]
+      }
+    };
+
+    this[TYPES._bytestring].at.local = Valtype.i32;
+    this[TYPES._bytestring].at.returnType = TYPES._bytestring;
+    this[TYPES._bytestring].charAt.returnType = TYPES._bytestring;
+    this[TYPES._bytestring].charCodeAt.local = Valtype.i32;
+    this[TYPES._bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
+
+    this[TYPES._bytestring].isWellFormed.local = Valtype.i32;
+    this[TYPES._bytestring].isWellFormed.local2 = Valtype.i32;
+    this[TYPES._bytestring].isWellFormed.returnType = TYPES.boolean;
+  }
 };

package/compiler/types.js

@@ -0,0 +1,37 @@
+export const TYPES = {
+  number: 0x00,
+  boolean: 0x01,
+  string: 0x02,
+  undefined: 0x03,
+  object: 0x04,
+  function: 0x05,
+  symbol: 0x06,
+  bigint: 0x07
+};
+
+export const TYPE_NAMES = {
+  [TYPES.number]: 'Number',
+  [TYPES.boolean]: 'Boolean',
+  [TYPES.string]: 'String',
+  [TYPES.undefined]: 'undefined',
+  [TYPES.object]: 'Object',
+  [TYPES.function]: 'Function',
+  [TYPES.symbol]: 'Symbol',
+  [TYPES.bigint]: 'BigInt'
+};
+
+export const INTERNAL_TYPE_BASE = 0x10;
+let internalTypeIndex = INTERNAL_TYPE_BASE;
+const registerInternalType = name => {
+  const n = internalTypeIndex++;
+  TYPES['_' + name.toLowerCase()] = n;
+  TYPE_NAMES[n] = name;
+};
+
+// note: when adding a new internal type, please also add a deserializer to wrap.js
+// (it is okay to add a throw todo deserializer for wips)
+
+registerInternalType('Array');
+registerInternalType('RegExp');
+registerInternalType('ByteString');
+registerInternalType('Date');

package/compiler/wasmSpec.js

@@ -1,4 +1,13 @@
-import { enumify } from "../util/enum.js";
+const enumify = (...args) => {
+  const obj = {};
+
+  for (let i = 0; i < args.length; i++) {
+    obj[i] = args[i];
+    obj[args[i]] = i;
+  }
+
+  return obj;
+};
 
 export const Section = enumify('custom', 'type', 'import', 'func', 'table', 'memory', 'global', 'export', 'start', 'element', 'code', 'data', 'data_count', 'tag');
 export const ExportDesc = enumify('func', 'table', 'mem', 'global', 'tag');
@@ -32,17 +41,16 @@ export const Opcodes = {
   throw: 0x08,
   rethrow: 0x09,
 
-  call: 0x10,
-  call_indirect: 0x11,
-  return_call: 0x12,
-  return_call_indirect: 0x13,
-
   end: 0x0b,
   br: 0x0c,
   br_if: 0x0d,
   br_table: 0x0e,
   return: 0x0f,
+
   call: 0x10,
+  call_indirect: 0x11,
+  return_call: 0x12,
+  return_call_indirect: 0x13,
 
   drop: 0x1a,
 
@@ -57,15 +65,26 @@ export const Opcodes = {
   i64_load: 0x29,
   f64_load: 0x2b,
 
+  i32_load8_s: 0x2c,
+  i32_load8_u: 0x2d,
   i32_load16_s: 0x2e,
   i32_load16_u: 0x2f,
 
-  i32_store16: 0x3b,
+  i64_load8_s: 0x30,
+  i64_load8_u: 0x31,
+  i64_load16_s: 0x32,
+  i64_load16_u: 0x33,
 
   i32_store: 0x36,
   i64_store: 0x37,
   f64_store: 0x39,
 
+  i32_store8: 0x3a,
+  i32_store16: 0x3b,
+
+  i64_store8: 0x3c,
+  i64_store16: 0x3d,
+
   memory_grow: 0x40,
 
   i32_const: 0x41,
@@ -97,6 +116,8 @@ export const Opcodes = {
   i32_shl: 0x74,
   i32_shr_s: 0x75,
   i32_shr_u: 0x76,
+  i32_rotl: 0x77,
+  i32_rotr: 0x78,
 
   i64_eqz: 0x50,
   i64_eq: 0x51,
@@ -120,6 +141,7 @@ export const Opcodes = {
   i64_shr_s: 0x87,
   i64_shr_u: 0x88,
   i64_rotl: 0x89,
+  i64_rotr: 0x8a,
 
   f64_eq: 0x61,
   f64_ne: 0x62,

package/compiler/wrap.js

@@ -1,55 +1,56 @@
 import compile from './index.js';
 import decompile from './decompile.js';
 import { encodeVector, encodeLocal } from './encoding.js';
-// import fs from 'node:fs';
+import Prefs from './prefs.js';
+import { log } from './log.js';
+import { TYPES } from './types.js';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
-const typeBase = 0x00;
-const internalTypeBase = 0x10;
-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
-  [internalTypeBase]: '_array',
-  [internalTypeBase + 1]: '_regexp'
-};
-
 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, c } = compile(source, flags);
 
+  globalThis.porfDebugInfo = { funcs, globals };
+
   if (source.includes('export function')) flags.push('module');
 
-  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  // (await import('node: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`));
+  if (Prefs.profileCompiler) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
   const t2 = performance.now();
 
   let instance;
   try {
-    0, { instance } = await WebAssembly.instantiate(wasm, {
+    let wasmEngine = WebAssembly;
+    if (Prefs.asur) {
+      log.warning('wrap', 'using our !experimental! asur wasm engine instead of host to run');
+      wasmEngine = await import('../asur/index.js');
+    }
+
+    0, { instance } = await wasmEngine.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)),
-        t: _ => performance.now(),
+        t: () => performance.now(),
+        u: () => performance.timeOrigin,
+        y: () => {},
+        z: () => {},
         ...customImports
       }
     });
   } catch (e) {
-    const funcInd = parseInt(e.message.match(/function #([0-9]+) /)[1]);
-    const blobOffset = parseInt(e.message.split('@')[1]);
+    // only backtrace for runner, not test262/etc
+    if (!process.argv[1].includes('/runner')) throw e;
+
+    const funcInd = parseInt(e.message.match(/function #([0-9]+) /)?.[1]);
+    const blobOffset = parseInt(e.message.split('@')?.[1]);
+
+    if (!funcInd) throw e;
 
     // convert blob offset -> function wasm offset.
     // this is not good code and is somewhat duplicated
@@ -127,7 +128,7 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
   }
 
   times.push(performance.now() - t2);
-  if (flags.includes('info')) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
+  if (Prefs.profileCompiler) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
 
   const exports = {};
 
@@ -155,12 +156,29 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
         // if (ret >= typeBase && ret <= typeBase + 8) return ret > (typeBase + 7) ? 'object' : TYPES[ret];
 
-        switch (TYPES[type]) {
-          case 'boolean': return Boolean(ret);
-          case 'undefined': return undefined;
-          case 'object': return ret === 0 ? null : {};
+        switch (type) {
+          case TYPES.boolean: return Boolean(ret);
+          case TYPES.undefined: return undefined;
+          case TYPES.object: return ret === 0 ? null : {};
 
-          case '_array': {
+          case TYPES.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('');
+          }
+
+          case TYPES.function: {
+            // wasm func index, including all imports
+            const func = funcs.find(x => (x.originalIndex ?? x.index) === ret);
+            // if (!func) return ret;
+            if (!func) return function () {};
+
+            // make fake empty func for repl/etc
+            return {[func.name]() {}}[func.name];
+          }
+
+          case TYPES._array: {
             const pointer = ret;
             const length = new Int32Array(memory.buffer, pointer, 1);
 
@@ -170,20 +188,15 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
             return Array.from(new Float64Array(buf));
           }
 
-          case 'string': {
+          case TYPES._bytestring: {
             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('');
+            return Array.from(new Uint8Array(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];
+          case TYPES._date: {
+            return new Date(ret);
           }
 
           default: return ret;

package/package.json

@@ -1,21 +1,25 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.2.0-aea77ff",
+  "version": "0.2.0-b9abe0d",
   "author": "CanadaHonk",
   "license": "MIT",
+  "scripts": {
+    "precompile": "node ./compiler/precompile.js"
+  },
   "dependencies": {
-    "acorn": "^8.9.0"
+    "acorn": "^8.11.3",
+    "node-repl-polyfill": "^0.1.1"
   },
   "optionalDependencies": {
-    "@babel/parser": "^7.23.6",
+    "@babel/parser": "^7.24.4",
     "hermes-parser": "^0.18.2",
     "meriyah": "^4.3.9"
   },
   "bin": {
     "porf": "./runner/index.js"
   },
-  "main": "./runner/index.js",
+  "main": "./compiler/wrap.js",
   "type": "module",
   "repository": {
     "type": "git",
@@ -25,4 +29,4 @@
     "url": "https://github.com/CanadaHonk/porffor/issues"
   },
   "homepage": "https://porffor.goose.icu"
-}
+}

package/porf

@@ -0,0 +1,4 @@
+#!/bin/sh
+node runner/index.js "$@"
+# deno run -A runner/index.js "$@"
+# bun runner/index.js "$@"

package/rhemyn/compile.js

@@ -2,6 +2,7 @@ import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from '../compiler/
 import { number } from '../compiler/embedding.js';
 import { signedLEB128, unsignedLEB128 } from '../compiler/encoding.js';
 import parse from './parse.js';
+import Prefs from '../compiler/prefs.js';
 
 // local indexes
 const BasePointer = 0; // base string pointer
@@ -80,7 +81,7 @@ const generate = (node, negated = false, get = true, func = 'test') => {
         })[func], Valtype.i32)
       ];
 
-      if (globalThis.regexLog) {
+      if (Prefs.regexLog) {
         const underline = x => `\u001b[4m\u001b[1m${x}\u001b[0m`;
         console.log(`\n${underline('ast')}`);
         console.log(node);
@@ -159,7 +160,7 @@ const generateSet = (node, negated, get) => {
     ];
   }
 
-  out = out.concat(new Array(node.body.length - 1).fill(negated ? [ Opcodes.i32_or ] : [ Opcodes.i32_and ]));
+  if (node.body.length > 0) out = out.concat(new Array(node.body.length - 1).fill(negated ? [ Opcodes.i32_or ] : [ Opcodes.i32_and ]));
 
   return [
     ...out,
@@ -187,7 +188,8 @@ const generateRange = (node, negated, get) => {
 };
 
 const generateGroup = (node, negated, get) => {
-
+  // todo
+  return [];
 };
 
 export const test = (regex, index = 0, name = 'regex_test_' + regex) => outputFunc(generate(parse(regex), false, true, 'test'), name, index);