[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;
+
+  // 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, it is sufficient to check the top 32 bits to make sure that the
+  // sign, exponent and remaining significand bits are valid, and extract the
+  // bottom 32 bits to get the value.
+
+  uint32_t check;
+#ifndef V8_TARGET_BIG_ENDIAN
+  Address top_ptr = reinterpret_cast<Address>(&shifted_value) + kInt32Size;
+  Address bottom_ptr = reinterpret_cast<Address>(&shifted_value);
+#else
+  Address top_ptr = reinterpret_cast<Address>(&shifted_value);
+  Address bottom_ptr = reinterpret_cast<Address>(&shifted_value) + kInt32Size;
+#endif
+  memcpy(&check, top_ptr, sizeof(uint32_t));

[rmcilroy, 2017/01/16 14:12:11]

Could you just do a reinterpreter_cast on the address and compare directly in
memory rather than a memcpy?

[Leszek Swirski, 2017/01/16 14:26:54]

Good question -- short version, no, because of strict aliasing. Longer
explanation, see the giant comment above bit_cast in macros.h. I could use
bitcast to cast the float to a uint64_t, and check/shift that around, but I
actually profiled this in microbenchmarks and it was slower.

[rmcilroy, 2017/01/16 15:59:51]

Ahh I see, thanks for the explination.
How much slower? I would rather keep all the mempy nastyness in one place and
just use bit_cast here if it wasn't a significant perf difference. Maybe you
could shift the mask / valid constants instead so that constant folding hides
any of the shifting overheads?

[Leszek Swirski, 2017/01/17 12:36:19]

Whoops, it turns out my microbenchmarks were super broken. bit_cast to uint64 is
actually faster, so updated the code to do it.

+  if (check == kValidTopBits) {
+    memcpy(uint32_value, bottom_ptr, sizeof(uint32_t));

[rmcilroy, 2017/01/16 14:12:11]

ditto

[Leszek Swirski, 2017/01/16 14:26:54]

As above.

+    // Make sure we convert back to the right value.
+    return FastUI2D(*uint32_value) == value;
   }
+  DCHECK(DoubleToUint32(value) != value);
   return false;
 }
 
 int32_t NumberToInt32(Object* number) {
   if (number->IsSmi()) return Smi::cast(number)->value();
   return DoubleToInt32(number->Number());
 }
 
 uint32_t NumberToUint32(Object* number) {
   if (number->IsSmi()) return Smi::cast(number)->value();
@@ skipping 651 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_