- Separate store buffer data in the isolate into the StoreBufferBlock and

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 2109 matching lines @@
   type.set_token_pos(token_pos);
   return type.raw();
 }
 
 
 RawUnresolvedClass* UnresolvedClass::New() {
   const Class& unresolved_class_class =
       Class::Handle(Object::unresolved_class_class());
   RawObject* raw = Object::Allocate(unresolved_class_class,
                                     UnresolvedClass::InstanceSize(),
-                                    Heap::kNew);
+                                    Heap::kOld);
   return reinterpret_cast<RawUnresolvedClass*>(raw);
 }
 
 
 void UnresolvedClass::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
   raw_ptr()->token_pos_ = token_pos;
 }
 
 
@@ skipping 2188 matching lines @@
                                     Heap::kOld);
   return reinterpret_cast<RawLiteralToken*>(raw);
 }
 
 
 RawLiteralToken* LiteralToken::New(Token::Kind kind, const String& literal) {
   const LiteralToken& result = LiteralToken::Handle(LiteralToken::New());
   result.set_kind(kind);
   result.set_literal(literal);
   if (kind == Token::kINTEGER) {
-    const Integer& value = Integer::Handle(Integer::New(literal));
+    const Integer& value = Integer::Handle(Integer::New(literal, Heap::kOld));
     result.set_value(value);
   } else if (kind == Token::kDOUBLE) {
     const Double& value = Double::Handle(Double::NewCanonical(literal));
     result.set_value(value);
   } else {
     ASSERT(Token::NeedsLiteralToken(kind));
     result.set_value(literal);
   }
   return result.raw();
 }
@@ skipping 2992 matching lines @@
 }
 
 
 const char* Integer::ToCString() const {
   // Integer is an interface. No instances of Integer should exist.
   UNREACHABLE();
   return "Integer";
 }
 
 
-RawInteger* Integer::New(const String& str) {
+RawInteger* Integer::New(const String& str, Heap::Space space) {
+  // TODO(iposva): If returning a big integer it will not necessarily be in the
+  // requested space.
   const Bigint& big = Bigint::Handle(Bigint::New(str));
   if (BigintOperations::FitsIntoSmi(big)) {
     return BigintOperations::ToSmi(big);
   } else if (BigintOperations::FitsIntoMint(big)) {
-    return Mint::New(BigintOperations::ToMint(big));
+    return Mint::New(BigintOperations::ToMint(big), space);
   } else {
     return big.raw();
   }
 }
 
 
-RawInteger* Integer::New(int64_t value) {
+RawInteger* Integer::New(int64_t value, Heap::Space space) {
   if ((value <= Smi::kMaxValue) && (value >= Smi::kMinValue)) {
     return Smi::New(value);
   }
-  return Mint::New(value);
+  return Mint::New(value, space);
 }
 
 
 double Integer::AsDoubleValue() const {
   UNIMPLEMENTED();
   return 0.0;
 }
 
 
 int64_t Integer::AsInt64Value() const {
@@ skipping 2879 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart