Option to truncate integers to 64 bits, part 1 (core VM changes)

runtime/lib/double.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/bootstrap_natives.h"
 
 #include "platform/math.h"
 
 #include "vm/dart_entry.h"
 #include "vm/double_conversion.h"
@@ skipping 61 matching lines @@
   return Double::New(left / right);
 }
 
 
 static RawInteger* DoubleToInteger(double val, const char* error_msg) {
   if (isinf(val) || isnan(val)) {
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, String::Handle(String::New(error_msg)));
     Exceptions::ThrowByType(Exceptions::kUnsupported, args);
   }
+  if (FLAG_truncate_ints_to_64_bits) {
+    // TODO(alexmarkov): decide on the double-to-integer conversion semantics
+    // in truncating mode.
+    int64_t ival = 0;
+    if (val <= static_cast<double>(kMinInt64)) {
+      ival = kMinInt64;
+    } else if (val >= static_cast<double>(kMaxInt64)) {
+      ival = kMaxInt64;
+    } else {  // Representable in int64_t.
+      ival = static_cast<int64_t>(val);
+    }
+    return Integer::New(ival);
+  }
   if ((-1.0 < val) && (val < 1.0)) {
     return Smi::New(0);
   }
   DoubleInternals internals = DoubleInternals(val);
   ASSERT(!internals.IsSpecial());  // Only Infinity and NaN are special.
   uint64_t significand = internals.Significand();
   intptr_t exponent = internals.Exponent();
   if (exponent <= 0) {
     significand >>= -exponent;
     exponent = 0;
   } else if (exponent <= 10) {
     // A double significand has at most 53 bits. The following shift will
     // hence not overflow, and yield an integer of at most 63 bits.
     significand <<= exponent;
     exponent = 0;
   }
   // A significand has at most 63 bits (after the shift above).
   // The cast to int64_t is hence safe.
   int64_t ival = static_cast<int64_t>(significand);
   if (internals.Sign() < 0) {
     ival = -ival;
   }
   if (exponent == 0) {
     // The double fits in a Smi or Mint.
     return Integer::New(ival);
   }

[siva, 2017/07/07 23:11:20]

Why not add your new code here
if (Flag_...) {
  if (val <= static_cast<double>(kMinInt64)) {
    ival = kMinInt64;
  } else {
    ASSERT(ival >= static_cast<double>(kMaxInt64));
    ival = kMaxInt64;
  }
  return Integer::New(ival);
}

[alexmarkov, 2017/07/10 16:58:12]

Although the code up to this points works fine in truncating mode, it is
unnecessary to look into double internals in truncating mode - generic code
"static_cast<int64_t>(val)" covers it just fine.

   Integer& result = Integer::Handle();
   result = Bigint::NewFromShiftedInt64(ival, exponent);
   return result.AsValidInteger();
 }
 
 
 DEFINE_NATIVE_ENTRY(Double_trunc_div, 2) {
   double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value();
   GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
   double right = right_object.value();
@@ skipping 191 matching lines @@
 DEFINE_NATIVE_ENTRY(Double_flipSignBit, 1) {
   const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0));
   const double in_val = arg.value();
   const int64_t bits = bit_cast<int64_t, double>(in_val) ^ kSignBitDouble;
   return Double::New(bit_cast<double, int64_t>(bits));
 }
 
 // Add here only functions using/referring to old-style casts.
 
 }  // namespace dart