Introduce a flag --limit-ints-to-64-bits in the VM in order to investigate the

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 19149 matching lines @@
     neg = false;
     result.set_digits(
         TypedData::Handle(zone, TypedData::EmptyUint32Array(thread)));
   }
   result.SetNeg(neg);
   result.SetUsed(used);
   return result.raw();
 }
 
 
 RawBigint* Bigint::NewFromInt64(int64_t value, Heap::Space space) {

[siva, 2017/02/22 01:48:51]

This function seems to be used only as a convenience for converting smi and mint
values into a Hex C String, should we really throw an exception in this case? We
might end up throwing exceptions in a number of cases where only smi or mint
values are in use.

We have a bunch of unit tests which use it but other than these I don't see any
use for it.

[regis, 2017/02/22 17:30:48]

Done.

+  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");
+  }
   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) {
+  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.

[siva, 2017/02/22 01:48:51]

Why do you say the value is not necessarily out of range? the caller seems to
check that the value is > Mint::kMaxValue

[regis, 2017/02/22 17:30:48]

You are right. I duplicated the same comment without actually checking how this
was called. I removed this comment.

+    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) {
+  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;
   const intptr_t used = 3 + digit_shift;
   const TypedData& digits = TypedData::Handle(NewDigits(used, space));
   bool neg;
   uint64_t abs_value;
   if (value < 0) {
     neg = true;
@@ skipping 10 matching lines @@
   SetDigitAt(digits, 1 + digit_shift,
              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.
   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.
   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 3633 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart