Allocate pending_classes array in new gen.

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/cpu.h"
@@ skipping 824 matching lines @@
   object_store->set_libraries(libraries);
 
   // Pre-register the core library.
   Library::InitCoreLibrary(isolate);
 
   // Basic infrastructure has been setup, initialize the class dictionary.
   Library& core_lib = Library::Handle(Library::CoreLibrary());
   ASSERT(!core_lib.IsNull());
 
   const GrowableObjectArray& pending_classes =
-      GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
   object_store->set_pending_classes(pending_classes);
 
   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.
   String& name = String::Handle();
   cls = object_store->array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::ObjectArray(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   // We cannot use NewNonParameterizedType(cls), because Array is parameterized.
   type ^= Type::New(Object::Handle(cls.raw()),
                     TypeArguments::Handle(),
                     Scanner::kDummyTokenIndex);
   type.SetIsFinalized();
   type ^= type.Canonicalize();
   object_store->set_array_type(type);
 
   cls = object_store->growable_object_array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::GrowableObjectArray(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = Class::New<Array>(kImmutableArrayCid);
   object_store->set_immutable_array_class(cls);
   cls.set_type_arguments_field_offset(Array::type_arguments_offset());
   ASSERT(object_store->immutable_array_class() != object_store->array_class());
   cls.set_is_prefinalized();
   RegisterPrivateClass(cls, Symbols::ImmutableArray(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = object_store->one_byte_string_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::OneByteString(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = object_store->two_byte_string_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::TwoByteString(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = Class::NewStringClass(kExternalOneByteStringCid);
   object_store->set_external_one_byte_string_class(cls);
   RegisterPrivateClass(cls, Symbols::ExternalOneByteString(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = Class::NewStringClass(kExternalTwoByteStringCid);
   object_store->set_external_two_byte_string_class(cls);
   RegisterPrivateClass(cls, Symbols::ExternalTwoByteString(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
   RegisterClass(cls, Symbols::StackTrace(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   // Super type set below, after Object is allocated.
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
   RegisterPrivateClass(cls, Symbols::JSSyntaxRegExp(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   // Initialize the base interfaces used by the core VM classes.
 
   // Allocate and initialize the pre-allocated classes in the core library.
   // The script and token index of these pre-allocated classes is set up in
   // the parser when the corelib script is compiled (see
   // Parser::ParseClassDefinition).
   cls = Class::New<Instance>(kInstanceCid);
   object_store->set_object_class(cls);
   cls.set_name(Symbols::Object());
   cls.set_is_prefinalized();
   core_lib.AddClass(cls);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
   RegisterClass(cls, Symbols::Bool(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = Class::New<Instance>(kNullCid);
   cls.set_is_prefinalized();
   object_store->set_null_class(cls);
   RegisterClass(cls, Symbols::Null(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = object_store->type_class();
   RegisterPrivateClass(cls, Symbols::Type(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = object_store->type_parameter_class();
   RegisterPrivateClass(cls, Symbols::TypeParameter(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = object_store->bounded_type_class();
   RegisterPrivateClass(cls, Symbols::BoundedType(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = object_store->mixin_app_type_class();
   RegisterPrivateClass(cls, Symbols::MixinAppType(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = Class::New<Integer>();
   object_store->set_integer_implementation_class(cls);
   RegisterPrivateClass(cls, Symbols::IntegerImplementation(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
   RegisterPrivateClass(cls, Symbols::_Smi(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = Class::New<Mint>();
   object_store->set_mint_class(cls);
   RegisterPrivateClass(cls, Symbols::_Mint(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = Class::New<Bigint>();
   object_store->set_bigint_class(cls);
   RegisterPrivateClass(cls, Symbols::_Bigint(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
   RegisterPrivateClass(cls, Symbols::_Double(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 
   // Abstract super class for all signature classes.
   cls = Class::New<Instance>(kIllegalCid);
   cls.set_is_prefinalized();
   RegisterPrivateClass(cls, Symbols::FunctionImpl(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_impl_type(type);
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
   RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
   // Pre-register the mirrors library so we can place the vm class
   // MirrorReference there rather than the core library.
   lib = Library::LookupLibrary(Symbols::DartMirrors());
@@ skipping 37 matching lines @@
   typed_data_classes.SetAt(index, cls);                                        \
   RegisterPrivateClass(cls, Symbols::_##clazz(), lib);                         \
 
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_CLASS);
 #undef REGISTER_TYPED_DATA_CLASS
 #define REGISTER_TYPED_DATA_VIEW_CLASS(clazz)                                  \
   cls = Class::NewTypedDataViewClass(kTypedData##clazz##ViewCid);              \
   index = kTypedData##clazz##ViewCid - kTypedDataInt8ArrayCid;                 \
   typed_data_classes.SetAt(index, cls);                                        \
   RegisterPrivateClass(cls, Symbols::_##clazz##View(), lib);                   \
-  pending_classes.Add(cls, Heap::kOld);                                        \
+  pending_classes.Add(cls);                                                    \
 
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_VIEW_CLASS);
   cls = Class::NewTypedDataViewClass(kByteDataViewCid);
   index = kByteDataViewCid - kTypedDataInt8ArrayCid;
   typed_data_classes.SetAt(index, cls);
   RegisterPrivateClass(cls, Symbols::_ByteDataView(), lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
 #undef REGISTER_TYPED_DATA_VIEW_CLASS
 #define REGISTER_EXT_TYPED_DATA_CLASS(clazz)                                   \
   cls = Class::NewExternalTypedDataClass(kExternalTypedData##clazz##Cid);      \
   index = kExternalTypedData##clazz##Cid - kTypedDataInt8ArrayCid;             \
   typed_data_classes.SetAt(index, cls);                                        \
   RegisterPrivateClass(cls, Symbols::_External##clazz(), lib);                 \
 
   CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
 #undef REGISTER_EXT_TYPED_DATA_CLASS
   // Register Float32x4 and Uint32x4 in the object store.
   cls = Class::New<Float32x4>();
   object_store->set_float32x4_class(cls);
   RegisterPrivateClass(cls, Symbols::_Float32x4(), lib);
   cls = Class::New<Uint32x4>();
   object_store->set_uint32x4_class(cls);
   RegisterPrivateClass(cls, Symbols::_Uint32x4(), lib);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Float32x4(), lib);
   cls.set_is_prefinalized();
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_float32x4_type(type);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Uint32x4(), lib);
   cls.set_is_prefinalized();
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_uint32x4_type(type);
 
   object_store->set_typed_data_classes(typed_data_classes);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   type = object_store->object_type();
   cls.set_super_type(type);
 
   // Abstract class that represents the Dart class Function.
   cls = Class::New<Instance>(kIllegalCid);
   cls.set_is_prefinalized();
   RegisterClass(cls, Symbols::Function(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_type(type);
 
   cls = Class::New<Number>();
   RegisterClass(cls, Symbols::Number(), core_lib);
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_number_type(type);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Int(), core_lib);
   cls.set_is_prefinalized();
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_int_type(type);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Double(), core_lib);
   cls.set_is_prefinalized();
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_double_type(type);
 
   name = Symbols::New("String");
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, name, core_lib);
   cls.set_is_prefinalized();
-  pending_classes.Add(cls, Heap::kOld);
+  pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_string_type(type);
 
   cls = object_store->bool_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_bool_type(type);
 
   cls = object_store->smi_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_smi_type(type);
@@ skipping 13785 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart