porffor 0.55.20 → 0.55.21

package/compiler/builtins/bigint.ts

@@ -5,11 +5,11 @@ export const __Porffor_bigint_fromDigits = (negative: boolean, digits: i32[]): b
   const len: i32 = digits.length;
   if (len > 16383) throw new RangeError('Maximum BigInt size exceeded'); // (65536 - 4) / 4
 
-  // const ptr: i32 = Porffor.allocate();
+  // use digits pointer as bigint pointer, as only used here
   let ptr: i32 = Porffor.wasm`local.get ${digits}`;
 
-  Porffor.wasm.i32.store8(ptr, negative ? 1 : 0, 0, 0);
-  Porffor.wasm.i32.store16(ptr, len, 0, 2);
+  Porffor.wasm.i32.store8(ptr, negative ? 1 : 0, 0, 0); // sign
+  Porffor.wasm.i32.store16(ptr, len, 0, 2); // digit count
 
   let allZero: boolean = true;
   for (let i: i32 = 0; i < len; i++) {
@@ -84,14 +84,10 @@ export const __Porffor_bigint_fromString = (n: string|bytestring): bigint => {
     offset = 1;
   }
 
-  // n -> digits (base 2^32) (most to least significant)
-  // 4294967294 -> [ 4294967294 ]
+  // n -> base 2^32 digits (most to least significant)
   // 4294967295 -> [ 4294967295 ]
   // 4294967296 -> [ 1, 0 ]
   // 4294967297 -> [ 1, 1 ]
-  // 9007199254740992 -> [ 2097152, 0 ]
-  // 9007199254740993 -> [ 2097152, 1 ]
-  // 9007199254740994 -> [ 2097152, 2 ]
 
   const BASE: i32 = 0x100000000; // 2^32
   const digits: i32[] = Porffor.allocate(); // todo: free later

package/compiler/codegen.js

@@ -462,7 +462,7 @@ const lookup = (scope, name, failEarly = false) => {
   }
 
   if (local?.idx === undefined) {
-    if (name === 'arguments' && scope.name !== '#main' && !scope.arrow) {
+    if (name === 'arguments' && !scope.arrow) {
       // todo: not compliant
       let len = countLength(scope);
       const names = new Array(len);
@@ -1386,29 +1386,6 @@ const generateLogicExp = (scope, decl) => {
   return performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right));
 };
 
-// potential future ideas for nan boxing (unused):
-// T = JS type, V = value/pointer
-// 0bTTT
-// qNAN: 0 11111111111 1000000000000000000000000000000000000000000000000001
-// 50 bits usable: 0 11111111111 11??????????????????????????????????????????????????
-// js type: 4 bits
-// internal type: ? bits
-// pointer: 32 bits
-// https://piotrduperas.com/posts/nan-boxing
-// 0x7ffc000000000000
-// budget: 50 bits
-// js type: 4 bits
-// internal type: ? bits
-// pointer: 32 bits
-// generic
-// 1              23   4             5
-// 0 11111111111 11TTTTIIII??????????PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
-// 1: regular iEEE 754 double NaN
-// 2: extra 1 bit to identify NaN box
-// 3: js type
-// 4: internal type
-// 5: pointer
-
 const isExistingProtoFunc = name => {
   if (name.startsWith('__Array_prototype')) return !!prototypeFuncs[TYPES.array][name.slice(18)];
   if (name.startsWith('__String_prototype_')) return !!prototypeFuncs[TYPES.string][name.slice(19)];
@@ -1470,7 +1447,7 @@ const getType = (scope, name, failEarly = false) => {
     global = true;
   }
 
-  if (global !== false && name === 'arguments' && scope.name !== '#main' && !scope.arrow) {
+  if (global !== false && name === 'arguments' && !scope.arrow) {
     return [ number(TYPES.array, Valtype.i32) ];
   }
 
@@ -2750,18 +2727,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   out.push([ Opcodes.call, idx ]);
-
-  if (!typedReturns) {
-    // let type;
-    // if (builtinFuncs[name]) type = TYPES[builtinFuncs[name].returnType ?? 'number'];
-    // if (internalConstrs[name]) type = internalConstrs[name].type;
-    // if (importedFuncs[name] && importedFuncs[]) type =
-
-    // if (type) out.push(
-    //   number(type, Valtype.i32),
-    //   [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
-    // );
-  } else out.push(...setLastType(scope));
+  if (typedReturns) out.push(...setLastType(scope));
 
   if (
     func?.returns?.length === 0 ||
@@ -3571,9 +3537,8 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
 const generateVar = (scope, decl) => {
   let out = [];
 
-  const topLevel = scope.name === '#main';
-
   // global variable if in top scope (main) or if internally wanted
+  const topLevel = scope.name === '#main';
   const global = decl._global ?? (topLevel || decl._bare);
 
   for (const x of decl.declarations) {
@@ -3637,6 +3602,15 @@ const memberTmpNames = scope => {
 // COCTC: cross-object compile-time cache
 let coctc = new Map();
 const coctcOffset = prop => {
+  if (typeof prop === 'object') {
+    if (
+      prop.computed || prop.optional ||
+      ['prototype', 'size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'length', '__proto__'].includes(prop.property.name)
+    ) return 0;
+
+    prop = prop.property.name;
+  }
+
   let offset = coctc.get(prop);
   if (offset == null) {
     offset = (coctc.lastOffset ?? 60000) - 9;
@@ -3768,7 +3742,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
     // todo/perf: use i32 object (and prop?) locals
     const { objectTmp, propertyTmp, objectGet, propertyGet } = memberTmpNames(scope);
 
-    const useCoctc = Prefs.coctc && !decl.left.computed && !decl.left.optional && !['prototype', 'size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'length', '__proto__'].includes(decl.left.property.name) && coctcOffset(decl.left.property.name) > 0;
+    const useCoctc = Prefs.coctc && coctcOffset(decl.left) > 0;
     if (useCoctc) valueUnused = false;
 
     // opt: do not mark prototype funcs as referenced to optimize this in them
@@ -4214,7 +4188,7 @@ const generateUnary = (scope, decl) => {
         const property = getProperty(decl.argument);
         if (property.value === 'length' || property.value === 'name') scope.noFastFuncMembers = true;
 
-        const useCoctc = Prefs.coctc && !decl.argument.computed && !decl.argument.optional && !['prototype', 'size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'length', '__proto__'].includes(decl.argument.property.name) && coctcOffset(decl.argument.property.name) > 0;
+        const useCoctc = Prefs.coctc && coctcOffset(decl.argument) > 0;
         const objectTmp = useCoctc && localTmp(scope, '#coctc_object', Valtype.i32);
 
         const out = [
@@ -5410,7 +5384,7 @@ const makeData = (scope, elements, page = null, itemType = 'i8') => {
 
   const length = elements.length;
 
-  // if length is 0 memory/data will just be 0000... anyway
+  // if length is 0, memory/data will just be 0000... anyway
   if (length === 0) return false;
 
   let bytes = compileBytes(length, 'i32');
@@ -5424,7 +5398,6 @@ const makeData = (scope, elements, page = null, itemType = 'i8') => {
   }
 
   const obj = { bytes, page };
-
   const idx = data.push(obj) - 1;
 
   scope.data ??= [];
@@ -5448,63 +5421,6 @@ const printStaticStr = str => {
   return out;
 };
 
-const storeArray = (scope, array, index, element) => {
-  if (!Array.isArray(element)) element = generate(scope, element);
-  if (typeof index === 'number') index = [ number(index) ];
-
-  const offset = localTmp(scope, '#storeArray_offset', Valtype.i32);
-
-  return [
-    // calculate offset
-    ...index,
-    Opcodes.i32_to_u,
-    number(ValtypeSize[valtype] + 1, Valtype.i32),
-    [ Opcodes.i32_mul ],
-
-    ...array,
-    Opcodes.i32_to_u,
-    [ Opcodes.i32_add ],
-    [ Opcodes.local_set, offset ],
-
-    // store value
-    [ Opcodes.local_get, offset ],
-    ...generate(scope, element),
-    [ Opcodes.store, 0, ValtypeSize.i32 ],
-
-    // store type
-    [ Opcodes.local_get, offset ],
-    ...getNodeType(scope, element),
-    [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
-  ];
-};
-
-const loadArray = (scope, array, index) => {
-  if (typeof index === 'number') index = [ number(index) ];
-
-  const offset = localTmp(scope, '#loadArray_offset', Valtype.i32);
-
-  return [
-    // calculate offset
-    ...index,
-    Opcodes.i32_to_u,
-    number(ValtypeSize[valtype] + 1, Valtype.i32),
-    [ Opcodes.i32_mul ],
-
-    ...array,
-    Opcodes.i32_to_u,
-    [ Opcodes.i32_add ],
-    [ Opcodes.local_set, offset ],
-
-    // load value
-    [ Opcodes.local_get, offset ],
-    [ Opcodes.load, 0, ValtypeSize.i32 ],
-
-    // load type
-    [ Opcodes.local_get, offset ],
-    [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
-  ];
-};
-
 const byteStringable = str => {
   for (let i = 0; i < str.length; i++) {
     if (str.charCodeAt(i) > 0xFF) return false;
@@ -5943,14 +5859,27 @@ const generateMember = (scope, decl, _global, _name) => {
     }
   }
 
-  const useCoctc = Prefs.coctc && !decl.computed && !decl.optional && !['prototype', 'size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'length', '__proto__'].includes(decl.property.name) && coctcOffset(decl.property.name) > 0;
+  const useCoctc = Prefs.coctc && coctcOffset(decl) > 0;
   const coctcObjTmp = useCoctc && localTmp(scope, '#coctc_obj' + uniqId(), Valtype.i32);
 
   const out = typeSwitch(scope, getNodeType(scope, object), {
     ...(decl.computed ? {
       [TYPES.array]: () => [
-        ...loadArray(scope, [ objectGet ], [ propertyGet ]),
-        ...setLastType(scope)
+        propertyGet,
+        Opcodes.i32_to_u,
+        number(ValtypeSize[valtype] + 1, Valtype.i32),
+        [ Opcodes.i32_mul ],
+
+        objectGet,
+        Opcodes.i32_to_u,
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_tee, localTmp(scope, '#loadArray_offset', Valtype.i32) ],
+        [ Opcodes.load, 0, ValtypeSize.i32 ],
+
+        ...setLastType(scope, [
+          [ Opcodes.local_get, localTmp(scope, '#loadArray_offset', Valtype.i32) ],
+          [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
+        ])
       ],
 
       [TYPES.string]: () => [
@@ -7072,28 +7001,24 @@ export default program => {
   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))];
 
-  program.id = { name: '#main' };
-
-  program.body = {
-    type: 'BlockStatement',
-    body: program.body
-  };
-
-  if (Prefs.astLog) console.log(JSON.stringify(program.body.body, null, 2));
-
-  const [ main ] = generateFunc({}, program);
+  const [ main ] = generateFunc({}, {
+    type: 'Program',
+    id: { name: '#main' },
+    body: {
+      type: 'BlockStatement',
+      body: program.body
+    }
+  });
 
   // if wanted and blank main func and other exports, remove it
   if (Prefs.rmBlankMain && main.wasm.length === 0 && funcs.some(x => x.export)) funcs.splice(main.index - importedFuncs.length, 1);
 
-  // make ~empty funcs for never generated funcs
-  // todo: these should just be deleted once able
   for (let i = 0; i < funcs.length; i++) {
     const f = funcs[i];
 
-    if (f.wasm) {
-      // run callbacks
-      const wasm = f.wasm;
+    const wasm = f.wasm;
+    if (wasm) {
+      // func was generated, run callback ops
       for (let j = 0; j < wasm.length; j++) {
         const o = wasm[j];
         if (o[0] === null && typeof o[1] === 'function') {
@@ -7104,14 +7029,8 @@ export default program => {
       continue;
     }
 
-    // make wasm just return 0s for expected returns
+    // func was never generated, make wasm just return 0s for expected returns
     f.wasm = f.returns.map(x => number(0, x));
-
-    // alternative: make func empty, may break some indirect calls
-    // f.wasm = [];
-    // f.returns = [];
-    // f.params = [];
-    // f.locals = {};
   }
 
   // // remove never generated functions
@@ -7151,10 +7070,9 @@ export default program => {
   for (let i = 0; i < indirectFuncs.length; i++) {
     const f = indirectFuncs[i];
     f.index = currentFuncIndex++;
+    funcs.push(f);
   }
 
-  funcs.push(...indirectFuncs);
-
   delete globals['#ind'];
 
   return { funcs, globals, tags, exceptions, pages, data };

package/package.json

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

package/runner/index.js

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