porffor 0.55.27 → 0.55.31

package/compiler/codegen.js

@@ -3,7 +3,7 @@ import { number, ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector, r
 import { operatorOpcode } from './expression.js';
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
 import { PrototypeFuncs } from './prototype.js';
-import { TYPES, TYPE_FLAGS, TYPE_NAMES, typeHasFlag } from './types.js';
+import { TYPES, TYPE_FLAGS, TYPE_NAMES } from './types.js';
 import * as Rhemyn from '../rhemyn/compile.js';
 import parse from './parse.js';
 import { log } from './log.js';
@@ -1505,7 +1505,18 @@ const setType = (scope, name, type, noInfer = false) => {
 };
 
 const getLastType = scope => {
-  if (!scope.locals['#last_type']) return [ number(TYPES.number, Valtype.i32) ];
+  if (!scope.locals['#last_type']) return [
+    [ null, () => {
+      if (scope.locals['#last_type']) {
+        scope.gotLastType = true;
+        return [
+          [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ]
+        ];
+      }
+
+      return [ number(TYPES.number, Valtype.i32) ];
+    } ]
+  ];
 
   scope.gotLastType = true;
   return [
@@ -1664,7 +1675,7 @@ const getNodeType = (scope, node) => {
 
       const objectKnownType = knownType(scope, getNodeType(scope, node.object));
       if (objectKnownType != null) {
-        if (name === 'length' && typeHasFlag(objectKnownType, TYPE_FLAGS.length)) return TYPES.number;
+        if (name === 'length' && (objectKnownType & TYPE_FLAGS.length) !== 0) return TYPES.number;
 
         if (node.computed) {
           if (objectKnownType === TYPES.string) return TYPES.string;
@@ -3653,7 +3664,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
     const type = getNodeType(scope, decl.left.object);
     const known = knownType(scope, type);
-    if (known != null && typeHasFlag(known, TYPE_FLAGS.length)) return [
+    if (known != null && (known & TYPE_FLAGS.length) !== 0) return [
       ...out,
       ...optional([ Opcodes.local_tee, pointerTmp ]),
 
@@ -5678,7 +5689,7 @@ const generateMember = (scope, decl, _global, _name) => {
 
     const type = getNodeType(scope, object);
     const known = knownType(scope, type);
-    if (known != null && typeHasFlag(known, TYPE_FLAGS.length)) return [
+    if (known != null && (known & TYPE_FLAGS.length) !== 0) return [
       ...out,
 
       [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
@@ -6655,6 +6666,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
   if (typedInput && decl.returnType) {
     const { type } = extractTypeAnnotation(decl.returnType);
     if (type != null) {
+      typeUsed(func, type);
       func.returnType = type;
       func.returns = func.returnType === TYPES.undefined && !func.async && !func.generator ? [] : [ valtypeBinary ];
     }

package/compiler/cyclone.js

@@ -1,6 +1,7 @@
 // cyclone: wasm partial constant evaluator (it is fast and dangerous hence "cyclone")
 import { number, signedLEB128, ieee754_binary64, read_ieee754_binary64, read_signedLEB128 } from './encoding.js';
 import { Opcodes, Valtype } from './wasmSpec.js';
+import './prefs.js';
 
 const f64ToI32Op = {
   [Opcodes.f64_eq]: Opcodes.i32_eq,
@@ -15,8 +16,16 @@ const f64ToI32Op = {
   [Opcodes.f64_div]: Opcodes.i32_div_s,
 };
 
-export default wasm => {
-  let stack = []; // """""stack"""""
+export default ({ name, wasm, locals: _locals, params }) => {
+  let locals = Object.values(_locals);
+  const localValtypes = locals.map(x => x.type);
+
+  const resetLocals = () => {
+    locals = new Array(locals.length).fill(false);
+  };
+  resetLocals();
+
+  let stack = []; // "stack"
   for (let i = 0; i < wasm.length; i++) {
     let op = wasm[i];
     if (!op) continue;
@@ -33,8 +42,13 @@ export default wasm => {
       stack.push({ val, op });
     };
 
+    const peek = () => stack[stack.length - 1]?.val;
+    const popWithoutRemove = () => stack.pop().val;
+
+    // let debugPops = [];
     const pop = () => {
       const popped = stack.pop();
+      // debugPops.unshift({ ...popped, index: wasm.indexOf(popped.op) });
 
       // remove the op
       wasm.splice(wasm.indexOf(popped.op), 1);
@@ -42,12 +56,18 @@ export default wasm => {
 
       return popped.val;
     };
-
     const pop2 = () => [ pop(), pop() ];
 
     const bool = v => v ? 1 : 0;
 
     const replaceOp = newOp => {
+      // console.log(`\x1b[4m${name}\x1b[0m`);
+      // const oldOps = [ ...debugPops, { op, index: i + debugPops.length } ];
+      // for (const x of oldOps) {
+      //   console.log(`\x1b[90m${x.index.toString().padStart(4)} ▌\x1b[0m ${disassemble([ x.op ], undefined, undefined, _locals).slice(0, -1)}${x.val != null ? ` \x1b[2m(${x.val})\x1b[0m` : ''}`);
+      // }
+      // process.stdout.write(`\x1b[s\x1b[${oldOps.length}A\x1b[40C\x1b[2m->\x1b[0m  ${disassemble([ newOp ]).slice(0, -1)}\x1b[u\n`);
+
       op.splice(0, op.length, ...newOp);
     };
     const replaceVal = (val, valtype) => replaceOp(number(val, valtype));
@@ -57,41 +77,41 @@ export default wasm => {
     };
 
     switch (opcode) {
-      case Opcodes.if: {
-        if (stack.length < 1) { empty(); break; }
-        const cond = bool(pop());
-
-        // find else split and end
-        let j = i + 1;
-        let depth = 0, elseStart = 0;
-        for (; j < wasm.length; j++) {
-          const op = wasm[j][0];
-          if (op === Opcodes.if || op === Opcodes.block || op === Opcodes.loop || op === Opcodes.try) depth++;
-          if (op === Opcodes.else && depth === 0) elseStart = j;
-          if (op === Opcodes.end) {
-            depth--;
-            if (depth < 0) break;
-          }
-          if (op === Opcodes.br || op === Opcodes.br_if) wasm[j][1] -= 1;
-        }
-
-        if (cond) {
-          // remove else if it exists, or just remove end
-          if (elseStart) wasm.splice(elseStart, j - elseStart + 1);
-            else wasm.splice(j, 1);
-        } else {
-          // remove truthy conseq and keep else if it exists, or just remove entire thing
-          if (elseStart) {
-            wasm.splice(j, 1); // remove end
-            wasm.splice(i + 1, elseStart - i + 1); // remove truthy conseq
-          } else wasm.splice(i + 1, j - i + 0); // no else, remove entire if
-        }
-
-        // remove this if op
-        wasm.splice(i, 1);
+      // case Opcodes.if: {
+      //   if (stack.length < 1) { empty(); break; }
+      //   const cond = bool(pop());
+
+      //   // find else split and end
+      //   let j = i + 1;
+      //   let depth = 0, elseStart = 0;
+      //   for (; j < wasm.length; j++) {
+      //     const op = wasm[j][0];
+      //     if (op === Opcodes.if || op === Opcodes.block || op === Opcodes.loop || op === Opcodes.try) depth++;
+      //     if (op === Opcodes.else && depth === 0) elseStart = j;
+      //     if (op === Opcodes.end) {
+      //       depth--;
+      //       if (depth < 0) break;
+      //     }
+      //     if (op === Opcodes.br || op === Opcodes.br_if) wasm[j][1] -= 1;
+      //   }
+
+      //   if (cond) {
+      //     // remove else if it exists, or just remove end
+      //     if (elseStart) wasm.splice(elseStart, j - elseStart + 1);
+      //       else wasm.splice(j, 1);
+      //   } else {
+      //     // remove truthy conseq and keep else if it exists, or just remove entire thing
+      //     if (elseStart) {
+      //       wasm.splice(j, 1); // remove end
+      //       wasm.splice(i + 1, elseStart - i + 1); // remove truthy conseq
+      //     } else wasm.splice(i + 1, j - i + 0); // no else, remove entire if
+      //   }
+
+      //   // remove this if op
+      //   wasm.splice(i, 1);
 
-        break;
-      }
+      //   break;
+      // }
 
       case Opcodes.i32_const: {
         const n = read_signedLEB128(op.slice(1));
@@ -448,8 +468,8 @@ export default wasm => {
         break;
       }
 
-      case Opcodes.f64_convert_i32_u:
-      case Opcodes.f64_convert_i32_s: {
+      case Opcodes.f64_convert_i32_s:
+      case Opcodes.f64_convert_i32_u: {
         if (stack.length < 1) { empty(); break; };
         const v = pop();
 
@@ -458,7 +478,8 @@ export default wasm => {
         break;
       }
 
-      case 0xfc02: { // i32_trunc_sat_f64_s
+      case 0xfc02: // i32.trunc_sat_f64_s
+      case 0xfc03: { // i32.trunc_sat_f64_u
         if (stack.length < 1) { empty(); break; }
         const v = pop();
 
@@ -467,20 +488,60 @@ export default wasm => {
         break;
       }
 
-      case 0xfc03: { // i32_trunc_sat_f64_u
+      case Opcodes.drop: {
         if (stack.length < 1) { empty(); break; }
-        const v = pop();
+        pop();
+        break;
+      }
 
-        replaceVal(v, Valtype.i32);
-        push(v);
+      case Opcodes.local_get: {
+        const x = locals[op[1]];
+        if (x === false) {
+          empty();
+        } else {
+          replaceVal(x, localValtypes[op[1]]);
+          push(x);
+        }
         break;
       }
 
-      // case Opcodes.local_tee: {
-      //   if (stack.length < 1) { empty(); break; }
-      //   push(pop());
-      //   break;
-      // }
+      case Opcodes.local_set: {
+        if (stack.length < 1) {
+          locals[op[1]] = false;
+          empty();
+          break;
+        }
+
+        const x = popWithoutRemove();
+        locals[op[1]] = x;
+        break;
+      }
+
+      case Opcodes.local_tee: {
+        if (stack.length < 1) {
+          locals[op[1]] = false;
+          empty();
+          break;
+        }
+
+        const x = pop();
+        locals[op[1]] = x;
+        replaceVal(x, localValtypes[op[1]]);
+        push(x);
+        break;
+      }
+
+      case Opcodes.block:
+      case Opcodes.loop:
+      case Opcodes.try:
+      case Opcodes.if:
+      case Opcodes.else:
+      case Opcodes.catch:
+      case Opcodes.end: {
+        resetLocals();
+        empty();
+        break;
+      }
 
       default: {
         empty();
@@ -500,69 +561,69 @@ export default wasm => {
     // i32.const 1
     // i32.add
     // local.set 7 ;; $i (i32)
-    if (i >= 2 &&
-      ((opcode >= 0xa0 && opcode <= 0xa3) || // main f64 math op
-      (opcode >= 0x61 && opcode <= 0x66)) // main f64 eq op
-    ) {
-      const o2 = wasm[i - 1][0];
-      if (o2 === Opcodes.f64_const) { // f64.const
-        const o3 = wasm[i - 2][0];
-        if (o3 === Opcodes.f64_convert_i32_s || o3 === Opcodes.f64_convert_i32_u) {
-          // remove now unneeded i32 -> f64 convert
-          wasm.splice(i - 2, 1);
-          i--;
-
-          // convert f64.const -> i32.const
-          const n = wasm[i - 1][1];
-          wasm.splice(i - 1, 1, number(n, Valtype.i32));
-
-          // convert math op from f64 to i32
-          wasm[i][0] = f64ToI32Op[wasm[i][0]];
-
-          const nextOp = wasm[i + 1];
-          if (nextOp && opcode >= 0xa0 && opcode <= 0xa3) {
-            if (nextOp[0] === 0xfc && (nextOp[1] === 0x02 || nextOp[1] === 0x03)) {
-              // remove optional unneeded f64 -> i32 convert after
-              wasm.splice(i + 1, 1);
-            } else {
-              // add now needed i32 -> f64 convert after
-              wasm.splice(i + 1, Opcodes.i32_trunc_sat_f64_s);
-            }
-          }
-        }
-      }
-    }
-
-    if ((opcode === 0xfc02 || opcode === 0xfc03) && i >= 3) { // i32.trunc_sat_f64_s/u
-      const o2 = wasm[i - 1][0];
-      if (
-        (o2 >= 0xa0 && o2 <= 0xa3) || // main f64 math op
-        (o2 >= 0x61 && o2 <= 0x66) // main f64 eq op
-      ) {
-        const o3 = wasm[i - 2][0];
-        if (o3 === Opcodes.f64_const) { // f64.const
-          const o4 = wasm[i - 3][0];
-          if (o4 === Opcodes.f64_convert_i32_s || o4 === Opcodes.f64_convert_i32_u) {
-            // remove now unneeded i32 -> f64 convert
-            wasm.splice(i - 3, 1);
-            i--;
-          } else {
-            // add now needed f64 -> i32 convert prior
-            wasm.splice(i - 2, 0, Opcodes.i32_trunc_sat_f64_s);
-            i++;
-          }
-
-          // convert f64.const -> i32.const
-          const n = wasm[i - 2][1];
-          wasm.splice(i - 2, 1, number(n, Valtype.i32));
-
-          // convert math op from f64 to i32
-          wasm[i - 1][0] = f64ToI32Op[wasm[i - 1][0]];
-
-          // remove this now unneeded f64 -> i32 convert
-          wasm.splice(i, 1);
-        }
-      }
-    }
+    // if (i >= 2 &&
+    //   ((opcode >= 0xa0 && opcode <= 0xa3) || // main f64 math op
+    //   (opcode >= 0x61 && opcode <= 0x66)) // main f64 eq op
+    // ) {
+    //   const o2 = wasm[i - 1][0];
+    //   if (o2 === Opcodes.f64_const) { // f64.const
+    //     const o3 = wasm[i - 2][0];
+    //     if (o3 === Opcodes.f64_convert_i32_s || o3 === Opcodes.f64_convert_i32_u) {
+    //       // remove now unneeded i32 -> f64 convert
+    //       wasm.splice(i - 2, 1);
+    //       i--;
+
+    //       // convert f64.const -> i32.const
+    //       const n = wasm[i - 1][1];
+    //       wasm.splice(i - 1, 1, number(n, Valtype.i32));
+
+    //       // convert math op from f64 to i32
+    //       wasm[i][0] = f64ToI32Op[wasm[i][0]];
+
+    //       const nextOp = wasm[i + 1];
+    //       if (nextOp && opcode >= 0xa0 && opcode <= 0xa3) {
+    //         if (nextOp[0] === 0xfc && (nextOp[1] === 0x02 || nextOp[1] === 0x03)) {
+    //           // remove optional unneeded f64 -> i32 convert after
+    //           wasm.splice(i + 1, 1);
+    //         } else {
+    //           // add now needed i32 -> f64 convert after
+    //           wasm.splice(i + 1, Opcodes.i32_trunc_sat_f64_s);
+    //         }
+    //       }
+    //     }
+    //   }
+    // }
+
+    // if ((opcode === 0xfc02 || opcode === 0xfc03) && i >= 3) { // i32.trunc_sat_f64_s/u
+    //   const o2 = wasm[i - 1][0];
+    //   if (
+    //     (o2 >= 0xa0 && o2 <= 0xa3) || // main f64 math op
+    //     (o2 >= 0x61 && o2 <= 0x66) // main f64 eq op
+    //   ) {
+    //     const o3 = wasm[i - 2][0];
+    //     if (o3 === Opcodes.f64_const) { // f64.const
+    //       const o4 = wasm[i - 3][0];
+    //       if (o4 === Opcodes.f64_convert_i32_s || o4 === Opcodes.f64_convert_i32_u) {
+    //         // remove now unneeded i32 -> f64 convert
+    //         wasm.splice(i - 3, 1);
+    //         i--;
+    //       } else {
+    //         // add now needed f64 -> i32 convert prior
+    //         wasm.splice(i - 2, 0, Opcodes.i32_trunc_sat_f64_s);
+    //         i++;
+    //       }
+
+    //       // convert f64.const -> i32.const
+    //       const n = wasm[i - 2][1];
+    //       wasm.splice(i - 2, 1, number(n, Valtype.i32));
+
+    //       // convert math op from f64 to i32
+    //       wasm[i - 1][0] = f64ToI32Op[wasm[i - 1][0]];
+
+    //       // remove this now unneeded f64 -> i32 convert
+    //       wasm.splice(i, 1);
+    //     }
+    //   }
+    // }
   }
 };

package/compiler/disassemble.js

@@ -18,7 +18,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
     }
 
     return `(${params.map((x, i) => invValtype[x]).join(', ')}) -> (${returns.map(x => invValtype[x]).join(', ')})`;
-  }
+  };
 
   let out = '', depth = 0;
   if (name) out += `${name}(${ind}) ${makeSignature(params, returns, locals)}\n`;

package/compiler/index.js

@@ -132,9 +132,9 @@ export default (code, module = undefined) => {
 
       for (const x of funcs) {
         const preOps = x.wasm.length;
-        cyclone(x.wasm);
+        cyclone(x);
 
-        console.log(`${x.name}: ${preOps} -> ${x.wasm.length} ops`);
+        if (preOps !== x.wasm.length) console.log(`${x.name}: ${preOps} -> ${x.wasm.length} ops`);
       }
       opt(funcs, globals, pages, tags, exceptions);
 
@@ -144,7 +144,7 @@ export default (code, module = undefined) => {
       console.log(`cyclone size diff: ${oldSize - newSize} bytes (${oldSize} -> ${newSize})\n`);
     } else {
       for (const x of funcs) {
-        cyclone(x.wasm);
+        cyclone(x);
       }
     }
   }

package/compiler/types.js

@@ -30,10 +30,7 @@ export const TYPE_NAMES = {
   [TYPES.bigint]: 'BigInt'
 };
 
-export const typeHasFlag = (type, flag) => (type & flag) !== 0;
-
-export const INTERNAL_TYPE_BASE = 0x10;
-let internalTypeIndex = INTERNAL_TYPE_BASE;
+let internalTypeIndex = TYPES.object + 1;
 const registerInternalType = (name, flags = [], overrideType = undefined) => {
   let n = overrideType ?? internalTypeIndex++;
 
@@ -72,12 +69,13 @@ registerInternalType('BooleanObject');
 registerInternalType('NumberObject');
 registerInternalType('StringObject');
 
-for (const x of [ '', 'Aggregate', 'Type', 'Reference', 'Syntax', 'Range', 'Eval', 'URI', 'Test262', 'Todo' ])
-  registerInternalType(`${x}Error`);
-
 registerInternalType('__Porffor_Generator');
 registerInternalType('__Porffor_AsyncGenerator');
 
+// from here, remapped object types only
+for (const x of [ '', 'Aggregate', 'Type', 'Reference', 'Syntax', 'Range', 'Eval', 'URI', 'Test262' ])
+  registerInternalType(`${x}Error`);
+
 if (Prefs.largestTypes) {
   const typeKeys = Object.keys(TYPES);
   const typeVals = Object.values(TYPES);
@@ -88,11 +86,11 @@ if (Prefs.largestTypes) {
     return [ val, key ];
   };
 
-  const unflag = val => val & 0b00111111;
-
   const logType = (label, val, key) => console.log(`${label}    ${key} - ${val} (0x${val.toString(16)}, 0b${val.toString(2).padStart(8, '0')})`);
 
-  logType(`largest type:         `, ...largestType(typeVals.map(unflag), typeKeys));
+  const largestUnflagged = largestType(typeVals.map(x => x & 0b00111111), typeKeys);
+  logType(`largest type:         `, ...largestUnflagged);
   logType(`largest type w/ flags:`, ...largestType(typeVals, typeKeys));
+  console.log('types left:', 0b00111111 - largestUnflagged[0]);
   console.log();
 }

package/compiler/wrap.js

@@ -311,8 +311,7 @@ ${flags & 0b0001 ? `    get func idx: ${get}
     case TYPES.rangeerror:
     case TYPES.evalerror:
     case TYPES.urierror:
-    case TYPES.test262error:
-    case TYPES.todoerror: {
+    case TYPES.test262error: {
       const obj = porfToJSValue({ memory, funcs, pages }, value, TYPES.object);
       const err = new (globalThis[TYPE_NAMES[type]] ?? Error)(obj.message);
 

package/package.json

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