Fix Win64 build of Dart VM.

runtime/vm/bigint_operations.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 
 #include "vm/bigint_operations.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 
 #include "vm/double_internals.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
@@ skipping 469 matching lines @@
     value <<= kDigitBitSize;
     value += static_cast<intptr_t>(bigint.GetChunkAt(i));
   }
   if (bigint.IsNegative()) {
     value = -value;
   }
   return Smi::New(value);
 }
 
 
+static double Uint64ToDouble(uint64_t x) {
+#if _WIN64

[Ivan Posva, 2014/06/05 17:42:11]

Alternatively we could avoid the ifdef and just do the more involved
instructions always, with the explanation on why we are doing it this way.

[Vyacheslav Egorov (Google), 2014/06/05 18:05:55]

I will ifdef for now because right now all other platform agree on the way of
rounding. If we discover more inconsistencies we can switch. Though instead of
using GCC pattern, I would actually use simpler MSVC one (TBH that's how I would
have generated those conversions myself in the first place).

+  // For static_cast<double>(x) MSVC x64 generates
+  //
+  //    cvtsi2sd xmm0, rax
+  //    test  rax, rax
+  //    jns done
+  //    addsd xmm0, static_cast<double>(2^64)
+  //  done:
+  //
+  // while GCC -m64 generates
+  //
+  //    test rax, rax
+  //    js negative
+  //    cvtsi2sd xmm0, rax
+  //    jmp done
+  //  negative:
+  //    mov rdx, rax
+  //    shr rdx, 1
+  //    and eax, 0x1
+  //    or rdx, rax
+  //    cvtsi2sd xmm0, rdx
+  //    addsd xmm0, xmm0
+  //  done:
+  //
+  // which results in a different rounding.
+  //
+  // For consistency between platforms fallback to GCC style converstion
+  // on Win64.
+  //
+  const int64_t y = static_cast<int64_t>(x);
+  if (y > 0) {
+    return static_cast<double>(y);
+  } else {
+    const double half = static_cast<double>(
+        static_cast<int64_t>(x >> 1) | (y & 1));
+    return half + half;
+  }
+#else
+  return static_cast<double>(x);
+#endif
+}
+
+
 RawDouble* BigintOperations::ToDouble(const Bigint& bigint) {
   ASSERT(IsClamped(bigint));
   if (bigint.IsZero()) {
     return Double::New(0.0);
   }
   if (AbsFitsIntoUint64(bigint)) {
-    double absolute_value = static_cast<double>(AbsToUint64(bigint));
+    double absolute_value = Uint64ToDouble(AbsToUint64(bigint));
     double result = bigint.IsNegative() ? -absolute_value : absolute_value;
     return Double::New(result);
   }
 
   static const int kPhysicalSignificandSize = 52;
   // The significand size has an additional hidden bit.
   static const int kSignificandSize = kPhysicalSignificandSize + 1;
   static const int kExponentBias = 0x3FF + kPhysicalSignificandSize;
   static const int kMaxExponent = 0x7FF - kExponentBias;
   static const uint64_t kOne64 = 1;
@@ skipping 1307 matching lines @@
 intptr_t BigintOperations::CountBits(Chunk digit) {
   intptr_t result = 0;
   while (digit != 0) {
     digit >>= 1;
     result++;
   }
   return result;
 }
 
 }  // namespace dart