- Allocate instantiated type arguments in new gen.

vm/object.cc

 // Copyright (c) 2011, 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 "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 2041 matching lines @@
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   ASSERT(IsFinalized());
   ASSERT(!IsInstantiated());
   TypeArguments& type_arguments = TypeArguments::Handle(arguments());
   type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments,
                                                   offset);
   const Class& cls = Class::Handle(type_class());
   ASSERT(cls.is_finalized());
   ParameterizedType& instantiated_type = ParameterizedType::Handle(
       ParameterizedType::New(cls, type_arguments));

[regis, 2011/11/17 16:46:23]

This call to ParameterizedType::New happens when instantiating generics at run
time. It should therefore allocate in the new gen. We may want a separate call
if we do not want to allocate all types in the new gen.

   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
   instantiated_type.set_is_finalized();
   return instantiated_type.raw();
 }
 
 
 bool ParameterizedType::Equals(const Type& other) const {
   ASSERT(IsFinalized() && other.IsFinalized());
   if (raw() == other.raw()) {
@@ skipping 182 matching lines @@
     const TypeArguments& value) const {
   StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
 }
 
 
 RawInstantiatedType* InstantiatedType::New() {
   const Class& instantiated_type_class =
       Class::Handle(Object::instantiated_type_class());
   RawObject* raw = Object::Allocate(instantiated_type_class,
                                     InstantiatedType::InstanceSize(),
                                     Heap::kOld);

[regis, 2011/11/17 16:46:23]

You can also use Heap::kNew here.

   return reinterpret_cast<RawInstantiatedType*>(raw);
 }
 
 
 RawInstantiatedType* InstantiatedType::New(
     const Type& uninstantiated_type,
     const TypeArguments& instantiator_type_arguments) {
   const InstantiatedType& result =
       InstantiatedType::Handle(InstantiatedType::New());
   result.set_uninstantiated_type(uninstantiated_type);
@@ skipping 218 matching lines @@
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   ASSERT(!IsInstantiated());
   if ((offset == 0) &&
       !instantiator_type_arguments.IsNull() &&
       IsUninstantiatedIdentity() &&
       (instantiator_type_arguments.Length() == Length())) {
     return instantiator_type_arguments.raw();
   }
   const intptr_t num_types = Length();
   TypeArray& instantiated_array = TypeArray::Handle(TypeArray::New(num_types));

[regis, 2011/11/17 16:46:23]

The same applies here to TypeArray::New as to ParameterizedType::New above.
Either we allocate all types in the new gen, or we provide a separate call to
allocate in the new gen here.

   Type& type = Type::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsInstantiated()) {
       type = type.InstantiateFrom(instantiator_type_arguments, offset);
     }
     instantiated_array.SetTypeAt(i, type);
   }
   return instantiated_array.raw();
 }
@@ skipping 81 matching lines @@
     const TypeArguments& value) const {
   StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
 }
 
 
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::New() {
   const Class& instantiated_type_arguments_class =
       Class::Handle(Object::instantiated_type_arguments_class());
   RawObject* raw = Object::Allocate(instantiated_type_arguments_class,
                                     InstantiatedTypeArguments::InstanceSize(),
-                                    Heap::kOld);
+                                    Heap::kNew);
   return reinterpret_cast<RawInstantiatedTypeArguments*>(raw);
 }
 
 
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::New(
     const TypeArguments& uninstantiated_type_arguments,
     const TypeArguments& instantiator_type_arguments) {
   const InstantiatedTypeArguments& result =
       InstantiatedTypeArguments::Handle(InstantiatedTypeArguments::New());
   result.set_uninstantiated_type_arguments(uninstantiated_type_arguments);
@@ skipping 4471 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