porffor 0.2.0-5e33105 → 0.2.0-6aff0fa

package/compiler/prototype.js

@@ -2,6 +2,7 @@ import { Opcodes, Blocktype, Valtype, ValtypeSize, PageSize } from "./wasmSpec.j
 import { number } from "./embedding.js";
 import { unsignedLEB128 } from "./encoding.js";
 import { UNDEFINED } from "./builtins.js";
+import Prefs from './prefs.js';
 
 // todo: do not duplicate this
 const TYPES = {
@@ -16,15 +17,17 @@ const TYPES = {
 
   // these are not "typeof" types but tracked internally
   _array: 0x10,
-  _regexp: 0x11
+  _regexp: 0x11,
+  _bytestring: 0x12
 };
 
 // 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 +74,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 +95,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,19 +128,23 @@ 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) => [
@@ -331,8 +344,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 +385,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 +485,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/sections.js

@@ -3,6 +3,7 @@ import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128 }
 import { number } from './embedding.js';
 import { importedFuncs } from './builtins.js';
 import { log } from "./log.js";
+import Prefs from './prefs.js';
 
 const createSection = (type, data) => [
   type,
@@ -26,12 +27,12 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
 
-  const compileHints = process.argv.includes('-compile-hints');
+  const compileHints = Prefs.compileHints;
   if (compileHints) log.warning('sections', '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]}`);
+    if (Prefs.optLog) log('sections', `getType(${JSON.stringify(params)}, ${JSON.stringify(returns)}) -> ${hash} | cache: ${typeCache[hash]}`);
     if (optLevel >= 1 && typeCache[hash] !== undefined) return typeCache[hash];
 
     const type = [ FuncType, ...encodeVector(params), ...encodeVector(returns) ];
@@ -79,7 +80,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
   }
   globalThis.importFuncs = importFuncs;
 
-  if (optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
+  if (Prefs.optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
 
   const importSection = importFuncs.length === 0 ? [] : createSection(
     Section.import,
@@ -95,7 +96,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
   // https://github.com/WebAssembly/design/issues/1473#issuecomment-1431274746
   const chSection = !compileHints ? [] : customSection(
     'compilationHints',
-    // for now just do everything as optimise eager
+    // for now just do everything as optimize eager
     encodeVector(funcs.map(_ => chHint(0x02, 0x02, 0x02)))
   );
 
@@ -106,7 +107,7 @@ export default (funcs, globals, tags, pages, data, 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);
+  if (Prefs.alwaysMemory && pages.size === 0) pages.set('-always-memory', 0);
   if (optLevel === 0) pages.set('O0 precaution', 0);
 
   const usesMemory = pages.size > 0;
@@ -169,7 +170,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
     unsignedLEB128(data.length)
   );
 
-  if (process.argv.includes('-sections')) console.log({
+  if (Prefs.sections) console.log({
     typeSection: typeSection.map(x => x.toString(16)),
     importSection: importSection.map(x => x.toString(16)),
     funcSection: funcSection.map(x => x.toString(16)),

package/compiler/wasmSpec.js

@@ -32,17 +32,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 +56,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,

package/compiler/wrap.js

@@ -1,6 +1,8 @@
 import compile from './index.js';
 import decompile from './decompile.js';
-import fs from 'node:fs';
+import { encodeVector, encodeLocal } from './encoding.js';
+import Prefs from './prefs.js';
+import { log } from './log.js';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
@@ -18,7 +20,8 @@ const TYPES = {
 
   // internal
   [internalTypeBase]: '_array',
-  [internalTypeBase + 1]: '_regexp'
+  [internalTypeBase + 1]: '_regexp',
+  [internalTypeBase + 2]: '_bytestring'
 };
 
 export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
@@ -29,20 +32,110 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   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`));
 
   const t2 = performance.now();
-  const { instance } = await WebAssembly.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(),
-      ...customImports
+
+  let instance;
+  try {
+    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(),
+        ...customImports
+      }
+    });
+  } catch (e) {
+    // 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]);
+
+    // convert blob offset -> function wasm offset.
+    // this is not good code and is somewhat duplicated
+    // I just want it to work for debugging, I don't care about perf/yes
+
+    const func = funcs.find(x => x.index === funcInd);
+    const locals = Object.values(func.locals).sort((a, b) => a.idx - b.idx).slice(func.params.length).sort((a, b) => a.idx - b.idx);
+
+    let localDecl = [], typeCount = 0, lastType;
+    for (let i = 0; i < locals.length; i++) {
+      const local = locals[i];
+      if (i !== 0 && local.type !== lastType) {
+        localDecl.push(encodeLocal(typeCount, lastType));
+        typeCount = 0;
+      }
+
+      typeCount++;
+      lastType = local.type;
+    }
+
+    if (typeCount !== 0) localDecl.push(encodeLocal(typeCount, lastType));
+
+    const toFind = encodeVector(localDecl).concat(func.wasm.flat().filter(x => x != null && x <= 0xff).slice(0, 40));
+
+    let i = 0;
+    for (; i < wasm.length; i++) {
+      let mismatch = false;
+      for (let j = 0; j < toFind.length; j++) {
+        if (wasm[i + j] !== toFind[j]) {
+          mismatch = true;
+          break;
+        }
+      }
+
+      if (!mismatch) break;
+    }
+
+    if (i === wasm.length) throw e;
+
+    const offset = (blobOffset - i) + encodeVector(localDecl).length;
+
+    let cumLen = 0;
+    i = 0;
+    for (; i < func.wasm.length; i++) {
+      cumLen += func.wasm[i].filter(x => x != null && x <= 0xff).length;
+      if (cumLen === offset) break;
     }
-  });
+
+    if (cumLen !== offset) throw e;
+
+    i -= 1;
+
+    console.log(`\x1B[35m\x1B[1mporffor backtrace\u001b[0m`);
+
+    console.log('\x1B[4m' + func.name + '\x1B[0m');
+
+    const surrounding = 6;
+
+    const decomp = decompile(func.wasm.slice(i - surrounding, i + surrounding + 1), '', 0, func.locals, func.params, func.returns, funcs, globals, exceptions).slice(0, -1).split('\n');
+
+    const noAnsi = s => s.replace(/\u001b\[[0-9]+m/g, '');
+    let longest = 0;
+    for (let j = 0; j < decomp.length; j++) {
+      longest = Math.max(longest, noAnsi(decomp[j]).length);
+    }
+
+    const middle = Math.floor(decomp.length / 2);
+    decomp[middle] = `\x1B[47m\x1B[30m${noAnsi(decomp[middle])}${'\u00a0'.repeat(longest - noAnsi(decomp[middle]).length)}\x1B[0m`;
+
+    console.log('\x1B[90m...\x1B[0m');
+    console.log(decomp.join('\n'));
+    console.log('\x1B[90m...\x1B[0m\n');
+
+    throw e;
+  }
 
   times.push(performance.now() - t2);
   if (flags.includes('info')) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
@@ -95,10 +188,18 @@ 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 '_bytestring': {
+            const pointer = ret;
+            const length = new Int32Array(memory.buffer, pointer, 1);
+
+            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;
+            // if (!func) return ret;
+            if (!func) return function () {};
 
             // make fake empty func for repl/etc
             return {[func.name]() {}}[func.name];

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.2.0-5e33105",
+  "version": "0.2.0-6aff0fa",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/porf

@@ -0,0 +1,2 @@
+#!/bin/sh
+node 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);

package/runner/index.js

@@ -3,6 +3,8 @@
 import compile from '../compiler/wrap.js';
 import fs from 'node:fs';
 
+const start = performance.now();
+
 if (process.argv.includes('-compile-hints')) {
   const v8 = await import('node:v8');
   v8.setFlagsFromString(`--experimental-wasm-compilation-hints`);
@@ -15,9 +17,28 @@ if (process.argv.includes('-compile-hints')) {
   // --experimental-wasm-return-call (on by default)
 }
 
-const file = process.argv.slice(2).find(x => x[0] !== '-');
+let file = process.argv.slice(2).find(x => x[0] !== '-');
+if (['run', 'wasm', 'native', 'c', 'profile'].includes(file)) {
+  if (file === 'profile') {
+    process.argv.splice(process.argv.indexOf(file), 1);
+    await import('./profiler.js');
+    await new Promise(() => {});
+  }
+
+  if (['wasm', 'native', 'c'].includes(file)) {
+    process.argv.push(`-target=${file}`);
+  }
+
+  file = process.argv.slice(process.argv.indexOf(file) + 1).find(x => x[0] !== '-');
+
+  const nonOptOutFile = process.argv.slice(process.argv.indexOf(file) + 1).find(x => x[0] !== '-');
+  if (nonOptOutFile) {
+    process.argv.push(`-o=${nonOptOutFile}`);
+  }
+}
+
 if (!file) {
-  if (process.argv.includes('-v')) {
+  if (process.argv.includes('-v') || process.argv.includes('--version')) {
     // just print version
     console.log((await import('./version.js')).default);
     process.exit(0);
@@ -52,4 +73,6 @@ try {
 } catch (e) {
   if (cache) process.stdout.write(cache);
   console.error(process.argv.includes('-i') ? e : `${e.constructor.name}: ${e.message}`);
-}
+}
+
+if (process.argv.includes('-t')) console.log(`\n\ntotal time: ${(performance.now() - start).toFixed(2)}ms`);