porffor 0.55.13 → 0.55.15

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/math.ts

@@ -137,6 +137,11 @@ export const __Math_pow = (base: number, exponent: number): number => {
   // 2. If exponent is either +0𝔽 or -0𝔽, return 1𝔽.
   if (exponent == 0) return 1;
 
+  // opt: use bit shift for base 2
+  if (base == 2) {
+    if (Porffor.fastAnd(Number.isInteger(exponent), exponent > 0, exponent < 31)) return 2 << (exponent - 1);
+  }
+
   if (!Number.isFinite(base)) {
     // 3. If base is NaN, return NaN.
     if (Number.isNaN(base)) return base;
@@ -259,7 +264,7 @@ export const __Math_expm1 = (x: number): number => {
     return x;
   }
 
-  // use exp(x) - 1 for large x (perf)
+  // opt: use exp(x) - 1 for large x
   if (Math.abs(x) > 1e-5) return Math.exp(x) - 1;
 
   // Taylor series
@@ -280,7 +285,7 @@ export const __Math_log1p = (x: number): number => {
   if (x == -1) return -Infinity; // log(0) = -inf
   if (!Number.isFinite(x)) return x;
 
-  // use exp(x) - 1 for large x (perf)
+  // opt: use exp(x) - 1 for large x
   if (Math.abs(x) > 1e-5) return Math.log(1 + x);
 
   // Taylor series
@@ -454,4 +459,83 @@ export const __Math_atan2 = (y: number, x: number): number => {
 
   if (y >= 0) return Math.atan(ratio) + Math.PI;
   return Math.atan(ratio) - Math.PI;
+};
+
+export const __Math_sumPrecise = (values: any[]): number => {
+  // based on "Fast exact summation using small and large superaccumulators" by Radford M. Neal
+  // https://arxiv.org/abs/1505.05571
+  // accuracy is top priority, it is fine for this to be slow(er)
+
+  // small superaccumulator uses 67 chunks: (1 << (11 - 5)) + 3
+  //   11 is the number of exponent bits in IEEE-754 double precision
+  //   5 is the number of low-order exponent bits stored per chunk
+  const SMALL_SLOTS: number = 67;
+  const SMALL_MIN: number = -970;
+  const small: Float64Array = new Float64Array(SMALL_SLOTS);
+
+  // large superaccumulator uses 4096 chunks: 1 << (11 + 1)
+  //   11 is the number of exponent bits in IEEE-754 double precision
+  const LARGE_SLOTS: number = 4096;
+  const LARGE_MIN: number = -1074;
+  const large: Float64Array = new Float64Array(LARGE_SLOTS);
+
+  for (const _ of values) {
+    if (Porffor.rawType(_) != Porffor.TYPES.number) throw new TypeError('Math.sumPrecise must have only numbers in values');
+
+    const v: number = _;
+    if (v == 0) continue;
+
+    const exp: number = Porffor.number.getExponent(v);
+
+    // check if value fits in small superaccumulator
+    if (exp >= SMALL_MIN && exp < SMALL_MIN + SMALL_SLOTS) {
+      // map the exponent to an array index (-970 -> 0, -969 -> 1, etc)
+      const slot: number = exp - SMALL_MIN;
+      let y: number = v;
+
+      // cascade up through slots, similar to carrying digits in decimal
+      // but operating in binary and handling floating point carefully
+      for (let i: number = slot; i < SMALL_SLOTS - 1; i++) {
+        const sum: number = small[i] + y;
+        y = sum;
+
+        // a number fits in slot i if its magnitude is less than 2^(i+SMALL_MIN+1)
+        const slotLimit: number = Math.pow(2, i + SMALL_MIN + 1);
+        if (y >= -slotLimit && y < slotLimit) {
+          small[i] = y;
+          y = 0;
+          break;
+        }
+
+        // doesn't fit, clear this slot and continue cascading
+        small[i] = 0;
+      }
+
+      // if we still have a non-zero value after cascading through small,
+      // it needs to go into the large superaccumulator
+      if (y != 0) {
+        large[Porffor.number.getExponent(y) - LARGE_MIN] += y;
+      }
+    } else {
+      // exponent is outside small superaccumulator range,
+      // put it directly in the large superaccumulator
+      large[Porffor.number.getExponent(v) - LARGE_MIN] += v;
+    }
+  }
+
+  // combine results from both superaccumulators,
+  // process from highest to lowest to maintain precision
+  // todo: handle -0 (see test262 test)
+  let sum: number = -0;
+  for (let i: number = LARGE_SLOTS - 1; i >= 0; i--) {
+    sum += large[i];
+  }
+
+  for (let i: number = SMALL_SLOTS - 1; i >= 0; i--) {
+    sum += small[i];
+  }
+
+  // todo: free large and small
+
+  return sum;
 };

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/porffor.d.ts

@@ -89,6 +89,10 @@ type PorfforGlobal = {
     appendPadNum(str: bytestring, num: number, len: number): i32;
   }
 
+  number: {
+    getExponent(v: f64): i32;
+  }
+
   print(x: any): i32;
 
   randomByte(): i32;

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 ],
@@ -1025,5 +957,24 @@ export const BuiltinFuncs = function() {
     table: true
   };
 
+  this.__Porffor_number_getExponent = {
+    params: [ Valtype.f64 ],
+    returns: [ Valtype.i32 ],
+    returnType: TYPES.number,
+    wasm: [
+      // extract exponent bits from f64 with bit manipulation
+      [ Opcodes.local_get, 0 ],
+      [ Opcodes.i64_reinterpret_f64 ],
+      number(52, Valtype.i64),
+      [ Opcodes.i64_shr_u ],
+      number(0x7FF, Valtype.i64),
+      [ Opcodes.i64_and ],
+      [ Opcodes.i32_wrap_i64 ],
+      number(1023, Valtype.i32),
+      [ Opcodes.i32_sub ]
+    ]
+  };
+
+
   PrecompiledBuiltins.BuiltinFuncs.call(this);
 };

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 + '_';