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

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 18980 matching lines @@
 
 RawInteger* Integer::New(const String& str, Heap::Space space) {
   // We are not supposed to have integers represented as two byte strings.
   ASSERT(str.IsOneByteString());
   int64_t value;
   if (!OS::StringToInt64(str.ToCString(), &value)) {
     const Bigint& big =
         Bigint::Handle(Bigint::NewFromCString(str.ToCString(), space));
     ASSERT(!big.FitsIntoSmi());
     ASSERT(!big.FitsIntoInt64());
-    return big.raw();
+    if (!FLAG_truncate_ints_to_64_bits) {
+      return big.raw();
+    }
+    // TODO(alexmarkov): Throw error in FLAG_truncate_ints_to_64_bits mode.

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

You have this comment here and below of throwing an error, is this because of
potential used of these methods from the parser?

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

Yes.

+    value = big.AsTruncatedInt64Value();
   }
   return Integer::New(value, space);
 }
 
 
 RawInteger* Integer::NewCanonical(const String& str) {
   // We are not supposed to have integers represented as two byte strings.
   ASSERT(str.IsOneByteString());
   int64_t value;
   if (!OS::StringToInt64(str.ToCString(), &value)) {
     const Bigint& big = Bigint::Handle(Bigint::NewCanonical(str));
     ASSERT(!big.FitsIntoSmi());
     ASSERT(!big.FitsIntoInt64());
-    return big.raw();
+    if (!FLAG_truncate_ints_to_64_bits) {
+      return big.raw();
+    }
+    // TODO(alexmarkov): Throw error in FLAG_truncate_ints_to_64_bits mode.
+    value = big.AsTruncatedInt64Value();
   }
   if (Smi::IsValid(value)) {
     return Smi::New(static_cast<intptr_t>(value));
   }
   return Mint::NewCanonical(value);
 }
 
 
 RawInteger* Integer::New(int64_t value, Heap::Space space) {
   const bool is_smi = Smi::IsValid(value);
   if (is_smi) {
     return Smi::New(static_cast<intptr_t>(value));
   }
   return Mint::New(value, space);
 }
 
 
 RawInteger* Integer::NewFromUint64(uint64_t value, Heap::Space space) {
   if (value > static_cast<uint64_t>(Mint::kMaxValue)) {
-    return Bigint::NewFromUint64(value, space);
+    if (FLAG_truncate_ints_to_64_bits) {
+      // TODO(alexmarkov): Throw error in FLAG_truncate_ints_to_64_bits mode.
+      return Integer::New(static_cast<int64_t>(value), space);
+    } else {
+      return Bigint::NewFromUint64(value, space);
+    }
   } else {
     return Integer::New(value, space);
   }
 }
 
 
 bool Integer::Equals(const Instance& other) const {
   // Integer is an abstract class.
   UNREACHABLE();
   return false;
@@ skipping 88 matching lines @@
         return Integer::New(left_value + right_value, space);
       case Token::kSUB:
         return Integer::New(left_value - right_value, space);
       case Token::kMUL: {
         if (Smi::kBits < 32) {
           // In 32-bit mode, the product of two Smis fits in a 64-bit result.
           return Integer::New(static_cast<int64_t>(left_value) *
                                   static_cast<int64_t>(right_value),
                               space);
         } else {
-          // In 64-bit mode, the product of two signed integers fits in a
-          // 64-bit result if the sum of the highest bits of their absolute
-          // values is smaller than 62.
           ASSERT(sizeof(intptr_t) == sizeof(int64_t));
-          if ((Utils::HighestBit(left_value) + Utils::HighestBit(right_value)) <
-              62) {
-            return Integer::New(left_value * right_value, space);
+          if (FLAG_truncate_ints_to_64_bits) {
+            return Integer::New(
+                Utils::MulWithWrapAround(left_value, right_value), space);
+          } else {
+            // In 64-bit mode, the product of two signed integers fits in a
+            // 64-bit result if the sum of the highest bits of their absolute
+            // values is smaller than 62.
+            if ((Utils::HighestBit(left_value) +
+                 Utils::HighestBit(right_value)) < 62) {
+              return Integer::New(left_value * right_value, space);
+            }
           }
         }
         // Perform a Bigint multiplication below.
         break;
       }
       case Token::kTRUNCDIV:
         return Integer::New(left_value / right_value, space);
       case Token::kMOD: {
         const intptr_t remainder = left_value % right_value;
         if (remainder < 0) {
           if (right_value < 0) {
             return Integer::New(remainder - right_value, space);
           } else {
             return Integer::New(remainder + right_value, space);
           }
         }
         return Integer::New(remainder, space);
       }
       default:
         UNIMPLEMENTED();
     }
   }
   if (!IsBigint() && !other.IsBigint()) {
     const int64_t left_value = AsInt64Value();
     const int64_t right_value = other.AsInt64Value();
     switch (operation) {
       case Token::kADD: {
-        if (!Utils::WillAddOverflow(left_value, right_value)) {
-          return Integer::New(left_value + right_value, space);
+        if (FLAG_truncate_ints_to_64_bits) {
+          return Integer::New(Utils::AddWithWrapAround(left_value, right_value),
+                              space);
+        } else {
+          if (!Utils::WillAddOverflow(left_value, right_value)) {
+            return Integer::New(left_value + right_value, space);
+          }
         }
         break;
       }
       case Token::kSUB: {
-        if (!Utils::WillSubOverflow(left_value, right_value)) {
-          return Integer::New(left_value - right_value, space);
+        if (FLAG_truncate_ints_to_64_bits) {
+          return Integer::New(Utils::SubWithWrapAround(left_value, right_value),
+                              space);
+        } else {
+          if (!Utils::WillSubOverflow(left_value, right_value)) {
+            return Integer::New(left_value - right_value, space);
+          }
         }
         break;
       }
       case Token::kMUL: {
-        if ((Utils::HighestBit(left_value) + Utils::HighestBit(right_value)) <
-            62) {
-          return Integer::New(left_value * right_value, space);
+        if (FLAG_truncate_ints_to_64_bits) {
+          return Integer::New(Utils::MulWithWrapAround(left_value, right_value),
+                              space);
+        } else {
+          if ((Utils::HighestBit(left_value) + Utils::HighestBit(right_value)) <
+              62) {
+            return Integer::New(left_value * right_value, space);
+          }
         }
         break;
       }
       case Token::kTRUNCDIV: {
-        if ((left_value != Mint::kMinValue) || (right_value != -1)) {
+        if ((left_value == Mint::kMinValue) && (right_value == -1)) {
+          // Division special case: overflow in int64_t.
+          if (FLAG_truncate_ints_to_64_bits) {
+            // MIN_VALUE / -1 = (MAX_VALUE + 1), which wraps around to MIN_VALUE
+            return Integer::New(Mint::kMinValue, space);
+          }
+        } else {
           return Integer::New(left_value / right_value, space);
         }
         break;
       }
       case Token::kMOD: {
         const int64_t remainder = left_value % right_value;
         if (remainder < 0) {
           if (right_value < 0) {
             return Integer::New(remainder - right_value, space);
           } else {
             return Integer::New(remainder + right_value, space);
           }
         }
         return Integer::New(remainder, space);
       }
       default:
         UNIMPLEMENTED();
     }
   }
+  ASSERT(!FLAG_truncate_ints_to_64_bits);
   return Integer::null();  // Notify caller that a bigint operation is required.
 }
 
 
 static bool Are64bitOperands(const Integer& op1, const Integer& op2) {
   return !op1.IsBigint() && !op2.IsBigint();
 }
 
 
 RawInteger* Integer::BitOp(Token::Kind kind,
@@ skipping 25 matching lines @@
       case Token::kBIT_AND:
         return Integer::New(a & b, space);
       case Token::kBIT_OR:
         return Integer::New(a | b, space);
       case Token::kBIT_XOR:
         return Integer::New(a ^ b, space);
       default:
         UNIMPLEMENTED();
     }
   }
+  ASSERT(!FLAG_truncate_ints_to_64_bits);
   return Integer::null();  // Notify caller that a bigint operation is required.
 }
 
 
 // TODO(srdjan): Clarify handling of negative right operand in a shift op.
 RawInteger* Smi::ShiftOp(Token::Kind kind,
                          const Smi& other,
                          Heap::Space space) const {
   intptr_t result = 0;
   const intptr_t left_value = Value();
   const intptr_t right_value = other.Value();
   ASSERT(right_value >= 0);
   switch (kind) {
     case Token::kSHL: {
       if ((left_value == 0) || (right_value == 0)) {
         return raw();
       }
       {  // Check for overflow.
         int cnt = Utils::BitLength(left_value);
-        if ((cnt + right_value) > Smi::kBits) {
-          if ((cnt + right_value) > Mint::kBits) {
-            return Bigint::NewFromShiftedInt64(left_value, right_value, space);
+        if (right_value > (Smi::kBits - cnt)) {
+          if (FLAG_truncate_ints_to_64_bits) {
+            return Integer::New(
+                Utils::ShiftLeftWithTruncation(left_value, right_value), space);
           } else {
-            int64_t left_64 = left_value;
-            return Integer::New(left_64 << right_value, space);
+            if (right_value > (Mint::kBits - cnt)) {
+              return Bigint::NewFromShiftedInt64(left_value, right_value,
+                                                 space);
+            } else {
+              int64_t left_64 = left_value;
+              return Integer::New(left_64 << right_value, space);
+            }
           }
         }
       }
       result = left_value << right_value;
       break;
     }
     case Token::kSHR: {
       const intptr_t shift_amount =
           (right_value >= kBitsPerWord) ? (kBitsPerWord - 1) : right_value;
       result = left_value >> shift_amount;
@@ skipping 401 matching lines @@
     ASSERT(!digits_.IsNull());
     set_digits(digits_);
   } else {
     ASSERT(digits() == TypedData::EmptyUint32Array(Thread::Current()));
   }
   return true;
 }
 
 
 RawBigint* Bigint::New(Heap::Space space) {
+  // TODO(alexmarkov): Throw error or assert in --truncate-ints-to-64-bits mode.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate->object_store()->bigint_class() != Class::null());
   Bigint& result = Bigint::Handle(zone);
   {
     RawObject* raw =
         Object::Allocate(Bigint::kClassId, Bigint::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.SetNeg(false);
   result.SetUsed(0);
   result.set_digits(
       TypedData::Handle(zone, TypedData::EmptyUint32Array(thread)));
   return result.raw();
 }
 
 
 RawBigint* Bigint::New(bool neg,
                        intptr_t used,
                        const TypedData& digits,
                        Heap::Space space) {
+  // TODO(alexmarkov): Throw error or assert in --truncate-ints-to-64-bits mode.
   ASSERT((used == 0) ||
          (!digits.IsNull() && (digits.Length() >= (used + (used & 1)))));
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate->object_store()->bigint_class() != Class::null());
   Bigint& result = Bigint::Handle(zone);
   {
     RawObject* raw =
         Object::Allocate(Bigint::kClassId, Bigint::InstanceSize(), space);
@@ skipping 19 matching lines @@
   }
   result.SetNeg(neg);
   result.SetUsed(used);
   return result.raw();
 }
 
 
 RawBigint* Bigint::NewFromInt64(int64_t value, Heap::Space space) {
   // Currently only used to convert Smi or Mint to hex String, therefore do
   // not throw RangeError if --limit-ints-to-64-bits.
+  // TODO(alexmarkov): Throw error or assert in --truncate-ints-to-64-bits mode.
   const TypedData& digits = TypedData::Handle(NewDigits(2, space));
   bool neg;
   uint64_t abs_value;
   if (value < 0) {
     neg = true;
     abs_value = -value;
   } else {
     neg = false;
     abs_value = value;
   }
   SetDigitAt(digits, 0, static_cast<uint32_t>(abs_value));
   SetDigitAt(digits, 1, static_cast<uint32_t>(abs_value >> 32));
   return New(neg, 2, digits, space);
 }
 
 
 RawBigint* Bigint::NewFromUint64(uint64_t value, Heap::Space space) {
+  // TODO(alexmarkov): Throw error or assert in --truncate-ints-to-64-bits mode.
   if (FLAG_limit_ints_to_64_bits) {
     Exceptions::ThrowRangeErrorMsg(
         "Integer operand requires conversion to Bigint");
   }
   const TypedData& digits = TypedData::Handle(NewDigits(2, space));
   SetDigitAt(digits, 0, static_cast<uint32_t>(value));
   SetDigitAt(digits, 1, static_cast<uint32_t>(value >> 32));
   return New(false, 2, digits, space);
 }
 
 
 RawBigint* Bigint::NewFromShiftedInt64(int64_t value,
                                        intptr_t shift,
                                        Heap::Space space) {
+  // TODO(alexmarkov): Throw error or assert in --truncate-ints-to-64-bits mode.
   if (FLAG_limit_ints_to_64_bits) {
     // The allocated Bigint value is not necessarily out of range, but it may
     // be used as an operand in an operation resulting in a Bigint.
     Exceptions::ThrowRangeErrorMsg(
         "Integer operand requires conversion to Bigint");
   }
   ASSERT(kBitsPerDigit == 32);
   ASSERT(shift >= 0);
   const intptr_t digit_shift = shift / kBitsPerDigit;
   const intptr_t bit_shift = shift % kBitsPerDigit;
@@ skipping 17 matching lines @@
              static_cast<uint32_t>(abs_value >> (32 - bit_shift)));
   SetDigitAt(digits, 2 + digit_shift,
              (bit_shift == 0) ? 0 : static_cast<uint32_t>(abs_value >>
                                                           (64 - bit_shift)));
   return New(neg, used, digits, space);
 }
 
 
 RawBigint* Bigint::NewFromCString(const char* str, Heap::Space space) {
   // Allow parser to scan Bigint literal, even with --limit-ints-to-64-bits.
+  // TODO(alexmarkov): Throw error or assert in --truncate-ints-to-64-bits mode.
   ASSERT(str != NULL);
   bool neg = false;
   TypedData& digits = TypedData::Handle();
   if (str[0] == '-') {
     ASSERT(str[1] != '-');
     neg = true;
     str++;
   }
   intptr_t used;
   const intptr_t str_length = strlen(str);
   if ((str_length >= 2) && (str[0] == '0') &&
       ((str[1] == 'x') || (str[1] == 'X'))) {
     digits = NewDigitsFromHexCString(&str[2], &used, space);
   } else {
     digits = NewDigitsFromDecCString(str, &used, space);
   }
   return New(neg, used, digits, space);
 }
 
 
 RawBigint* Bigint::NewCanonical(const String& str) {
   // Allow parser to scan Bigint literal, even with --limit-ints-to-64-bits.
+  // TODO(alexmarkov): Throw error or assert in --truncate-ints-to-64-bits mode.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   const Bigint& value =
       Bigint::Handle(zone, Bigint::NewFromCString(str.ToCString(), Heap::kOld));
   const Class& cls =
       Class::Handle(zone, isolate->object_store()->bigint_class());
   intptr_t index = 0;
   Bigint& canonical_value = Bigint::Handle(zone);
   canonical_value ^= cls.LookupCanonicalBigint(zone, value, &index);
@@ skipping 3766 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart