[conversions] Make "DoubleToUint32IfEqualToSelf" use bit magic

src/conversions-inl.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_CONVERSIONS_INL_H_
 #define V8_CONVERSIONS_INL_H_
 
 #include <float.h>         // Required for DBL_MAX and on Win32 for finite()
 #include <limits.h>        // Required for INT_MAX etc.
 #include <stdarg.h>
@@ skipping 39 matching lines @@
   bool negative = x < 0;
   if (negative) {
     x = -x;
   }
   if (x < k2Pow52) {
     x += k2Pow52;
     uint32_t result;
 #ifndef V8_TARGET_BIG_ENDIAN
     Address mantissa_ptr = reinterpret_cast<Address>(&x);
 #else
-    Address mantissa_ptr = reinterpret_cast<Address>(&x) + kIntSize;
+    Address mantissa_ptr = reinterpret_cast<Address>(&x) + kInt32Size;
 #endif
     // Copy least significant 32 bits of mantissa.
     memcpy(&result, mantissa_ptr, sizeof(result));
     return negative ? ~result + 1 : result;
   }
   // Large number (outside uint32 range), Infinity or NaN.
   return 0x80000000u;  // Return integer indefinite.
 }
 
 
@@ skipping 45 matching lines @@
          value == FastI2D(FastD2I(value));
 }
 
 
 bool IsUint32Double(double value) {
   return !IsMinusZero(value) && value >= 0 && value <= kMaxUInt32 &&
          value == FastUI2D(FastD2UI(value));
 }
 
 bool DoubleToUint32IfEqualToSelf(double value, uint32_t* uint32_value) {
-  if (value < 0) return false;
-  // TODO(leszeks): We maybe could be faster than FastD2UI here, since we only
-  // care about the value being valid if the conversion is valid.
-  uint32_t converted_value = FastD2UI(value);
-  if (FastUI2D(converted_value) == value) {
-    *uint32_value = converted_value;
-    return true;
+  const double k2Pow52 = 4503599627370496.0;
+  const uint32_t kValidTopBits = 0x43300000;
+  const uint64_t kBottomBitMask = V8_2PART_UINT64_C(0x00000000, FFFFFFFF);
+
+  // Add 2^52 to the double, to place valid uint32 values in the low-significant
+  // bits of the exponent, by effectively setting the (implicit) top bit of the
+  // significand. Note that this addition also normalises 0.0 and -0.0.
+  double shifted_value = value + k2Pow52;
+
+  // At this point, a valid uint32 valued double will be represented as:
+  //
+  // sign = 0
+  // exponent = 52
+  // significand = 1. 00...00 <value>
+  //       implicit^          ^^^^^^^ 32 bits
+  //                  ^^^^^^^^^^^^^^^ 52 bits
+  //
+  // Therefore, we can first check the top 32 bits to make sure that the sign,
+  // exponent and remaining significand bits are valid, and only then check the
+  // value in the bottom 32 bits.
+
+  uint64_t result = bit_cast<uint64_t>(shifted_value);
+  if ((result >> 32) == kValidTopBits) {
+    *uint32_value = result & kBottomBitMask;
+    return (result & kBottomBitMask) == value;

[rmcilroy, 2017/01/17 15:46:07]

nit - please do:

return FastUI2D(*uint32_value) == value

[Leszek Swirski, 2017/01/17 16:06:45]

Changed to FastUI2D, but still using "result & kBottomBitMask" because fast
(reliably 5-7% faster on microbenchmarks).

   }
   return false;
 }
 
 int32_t NumberToInt32(Object* number) {
   if (number->IsSmi()) return Smi::cast(number)->value();
   return DoubleToInt32(number->Number());
 }
 
 uint32_t NumberToUint32(Object* number) {
@@ skipping 652 matching lines @@
   buffer[buffer_pos] = '\0';
 
   double converted = Strtod(Vector<const char>(buffer, buffer_pos), exponent);
   return (sign == NEGATIVE) ? -converted : converted;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CONVERSIONS_INL_H_