Don't allocate on the Dart heap during Bigint::ToCString().

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 19722 matching lines @@
     }
     if (IsNegative()) {
       result = -result;
     }
     return result > 0 ? 1 : result < 0 ? -1 : 0;
   }
   return this->IsNegative() ? -1 : 1;
 }
 
 
-const char* Bigint::ToDecCString(uword (*allocator)(intptr_t size)) const {
+const char* Bigint::ToDecCString(Zone* zone) const {
   // log10(2) ~= 0.30102999566398114.
   const intptr_t kLog2Dividend = 30103;
   const intptr_t kLog2Divisor = 100000;
   intptr_t used = Used();
   const intptr_t kMaxUsed =
       kIntptrMax / kBitsPerDigit / kLog2Dividend * kLog2Divisor;
   if (used > kMaxUsed) {
     Exceptions::ThrowOOM();
     UNREACHABLE();
   }
   const int64_t bit_len = used * kBitsPerDigit;
   const int64_t dec_len = (bit_len * kLog2Dividend / kLog2Divisor) + 1;
   // Add one byte for the minus sign and for the trailing \0 character.
   const int64_t len = (Neg() ? 1 : 0) + dec_len + 1;
-  char* chars = reinterpret_cast<char*>(allocator(len));
+  char* chars = zone->Alloc<char>(len);
   intptr_t pos = 0;
   const intptr_t kDivisor = 100000000;
   const intptr_t kDigits = 8;
   ASSERT(pow(10.0, 1.0 * kDigits) == kDivisor);
   ASSERT(kDivisor < kDigitBase);
   ASSERT(Smi::IsValid(kDivisor));
   // Allocate a copy of the digits.
-  const TypedData& rest_digits = TypedData::Handle(
-      TypedData::New(kTypedDataUint32ArrayCid, used));
+  uint32_t* rest_digits = zone->Alloc<uint32_t>(used);
   for (intptr_t i = 0; i < used; i++) {
-    rest_digits.SetUint32(i << 2, DigitAt(i));
+    rest_digits[i] = DigitAt(i);
   }
   if (used == 0) {
     chars[pos++] = '0';
   }
   while (used > 0) {
     uint32_t remainder = 0;
     for (intptr_t i = used - 1; i >= 0; i--) {
       uint64_t dividend = (static_cast<uint64_t>(remainder) << kBitsPerDigit) +
-          rest_digits.GetUint32(i << 2);
+          rest_digits[i];
       uint32_t quotient = static_cast<uint32_t>(dividend / kDivisor);
       remainder = static_cast<uint32_t>(
           dividend - static_cast<uint64_t>(quotient) * kDivisor);
-      rest_digits.SetUint32(i << 2, quotient);
+      rest_digits[i] = quotient;
     }
     // Clamp rest_digits.
-    while ((used > 0) && (rest_digits.GetUint32((used - 1) << 2) == 0)) {
+    while ((used > 0) && (rest_digits[used - 1] == 0)) {
       used--;
     }
     for (intptr_t i = 0; i < kDigits; i++) {
       chars[pos++] = '0' + (remainder % 10);
       remainder /= 10;
     }
     ASSERT(remainder == 0);
   }
   // Remove leading zeros.
   while ((pos > 1) && (chars[pos - 1] == '0')) {
@@ skipping 10 matching lines @@
     chars[i] = chars[j];
     chars[j] = tmp;
     i++;
     j--;
   }
   chars[pos] = '\0';
   return chars;
 }
 
 
-const char* Bigint::ToHexCString(uword (*allocator)(intptr_t size)) const {
+const char* Bigint::ToHexCString(Zone* zone) const {
   const intptr_t used = Used();
   if (used == 0) {
     const char* zero = "0x0";
     const size_t len = strlen(zero) + 1;
-    char* chars = reinterpret_cast<char*>(allocator(len));
+    char* chars = zone->Alloc<char>(len);
     strncpy(chars, zero, len);
     return chars;
   }
   const int kBitsPerHexDigit = 4;
   const int kHexDigitsPerDigit = 8;
   const intptr_t kMaxUsed = (kIntptrMax - 4) / kHexDigitsPerDigit;
   if (used > kMaxUsed) {
     Exceptions::ThrowOOM();
     UNREACHABLE();
   }
   intptr_t hex_len = (used - 1) * kHexDigitsPerDigit;
   // The most significant digit may use fewer than kHexDigitsPerDigit digits.
   uint32_t digit = DigitAt(used - 1);
   ASSERT(digit != 0);  // Value must be clamped.
   while (digit != 0) {
     hex_len++;
     digit >>= kBitsPerHexDigit;
   }
   // Add bytes for '0x', for the minus sign, and for the trailing \0 character.
   const int32_t len = (Neg() ? 1 : 0) + 2 + hex_len + 1;
-  char* chars = reinterpret_cast<char*>(allocator(len));
+  char* chars = zone->Alloc<char>(len);
   intptr_t pos = len;
   chars[--pos] = '\0';
   for (intptr_t i = 0; i < (used - 1); i++) {
     digit = DigitAt(i);
     for (intptr_t j = 0; j < kHexDigitsPerDigit; j++) {
       chars[--pos] = Utils::IntToHexDigit(digit & 0xf);
       digit >>= kBitsPerHexDigit;
     }
   }
   digit = DigitAt(used - 1);
   while (digit != 0) {
     chars[--pos] = Utils::IntToHexDigit(digit & 0xf);
     digit >>= kBitsPerHexDigit;
   }
   chars[--pos] = 'x';
   chars[--pos] = '0';
   if (Neg()) {
     chars[--pos] = '-';
   }
   ASSERT(pos == 0);
   return chars;
 }
 
 
-static uword BigintAllocator(intptr_t size) {
-  Zone* zone = Thread::Current()->zone();
-  return zone->AllocUnsafe(size);
-}
-
-
 const char* Bigint::ToCString() const {
-  return ToDecCString(&BigintAllocator);
+  return ToDecCString(Thread::Current()->zone());
 }
 
 
 // Synchronize with implementation in compiler (intrinsifier).
 class StringHasher : ValueObject {
  public:
   StringHasher() : hash_(0) {}
   void Add(int32_t ch) {
     hash_ = CombineHashes(hash_, ch);
   }
@@ skipping 3150 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart