Ensure objects emitted in code are allocated in old space.

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 96 matching lines @@
   }
 
   intptr_t str_length = strlen(str);
   if ((str_length > 2) &&
       (str[0] == '0') &&
       ((str[1] == 'x') || (str[1] == 'X'))) {
     const Bigint& result = Bigint::Handle(FromHexCString(&str[2], space));
     ASSERT(IsClamped(result));
     return result.raw();
   } else {
-    return FromDecimalCString(str);
+    return FromDecimalCString(str, space);
   }
 }
 
 
 intptr_t BigintOperations::ComputeChunkLength(const char* hex_string) {
   ASSERT(kDigitBitSize % 4 == 0);
   intptr_t hex_length = strlen(hex_string);
   // Round up.
   intptr_t bigint_length = ((hex_length - 1) / kHexCharsPerDigit) + 1;
   return bigint_length;
@@ skipping 34 matching lines @@
 
   // Read first digit separately. This avoids a multiplication and addition.
   // The first digit might also not have kDigitsPerIteration decimal digits.
   int first_digit_decimal_digits = str_length % kDigitsPerIteration;
   Chunk digit = 0;
   for (intptr_t i = 0; i < first_digit_decimal_digits; i++) {
     char c = str[str_pos++];
     ASSERT(('0' <= c) && (c <= '9'));
     digit = digit * 10 + c - '0';
   }
-  Bigint& result = Bigint::Handle(Bigint::Allocate(1, space));
+  Bigint& result = Bigint::Handle(Bigint::Allocate(1));
   result.SetChunkAt(0, digit);
   Clamp(result);  // Multiplication requires the inputs to be clamped.
 
   // Read kDigitsPerIteration at a time, and store it in 'increment'.
   // Then multiply the temporary result by 10^kDigitsPerIteration and add
   // 'increment' to the new result.
-  const Bigint& increment = Bigint::Handle(Bigint::Allocate(1, space));
+  const Bigint& increment = Bigint::Handle(Bigint::Allocate(1));
   while (str_pos < str_length - 1) {
     Chunk digit = 0;
     for (intptr_t i = 0; i < kDigitsPerIteration; i++) {
       char c = str[str_pos++];
       ASSERT(('0' <= c) && (c <= '9'));
       digit = digit * 10 + c - '0';
     }
     result ^= MultiplyWithDigit(result, kTenMultiplier);
     if (digit != 0) {
       increment.SetChunkAt(0, digit);
       result ^= Add(result, increment);
     }
   }
   Clamp(result);
+  if ((space == Heap::kOld) && !result.IsOld()) {
+    result ^= Object::Clone(result, Heap::kOld);
+  }
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::NewFromDouble(double d, Heap::Space space) {
   if ((-1.0 < d) && (d < 1.0)) {
     // Shortcut for small numbers. Also makes the right-shift below
     // well specified.
     Smi& zero = Smi::Handle(Smi::New(0));
     return NewFromSmi(zero, space);
@@ skipping 1441 matching lines @@
 int BigintOperations::CountBits(Chunk digit) {
   int result = 0;
   while (digit != 0) {
     digit >>= 1;
     result++;
   }
   return result;
 }
 
 }  // namespace dart