Resubmit bigint changes of r41817 that were later reverted.

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/cpu.h"
@@ skipping 16390 matching lines @@
   result.EnsureLength(2, space);
   result.SetUsed(2);
   result.SetDigitAt(0, static_cast<uint32_t>(value));
   result.SetDigitAt(1, static_cast<uint32_t>(value >> 32));
   result.Clamp();
   return result.raw();
 }
 
 
 RawBigint* Bigint::NewFromShiftedInt64(int64_t value, intptr_t shift,
-                                         Heap::Space space) {
+                                       Heap::Space space) {
   ASSERT(kBitsPerDigit == 32);
   ASSERT(shift >= 0);
   const Bigint& result = Bigint::Handle(New(space));
   const intptr_t digit_shift = shift / kBitsPerDigit;
   const intptr_t bit_shift = shift % kBitsPerDigit;
   result.EnsureLength(3 + digit_shift, space);
   result.SetUsed(3 + digit_shift);
   uint64_t abs_value;
   if (value < 0) {
     result.SetNeg(true);
@@ skipping 11 matching lines @@
   result.SetDigitAt(2 + digit_shift,
       (bit_shift == 0) ? 0
                        : static_cast<uint32_t>(abs_value >> (64 - bit_shift)));
   result.Clamp();
   return result.raw();
 }
 
 
 void Bigint::EnsureLength(intptr_t length, Heap::Space space) const {
   ASSERT(length >= 0);
+  length++;  // Account for leading zero for 64-bit processing.
   TypedData& old_digits = TypedData::Handle(digits());
-  if ((length > 0) && (length > old_digits.Length())) {
+  if (length > old_digits.Length()) {
     TypedData& new_digits = TypedData::Handle(
         TypedData::New(kTypedDataUint32ArrayCid, length + kExtraDigits, space));
-    if (old_digits.Length() > 0) {
+    set_digits(new_digits);
+    if (Used() > 0) {
       TypedData::Copy(new_digits, TypedData::data_offset(),
                       old_digits, TypedData::data_offset(),
-                      old_digits.LengthInBytes());
+                      (Used() + 1)*kBytesPerDigit);  // Copy leading zero.
     }
-    set_digits(new_digits);
   }
 }
 
 
 void Bigint::Clamp() const {
   intptr_t used = Used();
-  while ((used > 0) && (DigitAt(used - 1) == 0)) {
-    --used;
+  if (used > 0) {
+    if (DigitAt(used - 1) == 0) {
+      do {
+        --used;
+      } while ((used > 0) && (DigitAt(used - 1) == 0));
+      SetUsed(used);
+    }
+    SetDigitAt(used, 0);  // Set leading zero for 64-bit processing.
   }
-  SetUsed(used);
 }
 
 
 bool Bigint::IsClamped() const {
   intptr_t used = Used();
   return (used == 0) || (DigitAt(used - 1) > 0);
 }
 
 
 RawBigint* Bigint::NewFromCString(const char* str, Heap::Space space) {
   ASSERT(str != NULL);
-  if (str[0] == '\0') {
-    return NewFromInt64(0, space);
-  }
-
   // If the string starts with '-' recursively restart the whole operation
   // without the character and then toggle the sign.
-  // This allows multiple leading '-' (which will cancel each other out), but
-  // we have added an assert, to make sure that the returned result of the
-  // recursive call is not negative.
-  // We don't catch leading '-'s for zero. Ex: "--0", or "---".
   if (str[0] == '-') {
+    ASSERT(str[1] != '-');
     const Bigint& result = Bigint::Handle(NewFromCString(&str[1], space));
     result.SetNeg(!result.Neg());  // Toggle sign.
     ASSERT(result.IsZero() || result.IsNegative());
     ASSERT(result.IsClamped());
     return result.raw();
   }
 
   // No overflow check needed since overflowing str_length implies that we take
   // the branch to NewFromDecCString() which contains a check itself.
   const intptr_t str_length = strlen(str);
-  if ((str_length > 2) &&
+  if ((str_length >= 2) &&
       (str[0] == '0') &&
       ((str[1] == 'x') || (str[1] == 'X'))) {
     const Bigint& result = Bigint::Handle(NewFromHexCString(&str[2], space));
     ASSERT(result.IsClamped());
     return result.raw();
   } else {
     return NewFromDecCString(str, space);
   }
 }
 
@@ skipping 21 matching lines @@
   }
   // The value needs to be added to the constants list. Grow the list if
   // it is full.
   cls.InsertCanonicalConstant(index, value);
   value.SetCanonical();
   return value.raw();
 }
 
 
 RawBigint* Bigint::NewFromHexCString(const char* str, Heap::Space space) {
-  // TODO(regis): Do we need to check for max length?
   // If the string starts with '-' recursively restart the whole operation
   // without the character and then toggle the sign.
-  // This allows multiple leading '-' (which will cancel each other out), but
-  // we have added an assert, to make sure that the returned result of the
-  // recursive call is not negative.
-  // We don't catch leading '-'s for zero. Ex: "--0", or "---".
   if (str[0] == '-') {
+    ASSERT(str[1] != '-');
     const Bigint& result = Bigint::Handle(NewFromHexCString(&str[1], space));
-    result.SetNeg(!result.Neg());  // Toggle sign.
-    ASSERT(result.IsZero() || result.IsNegative());
+    if (!result.IsZero()) {
+      result.SetNeg(!result.Neg());  // Toggle sign.
+    }
     ASSERT(result.IsClamped());
     return result.raw();
   }
   const Bigint& result = Bigint::Handle(New(space));
   const int kBitsPerHexDigit = 4;
   const int kHexDigitsPerDigit = 8;
   const int kBitsPerDigit = kBitsPerHexDigit * kHexDigitsPerDigit;
   intptr_t hex_i = strlen(str);  // Terminating byte excluded.
+  if ((hex_i <= 0) || (hex_i >= kMaxInt32)) {
+    FATAL("Fatal error in Bigint::NewFromHexCString: string too long or empty");
+  }
   result.EnsureLength((hex_i + kHexDigitsPerDigit - 1) / kHexDigitsPerDigit,
                       space);
   intptr_t used_ = 0;
   uint32_t digit = 0;
   intptr_t bit_i = 0;
   while (--hex_i >= 0) {
     digit += Utils::HexDigitToInt(str[hex_i]) << bit_i;
     bit_i += kBitsPerHexDigit;
     if (bit_i == kBitsPerDigit) {
       bit_i = 0;
@@ skipping 10 matching lines @@
 }
 
 
 RawBigint* Bigint::NewFromDecCString(const char* str, Heap::Space space) {
   // Read 9 digits a time. 10^9 < 2^32.
   const int kDecDigitsPerIteration = 9;
   const uint32_t kTenMultiplier = 1000000000;
   ASSERT(kBitsPerDigit == 32);
 
   const intptr_t str_length = strlen(str);
-  if (str_length < 0) {  // TODO(regis): Pick a smaller limit.
-    FATAL("Fatal error in Bigint::NewFromDecCString: string too long");
+  if ((str_length <= 0) || (str_length >= kMaxInt32)) {
+    FATAL("Fatal error in Bigint::NewFromDecCString: string too long or empty");
   }
   intptr_t str_pos = 0;
 
   Bigint& result = Bigint::Handle(Bigint::New(space));
   // One decimal digit takes log2(10) bits, i.e. ~3.32192809489 bits.
   // That is a theoretical limit for large numbers.
   // The extra digits allocated take care of variations (kExtraDigits).
   const int64_t kLog10Dividend = 33219281;
   const int64_t kLog10Divisor = 10000000;
+
   result.EnsureLength((kLog10Dividend * str_length) /
                       (kLog10Divisor * kBitsPerDigit) + 1, space);
 
   // Read first digit separately. This avoids a multiplication and addition.
   // The first digit might also not have kDecDigitsPerIteration decimal digits.
   const intptr_t lsdigit_length = str_length % kDecDigitsPerIteration;
   uint32_t digit = 0;
   for (intptr_t i = 0; i < lsdigit_length; i++) {
     char c = str[str_pos++];
     ASSERT(('0' <= c) && (c <= '9'));
@@ skipping 2539 matching lines @@
       return 0;
     }
     // TODO(koda): Ensure VM classes only produce Smi hash codes, and remove
     // non-Smi cases once Dart-side implementation is complete.
     Isolate* isolate = Isolate::Current();
     REUSABLE_INSTANCE_HANDLESCOPE(isolate);
     Instance& hash_code = isolate->InstanceHandle();
     hash_code ^= Instance::Cast(obj).HashCode();
     if (hash_code.IsSmi()) {
       // May waste some bits on 64-bit, to ensure consistency with non-Smi case.
-      return static_cast<uword>(Smi::Cast(hash_code).Value() & 0xFFFFFFFF);
-      // TODO(regis): Same as Smi::AsTruncatedUint32Value(), simplify?
+      return static_cast<uword>(Smi::Cast(hash_code).AsTruncatedUint32Value());
     } else if (hash_code.IsInteger()) {
       return static_cast<uword>(
           Integer::Cast(hash_code).AsTruncatedUint32Value());
     } else {
       return 0;
     }
   }
 };
 typedef EnumIndexHashMap<DefaultHashTraits> EnumIndexDefaultMap;
 
@@ skipping 1253 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart