Ensure objects emitted in code are allocated in old space.

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 499 matching lines @@
   Library::InitCoreLibrary(isolate);
   Library& core_lib = Library::Handle(Library::CoreLibrary());
   ASSERT(!core_lib.IsNull());
   Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
   ASSERT(!core_impl_lib.IsNull());
 
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
   object_store->set_pending_classes(pending_classes);
 
-  Context& context = Context::Handle(Context::New(0));
+  Context& context = Context::Handle(Context::New(0, Heap::kOld));
   object_store->set_empty_context(context);
 
   // Now that the symbol table is initialized and that the core dictionary as
   // well as the core implementation dictionary have been setup, preallocate
   // remaining classes and register them by name in the dictionaries.
   const Script& impl_script = Script::Handle(Bootstrap::LoadImplScript());
 
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
   RegisterClass(cls, "Smi", impl_script, core_impl_lib);
@@ skipping 465 matching lines @@
     UNREACHABLE();
   }
   NoGCScope no_gc;
   InitializeObject(address, cls.id(), size);
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
   ASSERT(cls.id() == RawObject::ClassIdTag::decode(raw_obj->ptr()->tags_));
   return raw_obj;
 }
 
 
+class StoreBufferObjectPointerVisitor : public ObjectPointerVisitor {
+ public:
+  explicit StoreBufferObjectPointerVisitor(Isolate* isolate) :
+      ObjectPointerVisitor(isolate) {
+  }
+  void VisitPointers(RawObject** first, RawObject** last) {
+    for (RawObject** curr = first; curr <= last; ++curr) {
+      if ((*curr)->IsNewObject()) {
+        uword ptr = reinterpret_cast<uword>(curr);
+        isolate()->store_buffer()->AddPointer(ptr);
+      }
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StoreBufferObjectPointerVisitor);
+};
+
+
+RawObject* Object::Clone(const Object& src, Heap::Space space) {
+  const Class& cls = Class::Handle(src.clazz());
+  intptr_t size = src.raw()->Size();
+  RawObject* raw_obj = Object::Allocate(cls, size, space);
+  NoGCScope no_gc;
+  memmove(raw_obj->ptr(), src.raw()->ptr(), size);
+  if (space == Heap::kOld) {
+    StoreBufferObjectPointerVisitor visitor(Isolate::Current());
+    raw_obj->VisitPointers(&visitor);
+  }
+  return raw_obj;
+}
+
+
 RawString* Class::Name() const {
   if (raw_ptr()->name_ != String::null()) {
     return raw_ptr()->name_;
   }
   ASSERT(class_class() != Class::null());  // class_class_ should be set up.
   intptr_t index = GetSingletonClassIndex(raw());
   return String::NewSymbol(GetSingletonClassName(index));
 }
 
 
@@ skipping 1738 matching lines @@
       ASSERT((index == 0) && cls.IsSignatureClass());
       index++;
       continue;
     }
     if (this->Equals(type)) {
       return type.raw();
     }
     index++;
   }
   // The type needs to be added to the list. Grow the list if it is full.
-  // TODO(srdjan): Copy type into old space if canonicalized?
   if (index == canonical_types_len) {
     const intptr_t kLengthIncrement = 2;  // Raw and parameterized.
     const intptr_t new_length = canonical_types.Length() + kLengthIncrement;
     const Array& new_canonical_types =
         Array::Handle(Array::Grow(canonical_types, new_length, Heap::kOld));
     cls.set_canonical_types(new_canonical_types);
     new_canonical_types.SetAt(index, *this);
   } else {
     canonical_types.SetAt(index, *this);
   }
+  ASSERT(IsOld());
   SetCanonical();
   return this->raw();
 }
 
 
 void Type::set_type_class(const Object& value) const {
   ASSERT(!value.IsNull() && (value.IsClass() || value.IsUnresolvedClass()));
   StorePointer(&raw_ptr()->type_class_, value.raw());
 }
 
@@ skipping 622 matching lines @@
 
 RawAbstractTypeArguments* TypeArguments::Canonicalize() const {
   if (IsNull() || IsCanonical() || !IsInstantiated()) {
     return this->raw();
   }
   ObjectStore* object_store = Isolate::Current()->object_store();
   // 'table' must be null terminated.
   Array& table = Array::Handle(object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
   intptr_t index = 0;
-  TypeArguments& other = TypeArguments::Handle();
-  other ^= table.At(index);
-  while (!other.IsNull()) {
-    if (this->Equals(other)) {
-      return other.raw();
+  TypeArguments& result = TypeArguments::Handle();
+  result ^= table.At(index);
+  while (!result.IsNull()) {
+    if (this->Equals(result)) {
+      return result.raw();
     }
-    other ^= table.At(++index);
+    result ^= table.At(++index);
   }
   // Not found. Add 'this' to table.
-  // TODO(srdjan): Copy 'this' into old space if canonicalized?
+  result ^= this->raw();
+  if (result.IsNew()) {
+    result ^= Object::Clone(result, Heap::kOld);
+  }
+  ASSERT(result.IsOld());
   if (index == table.Length() - 1) {
     table = Array::Grow(table, table.Length() + 4, Heap::kOld);
     object_store->set_canonical_type_arguments(table);
   }
-  table.SetAt(index, *this);
-  SetCanonical();
-  return this->raw();
+  table.SetAt(index, result);
+  result.SetCanonical();
+  return result.raw();
 }
 
 
 const char* TypeArguments::ToCString() const {
   if (IsNull()) {
     return "NULL TypeArguments";
   }
   const char* format = "%s [%s]";
   const char* prev_cstr = "TypeArguments:";
   for (int i = 0; i < Length(); i++) {
@@ skipping 972 matching lines @@
   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, Heap::kOld));
+    ASSERT(value.IsSmi() || value.IsOld());
     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 3105 matching lines @@
         return false;
       }
     }
   }
   return true;
 }
 
 
 RawInstance* Instance::Canonicalize() const {
   ASSERT(!IsNull());
-  if (!IsCanonical()) {
-    const Class& cls = Class::Handle(this->clazz());
-    Array& constants = Array::Handle(cls.constants());
-    const intptr_t constants_len = constants.Length();
-    // Linear search to see whether this value is already present in the
-    // list of canonicalized constants.
-    Instance& norm_value = Instance::Handle();
-    intptr_t index = 0;
-    while (index < constants_len) {
-      norm_value ^= constants.At(index);
-      if (norm_value.IsNull()) {
-        break;
-      }
-      if (this->Equals(norm_value)) {
-        return norm_value.raw();
-      }
-      index++;
+  if (this->IsCanonical()) {
+    return this->raw();
+  }
+  Instance& result = Instance::Handle();
+  const Class& cls = Class::Handle(this->clazz());
+  Array& constants = Array::Handle(cls.constants());
+  const intptr_t constants_len = constants.Length();
+  // Linear search to see whether this value is already present in the
+  // list of canonicalized constants.
+  intptr_t index = 0;
+  while (index < constants_len) {
+    result ^= constants.At(index);
+    if (result.IsNull()) {
+      break;
     }
-    // The value needs to be added to the list. Grow the list if
-    // it is full.
-    // TODO(srdjan): Copy instance into old space if canonicalized?
-    cls.InsertCanonicalConstant(index, *this);
-    SetCanonical();
+    if (this->Equals(result)) {
+      return result.raw();
+    }
+    index++;
   }
-  return this->raw();
+  // The value needs to be added to the list. Grow the list if
+  // it is full.
+  result ^= this->raw();
+  if (result.IsNew()) {
+    // Create a canonical object in old space.
+    result ^= Object::Clone(result, Heap::kOld);
+  }
+  ASSERT(result.IsOld());
+  cls.InsertCanonicalConstant(index, result);
+  result.SetCanonical();
+  return result.raw();
 }
 
 
 RawType* Instance::GetType() const {
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   if (cls.HasTypeArguments()) {
@@ skipping 3157 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