porffor 0.55.14 → 0.55.16

package/README.md

@@ -108,7 +108,6 @@ Porffor can run Test262 via some hacks/transforms which remove unsupported featu
   - `codegen.js`: code (wasm) generation, ast -> wasm. The bulk of the effort
   - `cyclone.js`: wasm partial constant evaluator (it is fast and dangerous hence "cyclone")
   - `disassemble.js`: wasm disassembler using internal debug info
-  - `embedding.js`: utils for embedding consts
   - `encoding.js`: utils for encoding things as bytes as wasm expects
   - `expression.js`: mapping most operators to an opcode (advanced are as built-ins eg `f64_%`)
   - `havoc.js`: wasm rewrite library (it wreaks havoc upon wasm bytecode hence "havoc")

package/compiler/builtins/_internal_object.ts

@@ -135,11 +135,16 @@ export const __Porffor_object_lookup = (obj: any, target: any): i32 => {
   const size: i32 = Porffor.wasm.i32.load(obj, 0, 0);
   const endPtr: i32 = ptr + size * 14;
 
+  let out: boolean = false;
   if (targetType == Porffor.TYPES.symbol) {
     const targetSym: symbol = target;
     for (; ptr < endPtr; ptr += 14) {
       const keyRaw: i32 = Porffor.wasm.i32.load(ptr, 0, 0);
-      if (keyRaw == 0) break; // ran out of keys
+      if (keyRaw == 0) {
+        if (out) break; // ran out of keys
+        out = true;
+      }
+
       if (keyRaw >>> 30 == 3) { // MSB 1 and 2 set, symbol
         const keySym: symbol = keyRaw & 0x3FFFFFFF; // unset MSB
         if (keySym == targetSym) return ptr;
@@ -148,7 +153,10 @@ export const __Porffor_object_lookup = (obj: any, target: any): i32 => {
   } else {
     for (; ptr < endPtr; ptr += 14) {
       const keyRaw: i32 = Porffor.wasm.i32.load(ptr, 0, 0);
-      if (keyRaw == 0) break; // ran out of keys
+      if (keyRaw == 0) {
+        if (out) break; // ran out of keys
+        out = true;
+      }
 
       const msb: i32 = keyRaw >>> 30;
       if (msb == 0) {

package/compiler/builtins/bigint.ts

@@ -0,0 +1,233 @@
+import type {} from './porffor.d.ts';
+
+// digits is an array of u32s as digits in base 2^32
+export const __Porffor_bigint_fromDigits = (negative: boolean, digits: i32[]): bigint => {
+  const len: i32 = digits.length;
+  if (len > 16383) throw new RangeError('Maximum BigInt size exceeded'); // (65536 - 4) / 4
+
+  // const ptr: i32 = Porffor.allocate();
+  const 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);
+
+  for (let i: i32 = 0; i < len; i++) {
+    Porffor.wasm.i32.store(ptr + i * 4, digits[i], 0, 4);
+  }
+
+  const out: bigint = ptr;
+  return out;
+};
+
+export const __Porffor_bigint_fromNumber = (n: number): bigint => {
+  if (!Number.isInteger(n) || !Number.isFinite(n)) throw new RangeError('Cannot convert non-integer to BigInt');
+
+  const negative: boolean = n < 0;
+  n = Math.abs(n);
+
+  const digits: i32[] = Porffor.allocate();
+  while (n > 0) {
+    digits.unshift(n % 0x100000000);
+    n = Math.trunc(n / 0x100000000);
+  }
+
+  return __Porffor_bigint_fromDigits(negative, digits);
+};
+
+export const __Porffor_bigint_toNumber = (ptr: i32): number => {
+  const negative: boolean = Porffor.wasm.i32.load8_u(ptr, 0, 0) != 0;
+  const len: i32 = Porffor.wasm.i32.load16_u(ptr, 0, 2);
+
+  let out: number = 0;
+  for (let i: i32 = 0; i < len; i++) {
+    const d: i32 = Porffor.wasm.i32.load(ptr + i * 4, 0, 4);
+    out = out * 0x100000000 + d;
+  }
+
+  if (negative) out = -out;
+  return out;
+};
+
+export const __Porffor_bigint_fromString = (n: string|bytestring): bigint => {
+  const len: i32 = n.length;
+
+  let negative: boolean = false;
+  let end: i32 = 0;
+  if (n[0] === '-') {
+    negative = true;
+    end = 1;
+  } else if (n[0] === '+') {
+    end = 1;
+  }
+
+  // n -> digits (base 2^32) (most to least significant)
+  // 4294967294 -> [ 4294967294 ]
+  // 4294967295 -> [ 4294967295 ]
+  // 4294967296 -> [ 1, 0 ]
+  // 4294967297 -> [ 1, 1 ]
+  // 4294967298 -> [ 1, 2 ]
+  // 9007199254740992 -> [ 2097152 ]
+  // 9007199254740993 -> [ 2097152, 1 ]
+  // 9007199254740994 -> [ 2097152, 2 ]
+  // 9007199254740995 -> [ 2097152, 3 ]
+
+  const digits: i32[] = Porffor.allocate();
+
+  const base = 0x100000000; // 2^32
+
+  for (let i: i32 = end; i < len; i++) {
+    const char: i32 = n.charCodeAt(i);
+    const digit: i32 = char - 48;
+    if (digit < 0 || digit > 9) throw new SyntaxError('Invalid characters in BigInt string');
+
+    // Multiply current digits by 10 and add the new digit
+    let carry: i32 = digit;
+    for (let j: i32 = 0; j < digits.length; j++) {
+      const value: i32 = digits[j] * 10 + carry;
+      digits[j] = value % base;
+      carry = Math.trunc(value / base);
+    }
+
+    // If there's a carry left, push it as a new digit
+    if (carry > 0) {
+      digits.push(carry);
+    }
+  }
+
+  return __Porffor_bigint_fromDigits(negative, digits);
+};
+
+export const __Porffor_bigint_toString = (ptr: i32, radix: number): string => {
+  // todo
+  // return '';
+};
+
+export const __Porffor_bigint_add = (a: i32, b: i32, sub: boolean): bigint => {
+  const aNegative: boolean = Porffor.wasm.i32.load8_u(a, 0, 0) != 0;
+  const aLen: i32 = Porffor.wasm.i32.load16_u(a, 0, 2);
+
+  let bNegative: boolean = Porffor.wasm.i32.load8_u(b, 0, 0) != 0;
+  if (sub) bNegative = !bNegative;
+  const bLen: i32 = Porffor.wasm.i32.load16_u(b, 0, 2);
+
+  const maxLen: i32 = Math.max(aLen, bLen);
+  const digits: i32[] = Porffor.allocate();
+
+  // fast path: same sign
+  let negative: boolean = false;
+  let carry: i32 = 0;
+  if (aNegative == bNegative) {
+    negative = aNegative;
+
+    for (let i: i32 = 0; i < maxLen; i++) {
+      let aDigit: i32 = 0;
+      const aOffset: i32 = aLen - i;
+      if (aOffset > 0) aDigit = Porffor.wasm.i32.load(a + aOffset * 4, 0, 0);
+
+      let bDigit: i32 = 0;
+      const bOffset: i32 = bLen - i;
+      if (bOffset > 0) bDigit = Porffor.wasm.i32.load(b + bOffset * 4, 0, 0);
+
+      let sum: i32 = aDigit + bDigit + carry;
+      if (sum >= 0x100000000) {
+        sum -= 0x100000000;
+        carry = 1;
+      } else if (sum < 0) {
+        sum += 0x100000000;
+        carry = 1;
+      } else {
+        carry = 0;
+      }
+
+      digits.unshift(sum);
+    }
+  } else {
+    let aLarger: i32 = 0;
+    for (let i: i32 = 0; i < maxLen; i++) {
+      let aDigit: i32 = 0;
+      const aOffset: i32 = aLen - i;
+      if (aOffset > 0) aDigit = Porffor.wasm.i32.load(a + aOffset * 4, 0, 0);
+
+      let bDigit: i32 = 0;
+      const bOffset: i32 = bLen - i;
+      if (bOffset > 0) bDigit = Porffor.wasm.i32.load(b + bOffset * 4, 0, 0);
+
+      let sum: i32 = carry;
+      if (aNegative) sum -= aDigit;
+        else sum += aDigit;
+      if (bNegative) sum -= bDigit;
+        else sum += bDigit;
+
+      if (aDigit != bDigit) aLarger = aDigit > bDigit ? 1 : -1;
+
+      if (sum >= 0x100000000) {
+        sum -= 0x100000000;
+        carry = 1;
+      } else if (sum < 0) {
+        sum += 0x100000000;
+        carry = -1;
+      } else {
+        carry = 0;
+      }
+
+      digits.unshift(sum);
+    }
+
+    if (aLarger == 1) negative = aNegative;
+      else if (aLarger == -1) negative = bNegative;
+  }
+
+  if (carry != 0) {
+    digits.unshift(Math.abs(carry));
+    if (carry < 0) negative = !negative;
+  }
+
+  return __Porffor_bigint_fromDigits(negative, digits);
+};
+
+export const __Porffor_bigint_sub = (a: i32, b: i32): bigint => {
+  return __Porffor_bigint_add(a, b, true);
+};
+
+export const __Porffor_bigint_mul = (a: i32, b: i32): bigint => {
+  // todo
+  // return 0n;
+};
+
+export const __Porffor_bigint_div = (a: i32, b: i32): bigint => {
+  // todo
+  // return 0n;
+};
+
+export const __Porffor_bigint_rem = (a: i32, b: i32): bigint => {
+  // todo
+  // return 0n;
+};
+
+export const __Porffor_bigint_eq = (a: i32, b: i32): boolean => {
+  // todo
+  // return false;
+};
+
+export const __Porffor_bigint_ne = (a: i32, b: i32): boolean => {
+  return !__Porffor_bigint_eq(a, b);
+};
+
+export const __Porffor_bigint_gt = (a: i32, b: i32): boolean => {
+  // todo
+  // return false;
+};
+
+export const __Porffor_bigint_ge = (a: i32, b: i32): boolean => {
+  // todo
+  // return false;
+};
+
+export const __Porffor_bigint_lt = (a: i32, b: i32): boolean => {
+  return !__Porffor_bigint_ge(a, b);
+};
+
+export const __Porffor_bigint_le = (a: i32, b: i32): boolean => {
+  return !__Porffor_bigint_gt(a, b);
+};
+

package/compiler/builtins/number.ts

@@ -559,6 +559,8 @@ export const parseInt = (input: any, radix: any): f64 => {
 
   let defaultRadix: boolean = false;
   radix = ecma262.ToIntegerOrInfinity(radix);
+  if (!Number.isFinite(radix)) radix = 0; // infinity/NaN -> default
+
   if (radix == 0) {
     defaultRadix = true;
     radix = 10;

package/compiler/builtins.js

@@ -1,10 +1,9 @@
 import * as PrecompiledBuiltins from './builtins_precompiled.js';
 import ObjectBuiltins from './builtins_objects.js';
 import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
-import { number } from './embedding.js';
 import { TYPES, TYPE_NAMES } from './types.js';
+import { number, unsignedLEB128 } from './encoding.js';
 import './prefs.js';
-import { unsignedLEB128 } from './encoding.js';
 
 export const importedFuncs = [
   {
@@ -230,90 +229,26 @@ export const BuiltinFuncs = function() {
   };
 
 
-  this.__Math_sqrt = {
-    floatOnly: true,
-    params: [ valtypeBinary ],
-    locals: [],
-    returns: [ valtypeBinary ],
-    returnType: TYPES.number,
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.f64_sqrt ]
-    ]
-  };
-
-  this.__Math_abs = {
-    floatOnly: true,
-    params: [ valtypeBinary ],
-    locals: [],
-    returns: [ valtypeBinary ],
-    returnType: TYPES.number,
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.f64_abs ]
-    ]
-  };
-
-  this.__Math_sign = {
-    floatOnly: true,
-    params: [ valtypeBinary ],
-    locals: [],
-    returns: [ valtypeBinary ],
-    returnType: TYPES.number,
-    wasm: [
-      number(1),
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.f64_copysign ]
-    ]
-  };
-
-  this.__Math_floor = {
-    floatOnly: true,
-    params: [ valtypeBinary ],
-    locals: [],
-    returns: [ valtypeBinary ],
-    returnType: TYPES.number,
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.f64_floor ]
-    ]
-  };
-
-  this.__Math_ceil = {
-    floatOnly: true,
-    params: [ valtypeBinary ],
-    locals: [],
-    returns: [ valtypeBinary ],
-    returnType: TYPES.number,
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.f64_ceil ]
-    ]
-  };
-
-  this.__Math_round = {
-    floatOnly: true,
-    params: [ valtypeBinary ],
-    locals: [],
-    returns: [ valtypeBinary ],
-    returnType: TYPES.number,
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.f64_nearest ]
-    ]
-  };
-
-  this.__Math_trunc = {
-    floatOnly: true,
-    params: [ valtypeBinary ],
-    locals: [],
-    returns: [ valtypeBinary ],
-    returnType: TYPES.number,
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.f64_trunc ]
-    ]
-  };
+  for (const [ name, op, prefix = [ [ Opcodes.local_get, 0 ] ] ] of [
+    [ 'sqrt', Opcodes.f64_sqrt ],
+    [ 'abs', Opcodes.f64_abs ],
+    [ 'sign', Opcodes.f64_copysign, [ number(1), [ Opcodes.local_get, 0 ] ] ],
+    [ 'floor', Opcodes.f64_floor ],
+    [ 'ceil', Opcodes.f64_ceil ],
+    [ 'round', Opcodes.f64_nearest ],
+    [ 'trunc', Opcodes.f64_trunc ]
+  ]) {
+    this[`__Math_${name}`] = {
+      params: [ Valtype.f64 ],
+      locals: [],
+      returns: [ Valtype.f64 ],
+      returnType: TYPES.number,
+      wasm: [
+        ...prefix,
+        [ op ]
+      ]
+    };
+  }
 
   // todo: does not follow spec with +-Infinity and values >2**32
   this.__Math_clz32 = {
@@ -359,10 +294,7 @@ export const BuiltinFuncs = function() {
     ]
   };
 
-  // this is an implementation of xorshift128+ (in wasm bytecode)
-  // fun fact: v8, SM, JSC also use this (you will need this fun fact to maintain your sanity reading this code)
   const prngSeed0 = (Math.random() * (2 ** 30)) | 0, prngSeed1 = (Math.random() * (2 ** 30)) | 0;
-
   const prng = ({
     'lcg32': {
       globals: [ Valtype.i32 ],

package/compiler/builtins_objects.js

@@ -1,6 +1,6 @@
 import { Blocktype, Opcodes, PageSize, Valtype } from './wasmSpec.js';
 import { TYPES } from './types.js';
-import { number } from './embedding.js';
+import { number } from './encoding.js';
 
 export default function({ builtinFuncs }, Prefs) {
   const makePrefix = name => (name.startsWith('__') ? '' : '__') + name + '_';