porffor 0.60.8 → 0.60.9

package/compiler/codegen.js

@@ -1,5 +1,5 @@
 import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
-import { number, ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector, read_signedLEB128 } from './encoding.js';
+import { number, ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from './encoding.js';
 import { operatorOpcode } from './expression.js';
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
 import { TYPES, TYPE_FLAGS, TYPE_NAMES } from './types.js';
@@ -41,24 +41,30 @@ const allocBytes = (scope, reason, bytes) => {
     return allocs.get(reason);
   }
 
-  let bin = bins.find(x => (pageSize - x.used) >= bytes);
-  if (!bin) {
-    // new bin
-    const page = pages.size;
-    bin = {
-      used: 0,
-      page
-    };
+  let startingPtr = 0;
+  while (bytes > 0) {
+    const alloc = Math.min(bytes, pageSize);
+    bytes -= alloc;
 
-    const id = bins.push(bin);
-    pages.set(`#bin: ${id}`, page);
-  }
+    let bin = bins.find(x => (pageSize - x.used) >= alloc);
+    if (!bin) {
+      // new bin
+      const page = pages.size;
+      bin = {
+        used: 0,
+        page
+      };
 
-  const ptr = pagePtr(bin.page) + bin.used;
-  bin.used += bytes;
+      const id = bins.push(bin);
+      pages.set(`#bin: ${id}`, page);
+    }
+
+    if (!startingPtr) startingPtr = pagePtr(bin.page) + bin.used;
+    bin.used += alloc;
+  }
 
-  allocs.set(reason, ptr);
-  return ptr;
+  allocs.set(reason, startingPtr);
+  return startingPtr;
 };
 
 export const allocStr = (scope, str, bytestring) => {
@@ -2840,7 +2846,7 @@ const knownType = (scope, type) => {
   if (typeof type === 'number') return type;
 
   if (type.length === 1 && type[0][0] === Opcodes.i32_const) {
-    return read_signedLEB128(type[0].slice(1));
+    return type[0][1];
   }
 
   if (typedInput && type.length === 1 && type[0][0] === Opcodes.local_get) {
@@ -4319,7 +4325,7 @@ const generateUnary = (scope, decl) => {
       return [
         ...toNumeric(),
         Opcodes.i32_to,
-        [ Opcodes.i32_const, ...signedLEB128(-1) ],
+        [ Opcodes.i32_const, -1 ],
         [ Opcodes.i32_xor ],
         Opcodes.i32_from
       ];
@@ -5118,14 +5124,14 @@ const generateForIn = (scope, decl) => {
         [ Opcodes.local_set, tmp ],
 
         // symbol is MSB 2 is set
-        [ Opcodes.i32_const, ...unsignedLEB128(TYPES.string) ],
-        [ Opcodes.i32_const, ...unsignedLEB128(TYPES.symbol) ],
+        [ Opcodes.i32_const, TYPES.string ],
+        [ Opcodes.i32_const, TYPES.symbol ],
         [ Opcodes.local_get, tmp ],
         number(0x40000000, Valtype.i32),
         [ Opcodes.i32_and ],
         [ Opcodes.select ],
       [ Opcodes.else ], // bytestring
-        [ Opcodes.i32_const, ...unsignedLEB128(TYPES.bytestring) ],
+        [ Opcodes.i32_const, TYPES.bytestring ],
       [ Opcodes.end ]
     ]),
 
@@ -6615,6 +6621,7 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
 
         const encodeFunc = ({
           [Opcodes.f64_const]: x => x,
+          [Opcodes.i32_const]: x => x,
           [Opcodes.if]: unsignedLEB128,
           [Opcodes.loop]: unsignedLEB128
         })[inst[0]] ?? signedLEB128;

package/compiler/cyclone.js

@@ -1,5 +1,5 @@
 // cyclone: wasm partial constant evaluator (it is fast and dangerous hence "cyclone")
-import { number, read_signedLEB128 } from './encoding.js';
+import { number } from './encoding.js';
 import { Opcodes, Valtype } from './wasmSpec.js';
 import './prefs.js';
 
@@ -123,7 +123,7 @@ export default ({ name, wasm, locals: _locals, params }) => {
         }
 
         case Opcodes.i32_const: {
-          const n = read_signedLEB128(op.slice(1));
+          const n = op[1];
           push(n);
           break;
         }

package/compiler/disassemble.js

@@ -1,5 +1,5 @@
 import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
-import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
+import { read_unsignedLEB128 } from './encoding.js';
 import { importedFuncs } from './builtins.js';
 
 const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
@@ -74,7 +74,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
     if (inst[0] === Opcodes.f64_const) {
       out += ` ${inst[1]}`;
     } else if (inst[0] === Opcodes.i32_const || inst[0] === Opcodes.i64_const) {
-      out += ` ${read_signedLEB128(inst.slice(1))}`;
+      out += ` ${inst[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 || 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)) {

package/compiler/encoding.js

@@ -3,10 +3,10 @@ import { Opcodes, Valtype } from './wasmSpec.js';
 export const number = (n, valtype = valtypeBinary) => {
   if (valtype === Valtype.f64) return [ Opcodes.f64_const, n ];
 
-  const out = [ valtype === Valtype.i32 ? Opcodes.i32_const : Opcodes.i64_const ];
-  signedLEB128_into(n, out);
-
-  return out;
+  return [
+    valtype === Valtype.i32 ? Opcodes.i32_const : Opcodes.i64_const,
+    n
+  ];
 };
 
 export const codifyString = str => {
@@ -23,6 +23,9 @@ export const encodeVector = data => unsignedLEB128(data.length).concat(data.flat
 
 // todo: this only works with integers within 32 bit range
 export const signedLEB128 = n => {
+  if (n === Infinity) return signedLEB128(2147483647);
+  if (n === -Infinity) return signedLEB128(-2147483648);
+
   n |= 0;
 
   // just input for small numbers (for perf as common)
@@ -49,6 +52,9 @@ export const signedLEB128 = n => {
 };
 
 export const unsignedLEB128 = n => {
+  if (n === Infinity) return unsignedLEB128(4294967295);
+  if (n === -Infinity) return unsignedLEB128(0);
+
   n |= 0;
 
   // just input for small numbers (for perf as common)
@@ -69,6 +75,9 @@ export const unsignedLEB128 = n => {
 };
 
 export const unsignedLEB128_length = n => {
+  if (n === Infinity) return unsignedLEB128_length(4294967295);
+  if (n === -Infinity) return unsignedLEB128_length(0);
+
   if (n < 0) n = n >>> 0;
   if (n <= 127) return 1;
   if (n <= 16383) return 2;
@@ -85,6 +94,9 @@ export const unsignedLEB128_length = n => {
 };
 
 export const signedLEB128_length = n => {
+  if (n === Infinity) return signedLEB128_length(2147483647);
+  if (n === -Infinity) return signedLEB128_length(-2147483648);
+
   if (n >= -64 && n <= 63) return 1;
   if (n >= -8192 && n <= 8191) return 2;
   if (n >= -1048576 && n <= 1048575) return 3;
@@ -201,6 +213,9 @@ export const read_ieee754_binary64 = buffer => new Float64Array(new Uint8Array(b
 
 // into funcs append to a given existing buffer instead of creating our own for perf
 export const signedLEB128_into = (n, buffer) => {
+  if (n === Infinity) return signedLEB128_into(2147483647, buffer);
+  if (n === -Infinity) return signedLEB128_into(-2147483648, buffer);
+
   n |= 0;
 
   // just input for small numbers (for perf as common)
@@ -224,6 +239,9 @@ export const signedLEB128_into = (n, buffer) => {
 };
 
 export const unsignedLEB128_into = (n, buffer) => {
+  if (n === Infinity) return unsignedLEB128_into(4294967295, buffer);
+  if (n === -Infinity) return unsignedLEB128_into(0, buffer);
+
   n |= 0;
 
   // just input for small numbers (for perf as common)

package/compiler/expression.js

@@ -46,31 +46,6 @@ export const operatorOpcode = {
     ]
   },
 
-  i64: {
-    '+': Opcodes.i64_add,
-    '-': Opcodes.i64_sub,
-    '*': Opcodes.i64_mul,
-    '/': Opcodes.i64_div_s,
-    '%': Opcodes.i64_rem_s,
-
-    '&': Opcodes.i64_and,
-    '|': Opcodes.i64_or,
-    '^': Opcodes.i64_xor,
-    '<<': Opcodes.i64_shl,
-    '>>': Opcodes.i64_shr_s,
-    '>>>': Opcodes.i64_shr_u,
-
-    '==': Opcodes.i64_eq,
-    '===': Opcodes.i64_eq,
-    '!=': Opcodes.i64_ne,
-    '!==': Opcodes.i64_ne,
-
-    '>': Opcodes.i64_gt_s,
-    '>=': Opcodes.i64_ge_s,
-    '<': Opcodes.i64_lt_s,
-    '<=': Opcodes.i64_le_s
-  },
-
   f64: {
     '+': Opcodes.f64_add,
     '-': Opcodes.f64_sub,

package/compiler/opt.js

@@ -1,5 +1,5 @@
 import { Opcodes, Valtype } from './wasmSpec.js';
-import { number, read_signedLEB128 } from './encoding.js';
+import { number } from './encoding.js';
 import { log } from './log.js';
 import './prefs.js';
 
@@ -177,7 +177,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           // -->
           // i32.const 0
 
-          wasm[i - 1] = number(valtype === 'f64' ? lastInst[1] : read_signedLEB128(lastInst.slice(1)), Valtype.i32); // f64.const -> i32.const
+          wasm[i - 1] = number(lastInst[1], Valtype.i32); // f64.const -> i32.const
 
           wasm.splice(i, 1); // remove this inst
           i--;
@@ -192,7 +192,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           // -->
           // f64.const 0
 
-          wasm[i - 1] = number(read_signedLEB128(lastInst.slice(1))); // i32.const -> f64.const
+          wasm[i - 1] = number(lastInst[1], Valtype.f64); // i32.const -> f64.const
 
           wasm.splice(i, 1); // remove this inst
           i--;
@@ -215,18 +215,18 @@ export default (funcs, globals, pages, tags, exceptions) => {
           continue;
         }
 
-        if (false && i === wasm.length - 1 && inst[0] === Opcodes.return) {
-          // replace final return, end -> end (wasm has implicit return)
-          // return
-          // end
-          // -->
-          // end
-
-          wasm.splice(i, 1); // remove this inst (return)
-          i--;
-          // if (Prefs.optLog) log('opt', `removed redundant return at end`);
-          continue;
-        }
+        // if (i === wasm.length - 1 && inst[0] === Opcodes.return) {
+        //   // replace final return, end -> end (wasm has implicit return)
+        //   // return
+        //   // end
+        //   // -->
+        //   // end
+
+        //   wasm.splice(i, 1); // remove this inst (return)
+        //   i--;
+        //   // if (Prefs.optLog) log('opt', `removed redundant return at end`);
+        //   continue;
+        // }
 
         // remove unneeded before get with update exprs (n++, etc) when value is unused
         if (i < wasm.length - 4 && lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_get && inst[0] === Opcodes.local_get && wasm[i + 1][0] === Opcodes.const && [Opcodes.add, Opcodes.sub].includes(wasm[i + 2][0]) && wasm[i + 3][0] === Opcodes.local_set && wasm[i + 3][1] === inst[1] && (wasm[i + 4][0] === Opcodes.drop || wasm[i + 4][0] === Opcodes.br)) {

package/compiler/precompile.js

@@ -176,7 +176,7 @@ const compile = async (file, _funcs) => {
           x.usesTag = true;
           let id;
           if (y[0] === Opcodes.i32_const && n[1] === 0) {
-            id = read_signedLEB128(y.slice(1));
+            id = y[1];
             wasm[i] = [ 'throw', exceptions[id].constructor, exceptions[id].message ];
 
             // remove throw inst
@@ -244,7 +244,7 @@ ${funcs.map(x => {
       if (Number.isNaN(v) || v === Infinity || v === -Infinity) return v.toString();
       return v;
     })
-      .replace(/\["alloc","(.*?)",(.*?)\]/g, (_, reason, valtype) => `number(allocPage(_,'${reason}'),${valtype})`)
+      .replace(/\["alloc","(.*?)",(.*?)\]/g, (_, reason, valtype) => `[${valtype === Valtype.i32 ? Opcodes.i32_const : Opcodes.f64_const},allocPage(_,'${reason}')]`)
       .replace(/\["global",(.*?),"(.*?)",(.*?)\]/g, (_, opcode, name, valtype) => `...glbl(${opcode},'${name}',${valtype})`)
       .replace(/\"local","(.*?)",(.*?)\]/g, (_, name, valtype) => `loc('${name}',${valtype})]`)
       .replace(/\[16,"(.*?)"]/g, (_, name) => `[16,builtin('${name}')]`)

package/compiler/wrap.js

@@ -586,7 +586,10 @@ export default (source, module = undefined, print = str => process.stdout.write(
   }
 
   times.push(performance.now() - t2);
-  if (Prefs.profileCompiler && !globalThis.onProgress) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
+  if (Prefs.profileCompiler) {
+    if (globalThis.onProgress) globalThis.onProgress('instantiated', times[1]);
+      else console.log(`instantiated in ${times[1].toFixed(2)}ms`);
+  }
 
   const exports = {};
   const rawValues = Prefs.d;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.60.8",
+  "version": "0.60.9",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},
   "dependencies": {
     "acorn": "^8.15.0",
-    "node-repl-polyfill": "github:CanadaHonk/node-repl-polyfill"
+    "node-repl-polyfill": "^0.1.2"
   },
   "optionalDependencies": {
     "@babel/parser": "^7.24.4",

package/runtime/index.js

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