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.

[regis, 2017/07/07 20:10:30]

I think you should throw now or it will be difficult to test this cl.

[alexmarkov, 2017/07/07 20:46:39]

Throwing error will require modifying parser and library (Dart) code as well.
I'd like to decouple those changes from changes in the semantics of arithmetic
operations.

Note that literals which fit into int64 and wrap-around arithmetic work just
fine with this CL - the corresponding test is included into CL.

[regis, 2017/07/07 21:46:53]

OK.

+    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.

[regis, 2017/07/07 20:10:30]

ditto

[alexmarkov, 2017/07/07 20:46:39]

Acknowledged.

+    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.

[regis, 2017/07/07 20:10:30]

ditto

[alexmarkov, 2017/07/07 20:46:39]

Acknowledged.

+      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.

[regis, 2017/07/07 20:10:30]

We will keep these constructors for the future BigInt library. A throw or assert
would only be temporary for your own debugging but should not be inserted here. 

[alexmarkov, 2017/07/07 20:46:39]

Acknowledged.

   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.

[regis, 2017/07/07 20:10:30]

ditto here and for all instances below.

[alexmarkov, 2017/07/07 20:46:39]

Acknowledged.

   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