Remove allocation in old space ....

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 506 matching lines @@
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
       ResolveType(cls, type_argument);
     }
   }
 }
 
 
 void ClassFinalizer::FinalizeTypeParameters(
     const Class& cls,
-    GrowableObjectArray* pending_types) {
+    PendingTypes* pending_types) {
   if (FLAG_trace_type_finalization) {
     ISL_Print("Finalizing type parameters of '%s'\n",
               String::Handle(cls.Name()).ToCString());
   }
   if (cls.IsMixinApplication()) {
     // Setup the type parameters of the mixin application and finalize the
     // mixin type.
     ApplyMixinType(cls, pending_types);
   }
   // The type parameter bounds are not finalized here.
@@ skipping 17 matching lines @@
 // not finite, where P is the instantiation of T with its own type parameters.
 // The induced type set S consists of the super types of any type in S as well
 // as the type arguments of any parameterized type in S.
 // The Dart Language Specification does not disallow the declaration and use of
 // non-contractive types (this may change). They are nevertheless disallowed
 // as an implementation restriction in the VM since they cause divergence.
 // A non-contractive type can be detected by looking at the queue of types
 // pending finalization that are mutually recursive with the checked type.
 void ClassFinalizer::CheckRecursiveType(const Class& cls,
                                         const Type& type,
-                                        GrowableObjectArray* pending_types) {
+                                        PendingTypes* pending_types) {
   Isolate* isolate = Isolate::Current();
   if (FLAG_trace_type_finalization) {
     ISL_Print("Checking recursive type '%s': %s\n",
               String::Handle(type.Name()).ToCString(),
               type.ToCString());
   }
   const Class& type_cls = Class::Handle(isolate, type.type_class());
   const TypeArguments& arguments =
       TypeArguments::Handle(isolate, type.arguments());
   // A type can only be recursive via its type arguments.
   ASSERT(!arguments.IsNull());
   const intptr_t num_type_args = arguments.Length();
   ASSERT(num_type_args > 0);
   ASSERT(num_type_args == type_cls.NumTypeArguments());
   const intptr_t num_type_params = type_cls.NumTypeParameters();
   const intptr_t first_type_param = num_type_args - num_type_params;
   // If the type is not generic (num_type_params == 0) or if its type parameters
   // are instantiated, no divergence can occur. Note that if the type parameters
   // are null, i.e. if the generic type is raw, they are considered
   // instantiated and no divergence can occur.
   if ((num_type_params == 0) ||
       arguments.IsSubvectorInstantiated(first_type_param, num_type_params)) {
     return;
   }
   // The type parameters are not instantiated. Verify that there is no other
   // type pending finalization with the same type class, but different
   // uninstantiated type parameters.
-  Type& pending_type = Type::Handle(isolate);
   TypeArguments& pending_arguments = TypeArguments::Handle(isolate);
-  const intptr_t num_pending_types = pending_types->Length();
+  const intptr_t num_pending_types = pending_types->length();
   for (intptr_t i = num_pending_types - 1; i >= 0; i--) {
-    pending_type ^= pending_types->At(i);
+    const Type& pending_type = Type::Cast(pending_types->At(i));
     if (FLAG_trace_type_finalization) {
       ISL_Print("  Comparing with pending type '%s': %s\n",
                 String::Handle(pending_type.Name()).ToCString(),
                 pending_type.ToCString());
     }
     if ((pending_type.raw() != type.raw()) &&
         (pending_type.type_class() == type_cls.raw())) {
       pending_arguments = pending_type.arguments();
       if (!pending_arguments.IsSubvectorEquivalent(arguments,
                                                    first_type_param,
@@ skipping 41 matching lines @@
 // It is too early to canonicalize the type arguments of the vector, because
 // several type argument vectors may be mutually recursive and finalized at the
 // same time. Canonicalization happens when pending types are processed.
 // The trail is required to correctly instantiate a recursive type argument
 // of the super type.
 void ClassFinalizer::FinalizeTypeArguments(
     const Class& cls,
     const TypeArguments& arguments,
     intptr_t num_uninitialized_arguments,
     Error* bound_error,
-    GrowableObjectArray* pending_types,
+    PendingTypes* pending_types,
     TrailPtr trail) {
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
   if (!cls.is_type_finalized()) {
     FinalizeTypeParameters(cls, pending_types);
     ResolveUpperBounds(cls);
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     const intptr_t num_super_type_params = super_class.NumTypeParameters();
@@ skipping 230 matching lines @@
                 bound_error.ToCString());
     }
   }
 }
 
 
 RawAbstractType* ClassFinalizer::FinalizeType(
     const Class& cls,
     const AbstractType& type,
     FinalizationKind finalization,
-    GrowableObjectArray* pending_types) {
+    PendingTypes* pending_types) {
   // Only the 'root' type of the graph can be canonicalized, after all depending
   // types have been bound checked.
   ASSERT((pending_types == NULL) || (finalization < kCanonicalize));
   if (type.IsFinalized()) {
     // Ensure type is canonical if canonicalization is requested, unless type is
     // malformed.
     if ((finalization >= kCanonicalize) && !type.IsMalformed()) {
       return type.Canonicalize();
     }
     return type.raw();
@@ skipping 54 matching lines @@
     // We do not canonicalize type parameters.
     return type_parameter.raw();
   }
 
   // At this point, we can only have a parameterized_type.
   const Type& parameterized_type = Type::Cast(type);
 
   // This type is the root type of the type graph if no pending types queue is
   // allocated yet.
   const bool is_root_type = (pending_types == NULL);
-  GrowableObjectArray& types = GrowableObjectArray::Handle(Z);
   if (is_root_type) {
-    types = GrowableObjectArray::New();
-    pending_types = &types;
+    pending_types = new PendingTypes(Z, 4);
   }
 
   // The type class does not need to be finalized in order to finalize the type,
   // however, it must at least be resolved (this was done as part of resolving
   // the type itself, a precondition to calling FinalizeType).
   // Also, the interfaces of the type class must be resolved and the type
   // parameters of the type class must be finalized.
   Class& type_class = Class::Handle(Z, parameterized_type.type_class());
   if (!type_class.is_type_finalized()) {
     FinalizeTypeParameters(type_class, pending_types);
@@ skipping 115 matching lines @@
     ASSERT(full_arguments.IsNull() ||
            !full_arguments.IsRaw(0, num_type_arguments));
     // Mark the type as finalized.
     parameterized_type.SetIsFinalized();
     // Do not yet remove the type from the pending_types array.
   }
 
   // If we are done finalizing a graph of mutually recursive types, check their
   // bounds.
   if (is_root_type) {
-    Type& type = Type::Handle(Z);
-    for (intptr_t i = types.Length() - 1; i >= 0; i--) {
-      type ^= types.At(i);
-      CheckTypeBounds(cls, type);
+    for (intptr_t i = pending_types->length() - 1; i >= 0; i--) {
+      CheckTypeBounds(cls, Type::Cast(pending_types->At(i)));
       if (FLAG_trace_type_finalization && type.IsRecursive()) {
         ISL_Print("Done finalizing recursive type '%s': %s\n",
                   String::Handle(Z, type.Name()).ToCString(),
                   type.ToCString());
       }
     }
   }
 
   // If the type class is a signature class, we are currently finalizing a
   // signature type, i.e. finalizing the result type and parameter types of the
@@ skipping 863 matching lines @@
               num_super_type_params + num_aliased_mixin_type_params,
               super_type.ToCString(),
               String::Handle(mixin_app_class.Name()).ToCString(),
               TypeArguments::Handle(
                   mixin_app_class.type_parameters()).ToCString());
   }
 }
 
 
 void ClassFinalizer::ApplyMixinType(const Class& mixin_app_class,
-                                    GrowableObjectArray* pending_types) {
+                                    PendingTypes* pending_types) {
   if (mixin_app_class.is_mixin_type_applied()) {
     return;
   }
   Type& mixin_type = Type::Handle(mixin_app_class.mixin());
   ASSERT(!mixin_type.IsNull());
   ASSERT(mixin_type.HasResolvedTypeClass());
   const Class& mixin_class = Class::Handle(mixin_type.type_class());
 
   if (FLAG_trace_class_finalization) {
     ISL_Print("Applying mixin type '%s' to %s at pos %" Pd "\n",
@@ skipping 1198 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart