- Allow the collection of intermediate values during long BigintOperations.

runtime/vm/bigint_operations.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 
 #include "vm/bigint_operations.h"
 
 #include "platform/utils.h"
 
 #include "vm/double_internals.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/zone.h"
@@ skipping 311 matching lines @@
     const Bigint& bigint, uword (*allocator)(intptr_t size)) {
   // log10(2) ~= 0.30102999566398114.
   const intptr_t kLog2Dividend = 30103;
   const intptr_t kLog2Divisor = 100000;
   // We remove a small constant for rounding imprecision, the \0 character and
   // the negative sign.
   const intptr_t kMaxAllowedDigitLength =
       (kIntptrMax - 10) / kLog2Dividend / kDigitBitSize * kLog2Divisor;
 
   intptr_t length = bigint.Length();
+  Isolate* isolate = Isolate::Current();
   if (length >= kMaxAllowedDigitLength) {
     // Use the preallocated out of memory exception to avoid calling
     // into dart code or allocating any code.
-    Isolate* isolate = Isolate::Current();
     const Instance& exception =
         Instance::Handle(isolate->object_store()->out_of_memory());
     Exceptions::Throw(exception);
     UNREACHABLE();
   }
 
   // Approximate the size of the resulting string. We prefer overestimating
   // to not allocating enough.
   int64_t bit_length = length * kDigitBitSize;
   ASSERT(bit_length > length);
@@ skipping 17 matching lines @@
   ASSERT(pow(10.0, kChunkDigits) == kChunkDivisor);
   ASSERT(static_cast<Chunk>(kChunkDivisor) < kDigitMaxValue);
   ASSERT(Smi::IsValid(kChunkDivisor));
   const Bigint& divisor = Bigint::Handle(NewFromInt64(kChunkDivisor));
 
   // Rest contains the remaining bigint that needs to be printed.
   Bigint& rest = Bigint::Handle(bigint.raw());
   Bigint& quotient = Bigint::Handle();
   Bigint& remainder = Bigint::Handle();
   while (!rest.IsZero()) {
+    HANDLESCOPE(isolate);
     DivideRemainder(rest, divisor, &quotient, &remainder);
     ASSERT(remainder.Length() <= 1);
     intptr_t part = (remainder.Length() == 1)
         ? static_cast<intptr_t>(remainder.GetChunkAt(0))
         : 0;
     for (int i = 0; i < kChunkDigits; i++) {
       result[result_pos++] = '0' + (part % 10);
       part /= 10;
     }
     ASSERT(part == 0);
@@ skipping 1147 matching lines @@
   intptr_t quotient_pos = dividend_length - divisor_length;
   // Find the first quotient-digit.
   // The first digit must be computed separately from the other digits because
   // the preconditions for the loop are not yet satisfied.
   // For simplicity use a shifted divisor, so that the comparison and
   // subtraction are easier.
   int divisor_shift_amount = dividend_length - divisor_length;
   Bigint& shifted_divisor =
       Bigint::Handle(DigitsShiftLeft(divisor, divisor_shift_amount));
   Chunk first_quotient_digit = 0;
+  Isolate* isolate = Isolate::Current();
   while (UnsignedCompare(dividend, shifted_divisor) >= 0) {
+    HANDLESCOPE(isolate);
     first_quotient_digit++;
     dividend = Subtract(dividend, shifted_divisor);
   }
   quotient->SetChunkAt(quotient_pos--, first_quotient_digit);
 
   // Find the remainder of the digits.
 
   Chunk first_divisor_digit = divisor.GetChunkAt(divisor_length - 1);
   // The short divisor only represents the first two digits of the divisor.
   // If the divisor has only one digit, then the second part is zeroed out.
@@ skipping 114 matching lines @@
 int BigintOperations::CountBits(Chunk digit) {
   int result = 0;
   while (digit != 0) {
     digit >>= 1;
     result++;
   }
   return result;
 }
 
 }  // namespace dart