Option to truncate integers to 64 bits, part 2

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 8099 matching lines @@
                                     LiteralToken::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawLiteralToken*>(raw);
 }
 
 RawLiteralToken* LiteralToken::New(Token::Kind kind, const String& literal) {
   const LiteralToken& result = LiteralToken::Handle(LiteralToken::New());
   result.set_kind(kind);
   result.set_literal(literal);
   if (kind == Token::kINTEGER) {
     const Integer& value = Integer::Handle(Integer::NewCanonical(literal));
+    if (value.IsNull()) {
+      // Integer is out of range.
+      return LiteralToken::null();
+    }
     ASSERT(value.IsSmi() || value.IsOld());
     result.set_value(value);
   } else if (kind == Token::kDOUBLE) {
     const Double& value = Double::Handle(Double::NewCanonical(literal));
     result.set_value(value);
   } else {
     ASSERT(Token::NeedsLiteralToken(kind));
     result.set_value(literal);
   }
   return result.raw();
@@ skipping 361 matching lines @@
     value_ = tokens_->GetOrNull(descriptor, &is_present);
     intptr_t index = -1;
     if (is_present) {
       ASSERT(value_.IsSmi());
       index = Smi::Cast(value_).Value();
     } else {
       const intptr_t fresh_index = token_objects_.Length();
       fresh_index_smi_ = Smi::New(fresh_index);
       const LiteralToken& lit = LiteralToken::Handle(
           LiteralToken::New(descriptor.kind, *descriptor.literal));
+      if (lit.IsNull()) {
+        // Convert token to an error.
+        ASSERT(descriptor.kind == Token::kINTEGER);
+        ASSERT(FLAG_limit_ints_to_64_bits);
+        Scanner::TokenDescriptor errorDesc = descriptor;
+        errorDesc.kind = Token::kERROR;
+        errorDesc.literal = &String::Handle(Symbols::NewFormatted(
+            Thread::Current(), "integer literal %s is out of range",
+            descriptor.literal->ToCString()));
+        AddLiteralToken(errorDesc);
+        return;
+      }
       index = Smi::Value(
           Smi::RawCast(tokens_->InsertOrGetValue(lit, fresh_index_smi_)));
       token_objects_.Add(lit);
       if (kPrintTokenObjects) {
         int iid = Isolate::Current()->main_port() % 1024;
         printf("lit    %03x  %p  %p  %p  <%s>\n", iid, token_objects_.raw(),
                lit.literal(), lit.value(),
                String::Handle(lit.literal()).ToCString());
       }
     }
@@ skipping 9309 matching lines @@
   // Integer is an interface. No instances of Integer should exist except null.
   ASSERT(IsNull());
   return "NULL Integer";
 }
 
 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)) {
+    if (FLAG_limit_ints_to_64_bits) {
+      // Out of range.
+      return Integer::null();
+    }
     const Bigint& big =
         Bigint::Handle(Bigint::NewFromCString(str.ToCString(), space));
     ASSERT(!big.FitsIntoSmi());
     ASSERT(!big.FitsIntoInt64());
-    if (!FLAG_limit_ints_to_64_bits) {
-      return big.raw();
-    }
-    // TODO(alexmarkov): Throw error in FLAG_limit_ints_to_64_bits mode.
-    value = big.AsTruncatedInt64Value();
+    return big.raw();
   }
   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)) {
+    if (FLAG_limit_ints_to_64_bits) {
+      // Out of range.
+      return Integer::null();
+    }
     const Bigint& big = Bigint::Handle(Bigint::NewCanonical(str));
     ASSERT(!big.FitsIntoSmi());
     ASSERT(!big.FitsIntoInt64());
-    if (!FLAG_limit_ints_to_64_bits) {
-      return big.raw();
-    }
-    // TODO(alexmarkov): Throw error in FLAG_limit_ints_to_64_bits mode.
-    value = big.AsTruncatedInt64Value();
+    return big.raw();
   }
   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)) {
     if (FLAG_limit_ints_to_64_bits) {
-      // TODO(alexmarkov): Throw error in FLAG_limit_ints_to_64_bits mode.
-      return Integer::New(static_cast<int64_t>(value), space);
+      // Out of range.
+      return Integer::null();
     } else {
       return Bigint::NewFromUint64(value, space);
     }
   } else {
     return Integer::New(value, space);
   }
 }
 
 bool Integer::Equals(const Instance& other) const {
   // Integer is an abstract class.
@@ skipping 180 matching lines @@
           } else {
             return Integer::New(remainder + right_value, space);
           }
         }
         return Integer::New(remainder, space);
       }
       default:
         UNIMPLEMENTED();
     }
   }
-  ASSERT(!FLAG_limit_ints_to_64_bits);
+  ASSERT(!Bigint::IsDisabled());
   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,
                            const Integer& other,
                            Heap::Space space) const {
@@ skipping 23 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_limit_ints_to_64_bits);
+  ASSERT(!Bigint::IsDisabled());
   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();
@@ skipping 392 matching lines @@
     digits_ ^= digits_.CheckAndCanonicalize(thread, NULL);
     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 --limit-ints-to-64-bits mode.
+  ASSERT(!Bigint::IsDisabled());
   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 --limit-ints-to-64-bits mode.
+  ASSERT(!Bigint::IsDisabled());
   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 16 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) {
-  // 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 --limit-ints-to-64-bits mode.
+  ASSERT(!Bigint::IsDisabled());
   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): Revise this assertion if this factory method is used
-  // to explicitly allocate Bigint objects in --limit-ints-to-64-bits mode.
-  ASSERT(!FLAG_limit_ints_to_64_bits);
+  ASSERT(!Bigint::IsDisabled());
   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): Revise this assertion if this factory method is used
-  // to explicitly allocate Bigint objects in --limit-ints-to-64-bits mode.
-  ASSERT(!FLAG_limit_ints_to_64_bits);
+  ASSERT(!Bigint::IsDisabled());
   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.
-  // TODO(alexmarkov): Throw error or assert in --limit-ints-to-64-bits mode.
+  ASSERT(!Bigint::IsDisabled());
   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 --limit-ints-to-64-bits mode.
+  ASSERT(!Bigint::IsDisabled());
   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 3533 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart