porffor 0.60.8 → 0.60.10

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) => {
@@ -83,7 +89,7 @@ const isFuncType = type =>
   type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression' ||
   type === 'ClassDeclaration' || type === 'ClassExpression';
 const hasFuncWithName = name =>
-  Object.hasOwn(funcIndex, name) || Object.hasOwn(builtinFuncs, name) || Object.hasOwn(importedFuncs, name) || Object.hasOwn(internalConstrs, name);
+  name in funcIndex || name in builtinFuncs || name in importedFuncs || name in internalConstrs;
 
 const astCache = new WeakMap();
 const cacheAst = (decl, wasm) => {
@@ -535,8 +541,8 @@ const generateEnum = (scope, decl) => {
 const optional = (op, clause = op.at(-1)) => clause || clause === 0 ? (Array.isArray(op[0]) ? op : [ op ]) : [];
 
 const lookupName = (scope, name) => {
-  if (Object.hasOwn(scope.locals, name)) return [ scope.locals[name], false ];
-  if (Object.hasOwn(globals, name)) return [ globals[name], true ];
+  if (name in scope.locals) return [ scope.locals[name], false ];
+  if (name in globals) return [ globals[name], true ];
 
   return [ undefined, undefined ];
 };
@@ -602,7 +608,7 @@ const hoistLookupType = (scope, name) => {
 const lookup = (scope, name, failEarly = false) => {
   let local = scope.locals[name];
 
-  if (Object.hasOwn(builtinVars, name)) {
+  if (name in builtinVars) {
     let wasm = builtinVars[name];
     if (wasm.usesImports) scope.usesImports = true;
 
@@ -610,9 +616,9 @@ const lookup = (scope, name, failEarly = false) => {
     return wasm.slice();
   }
 
-  if (!Object.hasOwn(funcIndex, name) && Object.hasOwn(builtinFuncs, name)) {
+  if (!(name in funcIndex) && name in builtinFuncs) {
     includeBuiltin(scope, name);
-  } else if (Object.hasOwn(internalConstrs, name)) {
+  } else if (name in internalConstrs) {
     // todo: return an actual something
     return [ number(1) ];
   }
@@ -656,16 +662,16 @@ const lookup = (scope, name, failEarly = false) => {
     }
 
     // no local var with name
-    if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name].idx ] ];
-    if (Object.hasOwn(funcIndex, name)) return funcRef(funcByName(name));
-    if (Object.hasOwn(importedFuncs, name)) return [ number(importedFuncs[name] - importedFuncs.length) ];
+    if (name in globals) return [ [ Opcodes.global_get, globals[name].idx ] ];
+    if (name in funcIndex) return funcRef(funcByName(name));
+    if (name in importedFuncs) return [ number(importedFuncs[name] - importedFuncs.length) ];
 
     if (name.startsWith('__')) {
       // return undefined if unknown key in already known var
       let parent = name.slice(2).split('_').slice(0, -1).join('_');
       if (parent.includes('_')) parent = '__' + parent;
 
-      if (Object.hasOwn(builtinFuncs, name + '$get')) {
+      if ((name + '$get') in builtinFuncs) {
         // hack: force error as accessors should only be used with objects anyway
         return internalThrow(scope, 'TypeError', 'Accessor called without object');
       }
@@ -1468,7 +1474,7 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
   },
   glbl: (opcode, name, type) => {
     const globalName = '#porf#' + name; // avoid potential name clashing with user js
-    if (!Object.hasOwn(globals, globalName)) {
+    if (!(globalName in globals)) {
       const idx = globals['#ind']++;
       globals[globalName] = { idx, type };
 
@@ -1503,7 +1509,7 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
     return out;
   },
   loc: (name, type) => {
-    if (!Object.hasOwn(scope.locals, name)) {
+    if (!(name in scope.locals)) {
       const idx = scope.localInd++;
       scope.locals[name] = { idx, type };
     }
@@ -1545,7 +1551,7 @@ const asmFunc = (name, func) => {
   if (existing) return existing;
 
   const allLocals = params.concat(localTypes);
-  const locals = {};
+  const locals = Object.create(null);
   for (let i = 0; i < allLocals.length; i++) {
     locals[localNames[i] ?? `l${i}`] = { idx: i, type: allLocals[i] };
   }
@@ -1640,14 +1646,14 @@ const getType = (scope, name, failEarly = false) => {
     [ null, () => hoistLookupType(scope, name) ]
   ];
 
-  if (Object.hasOwn(builtinVars, name)) return [ number(builtinVars[name].type ?? TYPES.number, Valtype.i32) ];
+  if (name in builtinVars) return [ number(builtinVars[name].type ?? TYPES.number, Valtype.i32) ];
 
   let metadata, typeLocal, global = null;
-  if (Object.hasOwn(scope.locals, name)) {
+  if (name in scope.locals) {
     metadata = scope.locals[name].metadata;
     typeLocal = scope.locals[name + '#type'];
     global = false;
-  } else if (Object.hasOwn(globals, name)) {
+  } else if (name in globals) {
     metadata = globals[name].metadata;
     typeLocal = globals[name + '#type'];
     global = true;
@@ -1681,10 +1687,10 @@ const setType = (scope, name, type, noInfer = false) => {
   const out = typeof type === 'number' ? [ number(type, Valtype.i32) ] : type;
 
   let metadata, typeLocal, global = false;
-  if (Object.hasOwn(scope.locals, name)) {
+  if (name in scope.locals) {
     metadata = scope.locals[name].metadata;
     typeLocal = scope.locals[name + '#type'];
-  } else if (Object.hasOwn(globals, name)) {
+  } else if (name in globals) {
     metadata = globals[name].metadata;
     typeLocal = globals[name + '#type'];
     global = true;
@@ -1791,8 +1797,8 @@ const getNodeType = (scope, node) => {
         if (func.returnType != null) return func.returnType;
       }
 
-      if (Object.hasOwn(builtinFuncs, name) && builtinFuncs[name].returnType != null) return builtinFuncs[name].returnType;
-      if (Object.hasOwn(internalConstrs, name) && internalConstrs[name].type != null) return internalConstrs[name].type;
+      if (name in builtinFuncs && builtinFuncs[name].returnType != null) return builtinFuncs[name].returnType;
+      if (name in internalConstrs && internalConstrs[name].type != null) return internalConstrs[name].type;
 
       if (name.startsWith('__Porffor_wasm_')) {
         // todo: return undefined for non-returning ops
@@ -2165,7 +2171,7 @@ const createThisArg = (scope, decl) => {
   const name = decl.callee?.name;
   if (decl._new) {
     // if precompiling or builtin func, just make it null as unused
-    if (!decl._forceCreateThis && (globalThis.precompile || Object.hasOwn(builtinFuncs, name))) return [
+    if (!decl._forceCreateThis && (globalThis.precompile || name in builtinFuncs)) return [
       number(NULL),
       number(TYPES.object, Valtype.i32)
     ];
@@ -2332,7 +2338,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     target.name = spl.slice(0, -1).join('_');
 
     if (builtinFuncs['__' + target.name + '_' + protoName]) protoName = null;
-      else if (lookupName(scope, target.name)[0] == null && !Object.hasOwn(builtinFuncs, target.name)) {
+      else if (lookupName(scope, target.name)[0] == null && !(target.name in builtinFuncs)) {
         if (lookupName(scope, '__' + target.name)[0] != null || builtinFuncs['__' + target.name]) target.name = '__' + target.name;
           else protoName = null;
       }
@@ -2472,18 +2478,18 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   let idx;
   if (decl._funcIdx) {
     idx = decl._funcIdx;
-  } else if (Object.hasOwn(internalConstrs, name) && !decl._noInternalConstr) {
+  } else if (name in internalConstrs && !decl._noInternalConstr) {
     if (decl._new && internalConstrs[name].notConstr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
     return internalConstrs[name].generate(scope, decl, _global, _name);
-  } else if (Object.hasOwn(funcIndex, name)) {
+  } else if (name in funcIndex) {
     idx = funcIndex[name];
   } else if (scope.name === name) {
     // fallback for own func but with a different var/id name
     idx = scope.index;
-  } else if (Object.hasOwn(importedFuncs, name)) {
+  } else if (name in importedFuncs) {
     idx = importedFuncs[name];
     scope.usesImports = true;
-  } else if (Object.hasOwn(builtinFuncs, name)) {
+  } else if (name in builtinFuncs) {
     if (decl._new && !builtinFuncs[name].constr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
 
     includeBuiltin(scope, name);
@@ -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) {
@@ -3130,7 +3136,7 @@ const allocVar = (scope, name, global = false, type = true, redecl = false, i32
   const target = global ? globals : scope.locals;
 
   // already declared
-  if (Object.hasOwn(target, name)) {
+  if (name in target) {
     if (redecl) {
       // force change old local name(s)
       target['#redecl_' + name + uniqId()] = target[name];
@@ -3326,7 +3332,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
       const [ _func, out ] = generateFunc(scope, init, true);
 
       const funcName = init.id?.name;
-      if (name !== funcName && Object.hasOwn(funcIndex, funcName)) {
+      if (name !== funcName && funcName in funcIndex) {
         funcIndex[name] = funcIndex[funcName];
         delete funcIndex[funcName];
       }
@@ -3341,7 +3347,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
     }
 
     let out = [];
-    if (topLevel && Object.hasOwn(builtinVars, name)) {
+    if (topLevel && name in builtinVars) {
       // cannot redeclare
       if (kind !== 'var') return internalThrow(scope, 'SyntaxError', `Identifier '${unhackName(name)}' has already been declared`);
 
@@ -3389,7 +3395,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
       }
 
       if (globalThis.precompile && global) {
-        scope.globalInits ??= {};
+        scope.globalInits ??= Object.create(null);
         scope.globalInits[name] = newOut;
       }
     } else {
@@ -4208,7 +4214,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
       ];
     }
 
-    if (Object.hasOwn(builtinVars, name)) {
+    if (name in builtinVars) {
       if (scope.strict) return internalThrow(scope, 'TypeError', `Cannot assign to non-writable global ${name}`, true);
 
       // just return rhs (eg `NaN = 2`)
@@ -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 ]
     ]),
 
@@ -5839,7 +5845,7 @@ const wrapBC = (bc, { prelude = [], postlude = [] } = {}) => {
 
 const countParams = (func, name = undefined) => {
   if (!func) {
-    if (Object.hasOwn(importedFuncs, name)) {
+    if (name in importedFuncs) {
       // reverse lookup then normal lookup
       func = importedFuncs[importedFuncs[name]];
       if (func) return func.params?.length ?? func.params;
@@ -6571,6 +6577,7 @@ const generateTemplate = (scope, decl) => {
 
 const generateTaggedTemplate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
   const intrinsics = {
+    __proto__: null,
     __Porffor_wasm: str => {
       let out = [];
 
@@ -6597,12 +6604,12 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
         const immediates = asm.slice(1).map(x => {
           const n = parseFloat(x);
           if (Number.isNaN(n) && x !== 'NaN') {
-            if (Object.hasOwn(builtinFuncs, x)) {
+            if (x in builtinFuncs) {
               if (funcIndex[x] == null) includeBuiltin(scope, x);
               return funcIndex[x];
             }
 
-            if (Object.hasOwn(importedFuncs, x)) {
+            if (x in importedFuncs) {
               scope.usesImports = true;
               return importedFuncs[x];
             }
@@ -6615,6 +6622,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;
@@ -6641,7 +6649,7 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
   };
 
   const { quasis, expressions } = decl.quasi;
-  if (Object.hasOwn(intrinsics, decl.tag.name)) {
+  if (decl.tag.name in intrinsics) {
     let str = quasis[0].value.raw;
 
     for (let i = 0; i < expressions.length; i++) {
@@ -6725,7 +6733,7 @@ const objectHack = node => {
       if (objectName !== 'Object_prototype' && (node.property.name === 'propertyIsEnumerable' || node.property.name === 'hasOwnProperty' || node.property.name === 'isPrototypeOf')) return abortOut;
 
       const name = '__' + objectName + '_' + node.property.name;
-      if ((!hasFuncWithName(name) && !Object.hasOwn(builtinVars, name) && !hasFuncWithName(name + '$get')) && (hasFuncWithName(objectName) || Object.hasOwn(builtinVars, objectName) || hasFuncWithName('__' + objectName) || Object.hasOwn(builtinVars, '__' + objectName))) return abortOut;
+      if ((!hasFuncWithName(name) && !(name in builtinVars) && !hasFuncWithName(name + '$get')) && (hasFuncWithName(objectName) || objectName in builtinVars || hasFuncWithName('__' + objectName) || ('__' + objectName) in builtinVars)) return abortOut;
 
       if (Prefs.codeLog) log('codegen', `object hack! ${node.object.name}.${node.property.name} -> ${name}`);
 
@@ -6788,7 +6796,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
   const arrow = decl.type === 'ArrowFunctionExpression' || decl.type === 'Program';
   const func = {
     start: decl.start,
-    locals: {},
+    locals: Object.create(null),
     localInd: 0,
     returns: [ valtypeBinary, Valtype.i32 ], // value, type
     name,
@@ -6998,7 +7006,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
         wasm.push(...getNodeType(func, getLastNode(decl.body.body)));
 
         // inject promise job runner func at the end of main if promises are made
-        if (Object.hasOwn(funcIndex, 'Promise') || Object.hasOwn(funcIndex, '__Promise_resolve') || Object.hasOwn(funcIndex, '__Promise_reject')) {
+        if (('Promise' in funcIndex) || ('__Promise_resolve' in funcIndex) || ('__Promise_reject' in funcIndex)) {
           wasm.push(
             [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_runJobs').index ]
           );
@@ -7173,6 +7181,7 @@ const generateBlock = (scope, decl) => {
 };
 
 const internalConstrs = {
+  __proto__: null,
   __Array_of: {
     // this is not a constructor but best fits internal structure here
     generate: (scope, decl, global, name) => {
@@ -7362,7 +7371,8 @@ const internalConstrs = {
 
 let globals, tags, exceptions, funcs, indirectFuncs, funcIndex, currentFuncIndex, depth, pages, data, typeswitchDepth, usedTypes, coctc, globalInfer, builtinFuncs, builtinVars, lastValtype;
 export default program => {
-  globals = { ['#ind']: 0 };
+  globals = Object.create(null);
+  globals['#ind'] = 0;
   tags = [];
   exceptions = [];
   funcs = []; indirectFuncs = [];
@@ -7370,7 +7380,7 @@ export default program => {
     return indirectFuncs._bytesPerFuncLut ??=
       Math.min(Math.floor((pageSize * 2) / indirectFuncs.length), indirectFuncs.reduce((acc, x) => x.name.length > acc ? x.name.length : acc, 0) + 8);
   };
-  funcIndex = {};
+  funcIndex = Object.create(null);
   depth = [];
   pages = new Map();
   data = [];
@@ -7397,8 +7407,8 @@ export default program => {
   // keep builtins between compiles as much as possible
   if (lastValtype !== valtypeBinary) {
     lastValtype = valtypeBinary;
-    builtinFuncs = new BuiltinFuncs();
-    builtinVars = new BuiltinVars({ builtinFuncs });
+    builtinFuncs = BuiltinFuncs();
+    builtinVars = BuiltinVars({ builtinFuncs });
 
     const getObjectName = x => x.startsWith('__') && x.slice(2, x.indexOf('_', 2));
     objectHackers = ['assert', 'compareArray', 'Test262Error', ...new Set(Object.keys(builtinFuncs).map(getObjectName).concat(Object.keys(builtinVars).map(getObjectName)).filter(x => x))];

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
@@ -237,14 +237,14 @@ const precompile = async () => {
   return `// autogenerated by compiler/precompile.js
 import { number } from './encoding.js';
 
-export const BuiltinFuncs = function() {
+export const BuiltinFuncs = x => {
 ${funcs.map(x => {
   const rewriteWasm = wasm => {
     const str = JSON.stringify(wasm.filter(x => x.length && (x[0] != null || typeof x[1] === 'string')), (k, v) => {
       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}')]`)
@@ -278,7 +278,7 @@ ${funcs.map(x => {
   const name = x.name.includes('#') ? `['${x.name}']` : `.${x.name}`;
 
   const returnTypes = [...(x.returnTypes ?? [])].filter(x => ![ TYPES.undefined, TYPES.number, TYPES.boolean, TYPES.function ].includes(x));
-  return `this${name} = {
+  return `x${name} = {
 wasm:${rewriteWasm(x.wasm)},
 params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.returns)},${x.returnType != null ? `returnType:${JSON.stringify(x.returnType)},` : ''}${returnTypes.length > 0 ? `returnTypes:${JSON.stringify(returnTypes)},` : ''}jsLength:${x.jsLength},
 locals:${JSON.stringify(locals.slice(x.params.length).map(x => x[1].type))},localNames:${JSON.stringify(locals.map(x => x[0]))},

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;