porffor 0.60.7 → 0.60.9

package/compiler/codegen.js

@@ -1,13 +1,78 @@
 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';
 import parse from './parse.js';
 import { log } from './log.js';
-import { allocPage, allocStr } from './allocator.js';
 import './prefs.js';
 
+const pagePtr = ind => {
+  if (ind === 0) return 16;
+  return ind * pageSize;
+};
+
+const allocPage = (scope, name) => {
+  if (!name.startsWith('#')) {
+    name = `${scope.name}/${name}`;
+    if (globalThis.precompile) name = `${globalThis.precompile}/${name}`;
+  }
+
+  if (pages.has(name)) {
+    return pagePtr(pages.get(name));
+  }
+
+  const ind = pages.size;
+  pages.set(name, ind);
+
+  scope.pages ??= new Map();
+  scope.pages.set(name, ind);
+
+  return pagePtr(ind);
+};
+
+const allocBytes = (scope, reason, bytes) => {
+  bytes += 2; // overallocate by 2 bytes to ensure null termination
+
+  const allocs = pages.allocs ??= new Map();
+  const bins = pages.bins ??= [];
+
+  if (allocs.has(reason)) {
+    return allocs.get(reason);
+  }
+
+  let startingPtr = 0;
+  while (bytes > 0) {
+    const alloc = Math.min(bytes, pageSize);
+    bytes -= alloc;
+
+    let bin = bins.find(x => (pageSize - x.used) >= alloc);
+    if (!bin) {
+      // new bin
+      const page = pages.size;
+      bin = {
+        used: 0,
+        page
+      };
+
+      const id = bins.push(bin);
+      pages.set(`#bin: ${id}`, page);
+    }
+
+    if (!startingPtr) startingPtr = pagePtr(bin.page) + bin.used;
+    bin.used += alloc;
+  }
+
+  allocs.set(reason, startingPtr);
+  return startingPtr;
+};
+
+export const allocStr = (scope, str, bytestring) => {
+  // basic string interning for ~free
+  const bytes = 4 + str.length * (bytestring ? 1 : 2);
+  return allocBytes(scope, str, bytes);
+};
+
 const todo = (scope, msg, expectsValue = undefined) => {
   msg = `todo: ${msg}`;
 
@@ -1465,10 +1530,10 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
     wasm.push(Opcodes.i32_to_u);
     return wasm;
   },
-  allocPage: (scope, name) => allocPage({ scope, pages }, name),
+  allocPage,
   allocLargePage: (scope, name) => {
-    const _ = allocPage({ scope, pages }, name);
-    allocPage({ scope, pages }, name + '#2');
+    const _ = allocPage(scope, name);
+    allocPage(scope, name + '#2');
 
     return _;
   }
@@ -2781,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) {
@@ -4260,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
       ];
@@ -5059,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 ]
     ]),
 
@@ -5582,7 +5647,7 @@ const makeString = (scope, str, bytestring = true) => {
     if (c > 0xFF) bytestring = false;
   }
 
-  const ptr = allocStr({ scope, pages }, str, bytestring);
+  const ptr = allocStr(scope, str, bytestring);
   makeData(scope, elements, str, bytestring ? 'i8' : 'i16');
 
   return [ number(ptr) ];
