porffor 0.57.6 → 0.57.8

package/compiler/assemble.js

@@ -95,7 +95,13 @@ export default (funcs, globals, tags, pages, data, noTreeshake = false) => {
 
   const importSection = importFuncs.length === 0 ? [] : createSection(
     Section.import,
-    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(typeof x.params === 'object' ? x.params : new Array(x.params).fill(valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
+    encodeVector(importFuncs.map(x => {
+      return [
+        0, 1, x.import.charCodeAt(0),
+        ExportDesc.func,
+        getType(x.params, x.returns)
+      ];
+    }))
   );
   time('import section');
 

package/compiler/builtins.js

@@ -5,61 +5,44 @@ import { TYPES, TYPE_NAMES } from './types.js';
 import { number, unsignedLEB128 } from './encoding.js';
 import './prefs.js';
 
-export const importedFuncs = [
-  {
-    name: 'print',
-    import: 'p',
-    params: 1,
-    returns: 0
-  },
-  {
-    name: 'printChar',
-    import: 'c',
-    params: 1,
-    returns: 0
-  },
-  {
-    name: 'time',
-    import: 't',
-    params: 0,
-    returns: 1
-  },
-  {
-    name: 'timeOrigin',
-    import: 'u',
-    params: 0,
-    returns: 1
-  },
-  {
-    name: 'profile1',
-    import: 'y',
-    params: [ Valtype.i32 ],
-    returns: 0
-  },
-  {
-    name: 'profile2',
-    import: 'z',
-    params: [ Valtype.i32 ],
-    returns: 0
-  },
-  {
-    name: '__Porffor_readArgv',
-    import: 'w',
-    params: 2,
-    returns: 1
-  },
-  {
-    name: '__Porffor_readFile',
-    import: 'q',
-    params: 2,
-    returns: 1
-  }
-];
+export const importedFuncs = {};
+Object.defineProperty(importedFuncs, 'length', { configurable: true, writable: true, value: 0 });
+
+export const createImport = (name, params, returns, js = null, c = null) => {
+  if (name in importedFuncs) return false;
+
+  const call = importedFuncs.length;
+  const ident = String.fromCharCode(97 + importedFuncs.length);
+  let obj;
+  const get = () => {
+    if (obj) return obj;
+
+    if (typeof params === 'function') params = params();
+    if (typeof returns === 'function') returns = returns();
+    if (typeof params === 'number') params = new Array(params).fill(valtypeBinary);
+    if (typeof returns === 'number') returns = new Array(returns).fill(valtypeBinary);
+
+    obj = new Number(call);
+    obj.name = name;
+    obj.import = ident;
+    obj.params = params;
+    obj.returns = returns;
+    obj.js = js;
+    obj.c = c;
+    return obj;
+  };
 
-for (let i = 0; i < importedFuncs.length; i++) {
-  const f = importedFuncs[i];
-  importedFuncs[f.name] = i;
-}
+  Object.defineProperty(importedFuncs, name, {
+    get,
+    configurable: true,
+    enumerable: true
+  });
+  Object.defineProperty(importedFuncs, call, {
+    get,
+    configurable: true
+  });
+  importedFuncs.length = call + 1;
+};
 
 export const UNDEFINED = 0;
 export const NULL = 0;

package/compiler/encoding.js

@@ -28,9 +28,9 @@ export const signedLEB128 = n => {
   // just input for small numbers (for perf as common)
   if (n >= 0 && n <= 63) return [ n ];
   if (n >= -64 && n <= 0) return [ 128 + n ];
+  if (n >= 0 && n <= 8191) return [ 128 + (n % 128), Math.floor(n / 128) ];
 
   const buffer = [];
-
   while (true) {
     let byte = n & 0x7f;
     n >>= 7;
@@ -53,6 +53,7 @@ export const unsignedLEB128 = n => {
 
   // just input for small numbers (for perf as common)
   if (n >= 0 && n <= 127) return [ n ];
+  if (n >= 0 && n <= 16383) return [ 128 + (n % 128), Math.floor(n / 128) ];
 
   const buffer = [];
   do {
@@ -63,6 +64,7 @@ export const unsignedLEB128 = n => {
     }
     buffer.push(byte);
   } while (n !== 0);
+
   return buffer;
 };
 
@@ -122,14 +124,13 @@ export const big_unsignedLEB128 = n => {
   return buffer;
 };
 
-export const read_signedLEB128 = _input => {
-  const input = [..._input];
+export const read_signedLEB128 = input => {
   let result = 0, shift = 0;
 
+  let i = 0;
   while (true) {
-    const byte = input.shift();
+    const byte = input[i++];
     result |= (byte & 0x7f) << shift;
-
     shift += 7;
 
     if ((0x80 & byte) === 0) {
@@ -143,14 +144,13 @@ export const read_signedLEB128 = _input => {
 };
 
 // todo: check this with large unsigned values
-export const read_unsignedLEB128 = _input => {
-  const input = [..._input];
+export const read_unsignedLEB128 = input => {
   let result = 0, shift = 0;
 
+  let i = 0;
   while (true) {
-    const byte = input.shift();
+    const byte = input[i++];
     result |= (byte & 0x7f) << shift;
-
     shift += 7;
 
     if ((0x80 & byte) === 0) {
@@ -184,6 +184,7 @@ export const signedLEB128_into = (n, buffer) => {
   // just input for small numbers (for perf as common)
   if (n >= 0 && n <= 63) return buffer.push(n);
   if (n >= -64 && n <= 0) return buffer.push(128 + n);
+  if (n >= 0 && n <= 8191) return buffer.push(128 + (n % 128), Math.floor(n / 128));
 
   while (true) {
     let byte = n & 0x7f;
@@ -205,6 +206,7 @@ export const unsignedLEB128_into = (n, buffer) => {
 
   // just input for small numbers (for perf as common)
   if (n >= 0 && n <= 127) return buffer.push(n);
+  if (n >= 0 && n <= 16383) return buffer.push(128 + (n % 128), Math.floor(n / 128));
 
   do {
     let byte = n & 0x7f;

package/compiler/index.js

@@ -62,6 +62,9 @@ const progressClear = () => {
 export default (code, module = undefined) => {
   if (module !== undefined) Prefs.module = module;
 
+  globalThis.valtype = Prefs.valtype ?? 'f64';
+  globalThis.valtypeBinary = Valtype[valtype];
+
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
 
   let target = Prefs.target ?? 'wasm';

package/compiler/pgo.js

@@ -1,14 +1,12 @@
 import { Opcodes, Valtype } from './wasmSpec.js';
 import { number } from './encoding.js';
-import { importedFuncs } from './builtins.js';
+import { createImport, importedFuncs } from './builtins.js';
 import assemble from './assemble.js';
 import wrap, { writeByteStr } from './wrap.js';
 import * as Havoc from './havoc.js';
 import './prefs.js';
 
 export const setup = () => {
-  importedFuncs[importedFuncs.profile2].params = [ Valtype.i32, valtypeBinary ];
-
   // enable these prefs by default for pgo
   for (const x of [
     'typeswitchUniqueTmp', // use unique tmps for typeswitches
@@ -36,6 +34,15 @@ export const run = obj => {
 
   time(0, `injecting PGO logging...`);
 
+  let activeFunc = null, abort = false;
+  createImport('profile1', 1, 0, n => {
+    activeFunc = n;
+  });
+  createImport('profile2', 2, 0, (i, n) => {
+    if (activeFunc == null) throw 'fail';
+    localData[activeFunc][i].push(n);
+  });
+
   let funcs = [];
   for (let i = 0; i < wasmFuncs.length; i++) {
     const { name, internal, params, locals, wasm } = wasmFuncs[i];
@@ -79,7 +86,7 @@ export const run = obj => {
   time(0, `injected PGO logging`);
   time(1, `running with PGO logging...`);
 
-  let activeFunc = null, abort = false;
+
   try {
     obj.wasm = assemble(obj.funcs, obj.globals, obj.tags, obj.pages, obj.data, true);
 
@@ -87,14 +94,7 @@ export const run = obj => {
     Prefs.profileCompiler = false;
 
     const { exports } = wrap(obj, undefined, {
-      y: n => {
-        activeFunc = n;
-      },
-      z: (i, n) => {
-        if (activeFunc == null) throw 'fail';
-        localData[activeFunc][i].push(n);
-      },
-      w: (ind, outPtr) => { // readArgv
+      readArgv: (ind, outPtr) => {
         const pgoInd = process.argv.indexOf('--pgo');
         let args = process.argv.slice(pgoInd);
         args = args.slice(args.findIndex(x => !x.startsWith('-')) + 1);
@@ -108,7 +108,7 @@ export const run = obj => {
         writeByteStr(exports.$, outPtr, str);
         return str.length;
       },
-      q: (pathPtr, outPtr) => {
+      readFile: (pathPtr, outPtr) => {
         return -1;
       }
     }, () => {});

package/compiler/wrap.js

@@ -1,5 +1,5 @@
 import { encodeVector } from './encoding.js';
-import { importedFuncs } from './builtins.js';
+import { importedFuncs, createImport } from './builtins.js';
 import compile from './index.js';
 import disassemble from './disassemble.js';
 import { TYPES, TYPE_NAMES } from './types.js';
@@ -352,16 +352,61 @@ ${flags & 0b0001 ? `    get func idx: ${get}
   }
 };
 
+export { createImport };
 export default (source, module = undefined, customImports = {}, print = str => process.stdout.write(str)) => {
+  createImport('print', 1, 0, i => print(i.toString()));
+  createImport('printChar', 1, 0, i => print(String.fromCharCode(i)));
+  createImport('time', 0, 1, () => performance.now());
+  createImport('timeOrigin', 0, 1, () => performance.timeOrigin);
+
+  // todo: these should be provided elsewhere in runtime itself
+  createImport('__Porffor_readArgv', 2, 1, (ind, outPtr) => {
+    let args = process.argv.slice(2);
+    args = args.slice(args.findIndex(x => !x.startsWith('-')) + 1);
+
+    const str = args[ind - 1];
+    if (!str) return -1;
+
+    writeByteStr(memory, outPtr, str);
+    return str.length;
+  });
+  createImport('__Porffor_readFile', 2, 1, (pathPtr, outPtr) => { // readFile
+    try {
+      const path = pathPtr === 0 ? 0 : readByteStr(memory, pathPtr);
+      const contents = fs.readFileSync(path, 'utf8');
+      writeByteStr(memory, outPtr, contents);
+      return contents.length;
+    } catch {
+      return -1;
+    }
+  });
+
+  for (const x in customImports) {
+    const custom = customImports[x];
+
+    if (x in importedFuncs) {
+      // overwrite with user custom import
+      const existing = importedFuncs[x];
+      if (typeof custom === 'function') {
+        existing.js = custom;
+      } else {
+        existing.params = custom.params;
+        existing.returns = custom.returns;
+        existing.js = custom.js;
+        existing.c = custom.c;
+      }
+      continue;
+    }
+
+    // todo: make a simpler api for just js functions at some point using function.length etc
+    createImport(x, custom.params, custom.returns, custom.js, custom.c);
+  }
+
   const times = [];
 
   const t1 = performance.now();
   const { wasm, funcs, globals, tags, exceptions, pages, c } = typeof source === 'object' ? source : compile(source, module);
 
-  globalThis.porfDebugInfo = { funcs, globals };
-
-  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
-
   times.push(performance.now() - t1);
   if (Prefs.profileCompiler && !globalThis.onProgress) console.log(`\u001b[1mcompiled in ${times[0].toFixed(2)}ms\u001b[0m`);
 
@@ -448,35 +493,11 @@ export default (source, module = undefined, customImports = {}, print = str => p
   try {
     const module = new WebAssembly.Module(wasm);
     instance = new WebAssembly.Instance(module, {
-      '': {
-        p: i => print(i.toString()),
-        c: i => print(String.fromCharCode(i)),
-        t: () => performance.now(),
-        u: () => performance.timeOrigin,
-        y: () => {},
-        z: () => {},
-        w: (ind, outPtr) => { // readArgv
-          let args = process.argv.slice(2);
-          args = args.slice(args.findIndex(x => !x.startsWith('-')) + 1);
-
-          const str = args[ind - 1];
-          if (!str) return -1;
-
-          writeByteStr(memory, outPtr, str);
-          return str.length;
-        },
-        q: (pathPtr, outPtr) => { // readFile
-          try {
-            const path = pathPtr === 0 ? 0 : readByteStr(memory, pathPtr);
-            const contents = fs.readFileSync(path, 'utf8');
-            writeByteStr(memory, outPtr, contents);
-            return contents.length;
-          } catch {
-            return -1;
-          }
-        },
-        ...customImports
-      }
+      '': Object.keys(importedFuncs).reduce((acc, y) => {
+        const x = importedFuncs[y];
+        acc[x.import] = x.js ?? (() => {});
+        return acc;
+      }, {})
     });
   } catch (e) {
     if (!Prefs.d) throw e;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.57.6",
+  "version": "0.57.8",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/runtime/debug.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import compile from '../compiler/wrap.js';
+import compile, { createImport } from '../compiler/wrap.js';
 import Byg from '../byg/index.js';
 import fs from 'node:fs';
 
@@ -41,75 +41,75 @@ let lastLine;
 
 let output = '';
 
-try {
-  const { exports } = compile(source, undefined, {
-    y: n => {
-      if (callStarts[callStarts.length - 1] === n - 1) {
-        // end of call
+createImport('profile1', 1, 0, n => {
+  if (callStarts[callStarts.length - 1] === n - 1) {
+    // end of call
 
-        callStarts.pop();
-        callStack.pop();
+    callStarts.pop();
+    callStack.pop();
 
-        paused = _paused;
-      }
+    paused = _paused;
+  }
 
-      lastLine = n;
-
-      if (breakpoints[n]) paused = true;
-
-      if (paused) {
-        stepIn = false; stepOut = false;
-
-        switch (byg(
-          paused,
-          n,
-          `\x1b[1mporffor debugger\x1b[22m: ${file}@${n + 1}    ${callStack.join('->')}`,
-          [
-            {
-              x: termWidth - 1 - 40 - 6,
-              y: () => 4,
-              width: 40,
-              height: 20,
-              title: 'console',
-              content: output.split('\n')
-            }
-          ]
-        )) {
-          case 'resume': {
-            paused = false;
-            break;
-          }
-
-          case 'stepOver': {
-            break;
-          }
-
-          case 'stepIn': {
-            stepIn = true;
-            // paused = false;
-            break;
-          }
-
-          case 'stepOut': {
-            stepOut = true;
-            paused = false;
-            break;
-          }
+  lastLine = n;
+
+  if (breakpoints[n]) paused = true;
+
+  if (paused) {
+    stepIn = false; stepOut = false;
+
+    switch (byg(
+      paused,
+      n,
+      `\x1b[1mporffor debugger\x1b[22m: ${file}@${n + 1}    ${callStack.join('->')}`,
+      [
+        {
+          x: termWidth - 1 - 40 - 6,
+          y: () => 4,
+          width: 40,
+          height: 20,
+          title: 'console',
+          content: output.split('\n')
         }
+      ]
+    )) {
+      case 'resume': {
+        paused = false;
+        break;
       }
-    },
-    z: n => {
-      // start of call
-      callStack.push(funcs[n]);
 
-      callStarts.push(lastLine);
+      case 'stepOver': {
+        break;
+      }
 
-      _paused = paused;
-      if (!stepIn) paused = false;
-        else paused = true;
+      case 'stepIn': {
+        stepIn = true;
+        // paused = false;
+        break;
+      }
+
+      case 'stepOut': {
+        stepOut = true;
+        paused = false;
+        break;
+      }
     }
-  }, s => output += s);
+  }
+});
+
+createImport('profile2', 1, 0, n => {
+  // start of call
+  callStack.push(funcs[n]);
+
+  callStarts.push(lastLine);
 
+  _paused = paused;
+  if (!stepIn) paused = false;
+    else paused = true;
+});
+
+try {
+  const { exports } = compile(source, undefined, {}, s => output += s);
   exports.main();
 } catch (e) {
   console.error(e);

package/runtime/flamegraph.js

@@ -2,7 +2,7 @@
 import { Opcodes, Valtype } from '../compiler/wasmSpec.js';
 import { number } from '../compiler/encoding.js';
 import { importedFuncs } from '../compiler/builtins.js';
-import compile from '../compiler/wrap.js';
+import compile, { createImport } from '../compiler/wrap.js';
 import fs from 'node:fs';
 
 const file = process.argv.slice(2).find(x => x[0] !== '-');
@@ -148,7 +148,19 @@ const render = () => {
   lastRenderTime = performance.now() - renderStart;
 };
 
-// importedFuncs[importedFuncs.profile2].params = [ Valtype.i32, Valtype.f64 ];
+createImport('profile1', 1, 0, f => { // pre-call
+  samplesStart.push(performance.now());
+  running[runningIdx++] = samplesFunc.push(f) - 1;
+});
+createImport('profile2', 1, 0, f => { // post-call
+  const now = performance.now();
+  samplesEnd[running[--runningIdx]] = now;
+
+  if (now > last) {
+    last = now + 500;
+    render();
+  }
+});
 
 Prefs.treeshakeWasmImports = false;
 let funcLookup = new Map();
@@ -180,21 +192,7 @@ globalThis.compileCallback = ({ funcs }) => {
 
 let last = 0;
 let running = new Uint32Array(1024), runningIdx = 0;
-const { exports } = compile(source, undefined, {
-  y: f => { // pre-call
-    samplesStart.push(performance.now());
-    running[runningIdx++] = samplesFunc.push(f) - 1;
-  },
-  z: f => { // post-call
-    const now = performance.now();
-    samplesEnd[running[--runningIdx]] = now;
-
-    if (now > last) {
-      last = now + 500;
-      render();
-    }
-  }
-}, () => {});
+const { exports } = compile(source, undefined, {}, () => {});
 
 start = performance.now();
 render();

package/runtime/hotlines.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import compile from '../compiler/wrap.js';
+import compile, { createImport } from '../compiler/wrap.js';
 import fs from 'node:fs';
 
 const file = process.argv.slice(2).find(x => x[0] !== '-');
@@ -18,29 +18,26 @@ const spinner = ['-', '\\', '|', '/'];
 let spin = 0;
 let last = 0;
 
-try {
-  const { exports } = compile(source, undefined, {
-    y: n => {
-      tmp[n] = performance.now();
-    },
-    z: n => {
-      const t = performance.now();
-      times[n] += t - tmp[n];
-
-      samples++;
-      if (t > last) {
-        process.stdout.write(`\r${spinner[spin++ % 4]} running: collected ${samples} samples...`);
-        last = t + 100;
-      }
-    }
-  });
+createImport('profile1', 1, 0, n => {
+  tmp[n] = performance.now();
+});
+createImport('profile2', 1, 0, n => {
+  const t = performance.now();
+  times[n] += t - tmp[n];
 
-  const start = performance.now();
+  samples++;
+  if (t > last) {
+    process.stdout.write(`\r${spinner[spin++ % 4]} running: collected ${samples} samples...`);
+    last = t + 100;
+  }
+})
 
+try {
+  const { exports } = compile(source, undefined);
+  const start = performance.now();
   exports.main();
 
   const total = performance.now() - start;
-
   console.log(`\ntotal: ${total}ms\nsamples: ${samples}\n\n\n` + source.split('\n').map(x => {
     let time = 0;
     if (x.startsWith('profile')) {

package/runtime/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.57.6';
+globalThis.version = '0.57.8';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {