porffor 0.50.26 → 0.50.28

package/CONTRIBUTING.md

@@ -291,7 +291,7 @@ i32.eq
 i32.and
 ```
 
-This part is a little more complicated, first you have to understand how Wasm represents function parameters and local variables in general. When looking at the decompiled output of something like `let a = 1;`, you'll likely see something like this:
+This part is a little more complicated, first you have to understand how Wasm represents function parameters and local variables in general. When looking at the disassembled output of something like `let a = 1;`, you'll likely see something like this:
 ```
 f64.const 1
 i32.const 1

package/README.md

@@ -107,7 +107,7 @@ Porffor can run Test262 via some hacks/transforms which remove unsupported featu
   - `builtins_precompiled.js`: dynamically generated builtins from the `builtins/` folder
   - `codegen.js`: code (wasm) generation, ast -> wasm. The bulk of the effort
   - `cyclone.js`: wasm partial constant evaluator (it is fast and dangerous hence "cyclone")
-  - `decompile.js`: basic wasm decompiler for debug info
+  - `disassemble.js`: wasm disassembler using internal debug info
   - `embedding.js`: utils for embedding consts
   - `encoding.js`: utils for encoding things as bytes as wasm expects
   - `expression.js`: mapping most operators to an opcode (advanced are as built-ins eg `f64_%`)

package/compiler/assemble.js

@@ -1,5 +1,5 @@
 import { Valtype, FuncType, ExportDesc, Section, Magic, Opcodes, PageSize, Reftype } from './wasmSpec.js';
-import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128, unsignedLEB128_into, signedLEB128_into, ieee754_binary64, ieee754_binary64_into, unsignedLEB128_length } from './encoding.js';
+import { encodeVector, encodeString, unsignedLEB128, signedLEB128, unsignedLEB128_into, signedLEB128_into, ieee754_binary64, ieee754_binary64_into, unsignedLEB128_length } from './encoding.js';
 import { importedFuncs } from './builtins.js';
 import { log } from './log.js';
 import './prefs.js';

package/compiler/builtins.js

@@ -364,13 +364,13 @@ export const BuiltinFuncs = function() {
   const prngSeed0 = (Math.random() * (2 ** 30)) | 0, prngSeed1 = (Math.random() * (2 ** 30)) | 0;
 
   const prng = ({
-    'lcg32_glibc': {
+    'lcg32': {
       globals: [ Valtype.i32 ],
       locals: [],
       returns: Valtype.i32,
       wasm: [
+        // use glibc/musl's constants
         // seed = (MULTIPLIER * seed + INCREMENT) % MODULUS
-        // MULTIPLIER * state0
         [ Opcodes.global_get, 0 ],
         number(1103515245, Valtype.i32),
         [ Opcodes.i32_mul ],
@@ -380,30 +380,8 @@ export const BuiltinFuncs = function() {
         [ Opcodes.i32_add ],
 
         // % MODULUS
-        number(2 ** 31, Valtype.i32),
-        [ Opcodes.i32_rem_s ],
-
-        // state0 =
-        [ Opcodes.global_set, 0 ],
-
-        // state0
-        [ Opcodes.global_get, 0 ],
-      ],
-    },
-    'lcg32_minstd': {
-      globals: [ Valtype.i32 ],
-      locals: [],
-      returns: Valtype.i32,
-      wasm: [
-        // seed = (MULTIPLIER * seed + INCREMENT) % MODULUS
-        // MULTIPLIER * state0
-        [ Opcodes.global_get, 0 ],
-        number(48271, Valtype.i32),
-        [ Opcodes.i32_mul ],
-
-        // % MODULUS
-        number((2 ** 31) - 1, Valtype.i32),
-        [ Opcodes.i32_rem_s ],
+        number(0x7fffffff, Valtype.i32),
+        [ Opcodes.i32_and ],
 
         // state0 =
         [ Opcodes.global_set, 0 ],
@@ -412,7 +390,6 @@ export const BuiltinFuncs = function() {
         [ Opcodes.global_get, 0 ],
       ],
     },
-    'lcg64_musl': 0, // todo
 
     'xorshift32+': {
       globals: [ Valtype.i32 ],
@@ -485,11 +462,6 @@ export const BuiltinFuncs = function() {
         // state0 = s1
         [ Opcodes.global_set, 0 ],
 
-        // // s1 * 0x2545F4914F6CDD1D
-        // [ Opcodes.local_get, 0 ],
-        // [ Opcodes.i64_const, 0x9d, 0xba, 0xb3, 0xfb, 0x94, 0x92, 0xfd, 0xa2, 0x25 ],
-        // [ Opcodes.i64_mul ]
-
         // s1
         [ Opcodes.local_get, 0 ],
       ],

package/compiler/{decompile.js → disassemble.js}

@@ -49,7 +49,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
 
     let opStr = invOpcodes[inst[0]];
     if (!opStr) {
-      console.log(`decomp: unknown op ${inst[0]?.toString?.(16)} @${i}`);
+      console.log(`disasm: unknown op ${inst[0]?.toString?.(16)} @${i}`);
       // console.log(`prior: ${invOpcodes[wasm[i - 1][0]]}`);
       out += `;; unknown op ${inst[0]?.toString?.(16)}\n`;
       continue;

package/compiler/encoding.js

@@ -10,15 +10,8 @@ export const codifyString = str => {
 export const encodeString = str => unsignedLEB128(str.length).concat(codifyString(str));
 export const encodeVector = data => unsignedLEB128(data.length).concat(data.flat());
 
-export const encodeLocal = (count, type) => [
-  ...unsignedLEB128(count),
-  type
-];
-
 // todo: this only works with integers within 32 bit range
 export const signedLEB128 = n => {
-  if (typeof n === 'bigint') return big_signedLEB128(n);
-
   n |= 0;
 
   // just input for small numbers (for perf as common)
@@ -45,8 +38,6 @@ export const signedLEB128 = n => {
 };
 
 export const unsignedLEB128 = n => {
-  if (typeof n === 'bigint') return big_unsignedLEB128(n);
-
   n |= 0;
 
   // just input for small numbers (for perf as common)
@@ -217,5 +208,4 @@ export const unsignedLEB128_into = (n, buffer) => {
 export const ieee754_binary64_into = (value, buffer) => {
   const data = new Uint8Array(new Float64Array([ value ]).buffer);
   for (let i = 0; i < 8; i++) buffer.push(data[i]);
-  // buffer.push(...new Uint8Array(new Float64Array([ value ]).buffer));
 };

package/compiler/index.js

@@ -4,21 +4,23 @@ import parse from './parse.js';
 import codegen from './codegen.js';
 import opt from './opt.js';
 import assemble from './assemble.js';
-import decompile from './decompile.js';
+import disassemble from './disassemble.js';
 import toc from './2c.js';
 import * as pgo from './pgo.js';
 import cyclone from './cyclone.js';
 import './prefs.js';
 
-globalThis.decompile = decompile;
+globalThis.disassemble = disassemble;
 
 const logFuncs = (funcs, globals, exceptions) => {
   console.log('\n' + underline(bold('funcs')));
 
-  const wanted = Prefs.f;
+  let wanted = Prefs.f;
+  if (typeof wanted !== 'string') wanted = null;
+
   for (const f of funcs) {
     if ((wanted && f.name !== wanted) || (!wanted && f.internal)) continue;
-    console.log(decompile(f.wasm, f.name, f.index, f.locals, f.params, f.returns, funcs, globals, exceptions));
+    console.log(disassemble(f.wasm, f.name, f.index, f.locals, f.params, f.returns, funcs, globals, exceptions));
   }
 
   console.log();
@@ -75,7 +77,7 @@ export default (code, module = undefined) => {
 
   // change some prefs by default for c/native
   if (target !== 'wasm') {
-    Prefs.pgo = Prefs.pgo === false || globalThis.document ? false : true; // enable pgo
+    // Prefs.pgo = Prefs.pgo === false || globalThis.document ? false : true; // enable pgo by default
     Prefs.passiveData = false; // disable using passive Wasm data as unsupported by 2c for now
   }
 

package/compiler/parse.js

@@ -3,13 +3,11 @@ import './prefs.js';
 
 const file = globalThis.file;
 
-// should we try to support types (while parsing)
 const types = Prefs.parseTypes || Prefs.t || file?.endsWith('.ts');
 globalThis.typedInput = types && Prefs.optTypes;
 
-// todo: review which to use by default
 // supported parsers:
-// - acorn
+// - acorn (default)
 // - meriyah
 // - hermes-parser
 // - @babel/parser

package/compiler/wrap.js

@@ -1,7 +1,7 @@
-import { encodeVector, encodeLocal } from './encoding.js';
+import { encodeVector } from './encoding.js';
 import { importedFuncs } from './builtins.js';
 import compile from './index.js';
-import decompile from './decompile.js';
+import disassemble from './disassemble.js';
 import { TYPES, TYPE_NAMES } from './types.js';
 import { log } from './log.js';
 import './prefs.js';
@@ -352,7 +352,7 @@ export default (source, module = undefined, customImports = {}, print = str => p
   times.push(performance.now() - t1);
   if (Prefs.profileCompiler && !globalThis.onProgress) console.log(`\u001b[1mcompiled in ${times[0].toFixed(2)}ms\u001b[0m`);
 
-  const printDecomp = (middleIndex, func, funcs, globals, exceptions) => {
+  const printBacktrace = (middleIndex, func, funcs, globals, exceptions) => {
     console.log(`\x1B[35m\x1B[1mporffor backtrace\u001b[0m`);
 
     const surrounding = Prefs.backtraceSurrounding ?? 10;
@@ -363,22 +363,22 @@ export default (source, module = undefined, customImports = {}, print = str => p
       max = func.wasm.length;
     }
 
-    const decomp = decompile(func.wasm.slice(min, max), func.name, 0, func.locals, func.params, func.returns, funcs, globals, exceptions)
+    const disasm = disassemble(func.wasm.slice(min, max), func.name, 0, func.locals, func.params, func.returns, funcs, globals, exceptions)
       .slice(0, -1).split('\n').filter(x => !x.startsWith('\x1B[90m;;'));
 
     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);
+    for (let j = 0; j < disassemble.length; j++) {
+      longest = Math.max(longest, noAnsi(disassemble[j]).length);
     }
 
     if (middleIndex != -1) {
-      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`;
+      const middle = Math.floor(disasm.length / 2);
+      disasm[middle] = `\x1B[47m\x1B[30m${noAnsi(disasm[middle])}${'\u00a0'.repeat(longest - noAnsi(disasm[middle]).length)}\x1B[0m`;
     }
 
     if (min != 0) console.log('\x1B[90m...\x1B[0m');
-    console.log(decomp.join('\n'));
+    console.log(disasm.join('\n'));
     if (max > func.wasm.length) console.log('\x1B[90m...\x1B[0m\n');
   };
 
@@ -407,7 +407,7 @@ export default (source, module = undefined, customImports = {}, print = str => p
     }
 
     if (i === wasm.length) {
-      printDecomp(-1, func, funcs, globals, exceptions);
+      printBacktrace(-1, func, funcs, globals, exceptions);
       return false;
     }
 
@@ -421,11 +421,11 @@ export default (source, module = undefined, customImports = {}, print = str => p
     }
 
     if (cumLen !== offset) {
-      printDecomp(-1, func, funcs, globals, exceptions);
+      printBacktrace(-1, func, funcs, globals, exceptions);
       return false;
     }
 
-    printDecomp(i + 1, func, funcs, globals, exceptions);
+    printBacktrace(i + 1, func, funcs, globals, exceptions);
     return true;
   };
 
@@ -433,13 +433,6 @@ export default (source, module = undefined, customImports = {}, print = str => p
 
   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, {
     const module = new WebAssembly.Module(wasm);
     instance = new WebAssembly.Instance(module, {
       '': {
@@ -543,8 +536,8 @@ export default (source, module = undefined, customImports = {}, print = str => p
     };
   }
 
-  if (Prefs.decomp) {
-    return { exports, wasm, times, decomps: funcs.map(x => decompile(x.wasm, x.name, x.index, x.locals, x.params, x.returns, funcs, globals, exceptions)), c };
+  if (Prefs.disassemble) {
+    return { exports, wasm, times, disams: funcs.map(x => disassemble(x.wasm, x.name, x.index, x.locals, x.params, x.returns, funcs, globals, exceptions)), c };
   }
 
   return { exports, wasm, times, pages, c };

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.50.26",
+  "version": "0.50.28",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/rhemyn/compile.js

@@ -92,7 +92,7 @@ const generate = (node, negated = false, get = true, stringSize = 2, func = 'tes
         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');
+        console.log(`\n${underline('wasm bytecode')}\n` + disassemble(out) + '\n');
       }
 
       break;

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.50.26';
+globalThis.version = '0.50.28';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -11,7 +11,7 @@ const start = performance.now();
 
 if (process.argv.includes('--help')) {
   // description + version
-  console.log(`\x1B[1m\x1B[35mPorffor\x1B[0m is a JavaScript/TypeScript engine/compiler/runtime. \x1B[90m(${globalThis.version})\x1B[0m`);
+  console.log(`\x1B[1m\x1B[35mPorffor\x1B[0m is a JavaScript/TypeScript engine/compiler/runtime. \x1B[2m(${globalThis.version})\x1B[0m`);
 
   // basic usage
   console.log(`Usage: \x1B[1mporf <command> [...prefs] path/to/script.js [...args]\x1B[0m`);
@@ -43,6 +43,43 @@ if (process.argv.includes('--help')) {
     console.log(`  \x1B[90mporf\x1B[0m \x1B[1m\x1B[${color}m${cmd}\x1B[0m\x1B[2m${post}\x1B[0m ${' '.repeat(30 - cmd.length - post.length)}${desc}`);
   }
 
+  // flags
+  console.log(`\n\x1B[1m\x1B[4mFlags\x1B[0m`);
+  for (let [ flag, desc ] of Object.entries({
+    module: 'Parse input as a module',
+    t: 'Force TypeScript input',
+    d: 'Debug mode (include names in Wasm and debug logs)'
+  })) {
+    flag = '-' + flag;
+    if (flag.length > 3) flag = '-' + flag;
+
+    console.log(`  \x1B[1m${flag}\x1B[0m${' '.repeat(36 - flag.length)}${desc}`);
+  }
+
+  // niche flags
+  if (process.argv.includes('--flags')) {
+    for (let [ flag, desc ] of Object.entries({
+      f: 'Print disassembled Wasm generated from user functions',
+      pgo: 'Enable PGO (profile-guided optimization)',
+      'profile-compiler': 'Log general compiler performance (on by default when compiling to a file)',
+      valtype: 'Valtype to use (i32|i64|\x1B[1mf64\x1B[0m)',
+      prng: 'PRNG algorithm to use (lcg32|xorshift32+|xorshift64+|\x1B[1mxorshift128+\x1B[0m|xoroshiro128+|xoshiro128+)',
+      allocator: 'Allocator to use (oneshot|\x1B[1mchunk\x1B[0m)',
+      'exception-mode': 'Exception mode to use (lut|\x1B[1mstack\x1B[0m)',
+      fastLength: 'Spec non-compliant optimization to make .length faster',
+      'no-coctc': 'Disable COCTC (cross-object compile-time cache)',
+      cyclone: 'Enable experimental Cyclone optimizer',
+      'no-treeshake-wasm-imports': 'Do not treeshake Wasm imports'
+    })) {
+      flag = '-' + flag;
+      if (flag.length > 3) flag = '-' + flag;
+
+      console.log(`  \x1B[1m${flag}\x1B[0m${' '.repeat(36 - flag.length)}${desc}`);
+    }
+  } else {
+    console.log(`  \x1B[2m(To view all flags use --flags)\x1B[0m`);
+  }
+
   console.log();
   process.exit(0);
 }

package/runner/repl.js

@@ -137,7 +137,7 @@ replServer.defineCommand('memory', {
   }
 });
 replServer.defineCommand('asm', {
-  help: 'Log Wasm decompiled bytecode',
+  help: 'Log Wasm disassembled bytecode',
   action() {
     this.clearBufferedCommand();