@@ -5598,7 +5663,7 @@ const generateArray = (scope, decl, global = false, name = '$undeclared', static
   if (staticAlloc || decl._staticAlloc) {
     const uniqueName = name === '$undeclared' ? name + uniqId() : name;
 
-    const ptr = allocPage({ scope, pages }, uniqueName);
+    const ptr = allocPage(scope, uniqueName);
     pointer = number(ptr, Valtype.i32);
 
     scope.arrays ??= new Map();
@@ -6556,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

@@ -57,7 +57,7 @@ const compile = async (file, _funcs) => {
     first = source.slice(0, source.indexOf('\n'));
   }
 
-  let args = ['--module', '--todo-time=compile', '--truthy=no_nan_negative', '--no-rm-unused-types', '--scoped-page-names', '--fast-length', '--parse-types', '--opt-types', '--no-passive-data', '--active-data', '--no-treeshake-wasm-imports', '--no-coctc'];
+  let args = ['--module', '--todo-time=compile', '--truthy=no_nan_negative', '--no-rm-unused-types', '--fast-length', '--parse-types', '--opt-types', '--no-passive-data', '--active-data', '--no-treeshake-wasm-imports', '--no-coctc'];
   if (first.startsWith('// @porf')) {
     args = first.slice('// @porf '.length).split(' ').concat(args);
   }
@@ -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.7",
+  "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.7';
+globalThis.version = '0.60.9';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {

package/AGENTS.md

@@ -1,20 +0,0 @@
-you are an assistant coder for Porffor - an early javascript and typescript to webassembly and native ahead-of-time compiler. the codebase is written in js and ts.
-
-- built-ins apis (Date, String.prototype, etc) are written in ts inside `compiler/builtins`
-- once you update a file inside that directory, you MUST run `./porf precompile` to compile to make your changes effective
-- test your work using the test262 tools available, iterate independently but do not get stuck on one chain of thought or approach. paths for test262 tools should be relative to the 'test262/test' directory (e.g., 'built-ins/RegExp' NOT 'test262/test/built-ins/RegExp').
-- to get an overview of the most failing directories, use the command: `node test262/fails.cjs`
-- to just evaluate code in the engine, use the command: `./porf -p "..."`
-- after finishing, check if your work/diff could be simplified
-- always use single quotes (unless double is required)
-- 2-space indentation, LF line endings, no trailing whitespace
-- built-in APIs in `compiler/builtins/` written in TypeScript
-- inline code in built-ins, avoid helper functions
-- use semicolons
-- do not use trailing commas
-- use const/let, avoid var
-- follow existing naming: camelCase for variables, PascalCase for types
-- when possible, do not concat strings and instead write to them directly using wasm memory
-- there are no closures, you cannot use locals between functions. use arguments or globals if really necessary
-- The user prefers that prototype functions not have explicit return types in this codebase.
-- The user prefers not to use global variables in built-in functions.

package/compiler/allocator.js

@@ -1,65 +0,0 @@
-import './prefs.js';
-
-const pagePtr = ind => {
-  if (ind === 0) return 16;
-  return ind * pageSize;
-};
-
-export const nameToReason = (scope, name) => {
-  let scopeName = scope.name;
-  if (globalThis.precompile && scopeName === '#main') scopeName = globalThis.precompile;
-
-  return `${Prefs.scopedPageNames ? (scopeName + '/') : ''}${name}`;
-};
-
-export const allocPage = ({ scope, pages }, name) => {
-  const reason = nameToReason(scope, name);
-
-  if (pages.has(reason)) {
-    return pagePtr(pages.get(reason));
-  }
-
-  const ind = pages.size;
-  pages.set(reason, ind);
-
-  scope.pages ??= new Map();
-  scope.pages.set(reason, ind);
-
-  return pagePtr(ind);
-};
-
-export const allocBytes = ({ scope, pages }, reason, bytes) => {
-  bytes += 2; // overallocate by 2 bytes to ensure null termination
-
-  const allocs = pages.allocs ??= new Map();
-  const bins = pages.bins ??= [];
-
-  if (allocs.has(reason)) {
-    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
-    };
-
-    const id = bins.push(bin);
-    pages.set(`#bin: ${id}`, page);
-  }
-
-  const ptr = pagePtr(bin.page) + bin.used;
-  bin.used += bytes;
-
-  allocs.set(reason, ptr);
-  return ptr;
-};
-
-export const allocStr = ({ scope, pages }, str, bytestring) => {
-  // basic string interning for ~free
-  const bytes = 4 + str.length * (bytestring ? 1 : 2);
-  return allocBytes({ scope, pages }, str, bytes);
-};