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 10 matching lines @@
                     static_cast<uint32_t>(abs_value >> (32 - bit_shift)));
   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);
+  ASSERT(length > 0);
+  length++;  // Account for leading zero for 64-bit processing.

[regis, 2014/11/20 22:37:23]

Here too.

   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) {
@@ skipping 3948 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart