Add a helper cast utility to BigInt that saves code size. (#25308)

Author: juj

src/parseTools.mjs

@@ -262,14 +262,32 @@ function makeInlineCalculation(expression, value, tempVar) {
 
 // XXX Make all i64 parts signed
 
+function castToBigInt(x) {
+  // Micro-size-optimization: if x is an integer literal, then we can append
+  // the suffix 'n' instead of casting to BigInt(), to get smaller code size.
+  var n = Number(x);
+  if (Number.isInteger(n) && isFinite(n)) {
+    // NOTE: BigInt(316059037807746200000) != 316059037807746200000n
+    // i.e. constructing numbers with BigInt()s is subject to rounding, if
+    // the input value cannot be exactly represented as a 64-bit double.
+    // Currently the test suite depends on this rounding behavior, so only
+    // apply this literal optimization to safe integers for now.
+    if (Math.abs(n) < Number.MAX_SAFE_INTEGER) {
+      return `${x}n`;
+    }
+  }
+  return `BigInt(${x})`;
+}
+
+
 // Splits a number (an integer in a double, possibly > 32 bits) into an i64
 // value, represented by a low and high i32 pair.
 // Will suffer from rounding and truncation.
 function splitI64(value) {
   if (WASM_BIGINT) {
     // Nothing to do: just make sure it is a BigInt (as it must be of that
     // type, to be sent into wasm).
-    return `BigInt(${value})`;
+    return castToBigInt(value);
   }
 
   // general idea:
@@ -474,7 +492,7 @@ function makeSetValueImpl(ptr, pos, value, type) {
 
   const slab = getHeapForType(type);
   if (slab == 'HEAPU64' || slab == 'HEAP64') {
-    value = `BigInt(${value})`;
+    value = castToBigInt(value);
   }
   return `${slab}[${getHeapOffset(offset, type)}] = ${value}`;
 }
@@ -595,7 +613,7 @@ function getHeapForType(type) {
 
 export function makeReturn64(value) {
   if (WASM_BIGINT) {
-    return `BigInt(${value})`;
+    return castToBigInt(value);
   }
   const pair = splitI64(value);
   // `return (a, b, c)` in JavaScript will execute `a`, and `b` and return the final
@@ -1000,7 +1018,7 @@ function from64Expr(x) {
 // Converts a value to BigInt if building for wasm64, with both 64-bit pointers
 // and 64-bit memory. Used for indices into the memory tables, for example.
 function toIndexType(x) {
-  if (MEMORY64 == 1) return `BigInt(${x})`;
+  if (MEMORY64 == 1) return castToBigInt(x);
   return x;
 }
 
@@ -1010,7 +1028,7 @@ function toIndexType(x) {
 // this conversion before passing them).
 function to64(x) {
   if (!MEMORY64) return x;
-  return `BigInt(${x})`;
+  return castToBigInt(x);
 }
 
 function asyncIf(condition) {

test/other/test_parseTools.js

@@ -91,9 +91,12 @@ addToLibrary({
     {{{ makeSetValue('ptr', '0', 0x12345678AB, 'i64') }}};
     _printI64(ptr);
 
-    // This value doesn't fit into i64.  The current behaviour truncate (i.e.
-    // ignore the upper bits), in the same way that `BigInt64Array[X] = Y` does.
-    // (see splitI16 in parseTools.js)
+    // This value doesn't fit into i64.  The current behaviour is
+    // in unspecified, subject to a double rounding problem. See
+    // note in castToBigInt() in parseTools.mjs.
+    // FIXME: Find a way to improve BigInt-enabled case to avoid
+    // double rounding, and BigInt-disabled case to be at least
+    // less wrong.
     _clearI64(ptr);
     {{{ makeSetValue('ptr', '0', 0x1122334455667788AA, 'i64') }}};
     _printI64(ptr);