Do not eagerly finalize classes in CHA, instead regard unfinalized classes as ’non-existent’ an…

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 19 matching lines @@
       GrowableObjectArray::Handle(object_store->pending_classes());
   return classes.Length() == 0;
 }
 
 
 // Removes optimized code once we load more classes, since --use_cha based
 // optimizations may have become invalid.
 // Only methods which owner classes where subclasses can be invalid.
 // TODO(srdjan): Be even more precise by recording the exact CHA optimization.
 static void RemoveOptimizedCode(
-    const GrowableArray<intptr_t>& added_subclasses_to_cids) {
+    const GrowableArray<intptr_t>& added_subclass_to_cids) {
   ASSERT(FLAG_use_cha);
-  if (added_subclasses_to_cids.is_empty()) return;
+  if (added_subclass_to_cids.is_empty()) return;
   // Deoptimize all live frames.
-  DeoptimizeIfOwner(added_subclasses_to_cids);
+  DeoptimizeIfOwner(added_subclass_to_cids);
   // Switch all functions' code to unoptimized.
   const ClassTable& class_table = *Isolate::Current()->class_table();
   Class& cls = Class::Handle();
   Array& array = Array::Handle();
   Function& function = Function::Handle();
-  for (intptr_t i = 0; i < added_subclasses_to_cids.length(); i++) {
-    intptr_t cid = added_subclasses_to_cids[i];
+  for (intptr_t i = 0; i < added_subclass_to_cids.length(); i++) {
+    intptr_t cid = added_subclass_to_cids[i];
     cls = class_table.At(cid);
     ASSERT(!cls.IsNull());
     array = cls.functions();
     const intptr_t num_functions = array.IsNull() ? 0 : array.Length();
     for (intptr_t f = 0; f < num_functions; f++) {
       function ^= array.At(f);
       ASSERT(!function.IsNull());
       if (function.HasOptimizedCode()) {
         function.SwitchToUnoptimizedCode();
       }
@@ skipping 20 matching lines @@
   }
   finalized_super_classes->Add(cid);
   const AbstractType& super_type = AbstractType::Handle(cls.super_type());
   AddSuperType(super_type, finalized_super_classes);
 }
 
 
 // Use array instead of set since we expect very few subclassed classes
 // to occur.
 static void CollectFinalizedSuperClasses(
-    const GrowableObjectArray& pending_classes,
-    GrowableArray<intptr_t>* finalized_super_classes) {
-  Class& cls = Class::Handle();
+    const Class& cls_, GrowableArray<intptr_t>* finalized_super_classes) {
+  Class& cls = Class::Handle(cls_.raw());
   AbstractType& super_type = Type::Handle();
-  for (intptr_t i = 0; i < pending_classes.Length(); i++) {
-    cls ^= pending_classes.At(i);
-    ASSERT(!cls.is_finalized());
-    super_type = cls.super_type();
-    if (!super_type.IsNull()) {
-      if (!super_type.IsMalformed() && super_type.HasResolvedTypeClass()) {
-        cls ^= super_type.type_class();
-        if (cls.is_finalized()) {
-          AddSuperType(super_type, finalized_super_classes);
-        }
+  super_type = cls.super_type();
+  if (!super_type.IsNull()) {
+    if (!super_type.IsMalformed() && super_type.HasResolvedTypeClass()) {
+      cls ^= super_type.type_class();
+      if (cls.is_finalized()) {
+        AddSuperType(super_type, finalized_super_classes);
       }
     }
   }
 }
 
 
-// Class finalization occurs:
+// Type hierarchy finalization occurs:
 // a) when bootstrap process completes (VerifyBootstrapClasses).
 // b) after the user classes are loaded (dart_api).
-bool ClassFinalizer::FinalizePendingClasses() {
+bool ClassFinalizer::FinalizeTypeHierarchy() {

[siva, 2013/11/22 18:09:53]

We collect all classes in a pending classes list
(object_store->pending_classes()) and this method was to process through this
pending_classes list. By renaming this to something that does not refer to
pending classes we lose that connection.

Can this be renamed to FinalizeTypeHierarchyOfPendingClasses or something like
that.

   bool retval = true;
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   HANDLESCOPE(isolate);
   ObjectStore* object_store = isolate->object_store();
   const Error& error = Error::Handle(isolate, object_store->sticky_error());
   if (!error.IsNull()) {
     return false;
   }
   if (AllClassesFinalized()) {
     return true;
   }
 
-  GrowableArray<intptr_t> added_subclasses_to_cids;
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     GrowableObjectArray& class_array = GrowableObjectArray::Handle();
     class_array = object_store->pending_classes();
     ASSERT(!class_array.IsNull());
-    // Collect superclasses that were already finalized before this run of
-    // finalization.
-    CollectFinalizedSuperClasses(class_array, &added_subclasses_to_cids);
     Class& cls = Class::Handle();
     // First resolve all superclasses.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       GrowableArray<intptr_t> visited_interfaces;
       ResolveSuperTypeAndInterfaces(cls, &visited_interfaces);
     }
     // Finalize all classes.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       FinalizeTypesInClass(cls);
     }
     if (FLAG_print_classes) {
       for (intptr_t i = 0; i < class_array.Length(); i++) {
         cls ^= class_array.At(i);
         PrintClassInformation(cls);
       }
     }
     // Clear pending classes array.
     class_array = GrowableObjectArray::New();
     object_store->set_pending_classes(class_array);
     VerifyImplicitFieldOffsets();  // Verification after an error may fail.
   } else {
     retval = false;
   }
   isolate->set_long_jump_base(base);
-  if (FLAG_use_cha) {
-    RemoveOptimizedCode(added_subclasses_to_cids);
-  }
   return retval;
 }
 
 
 // Adds all interfaces of cls into 'collected'. Duplicate entries may occur.
 // No cycles are allowed.
 void ClassFinalizer::CollectInterfaces(const Class& cls,
                                        const GrowableObjectArray& collected) {
   const Array& interface_array = Array::Handle(cls.interfaces());
   AbstractType& interface = AbstractType::Handle();
@@ skipping 51 matching lines @@
       GrowableObjectArray::Handle(object_store->pending_classes());
   for (intptr_t i = 0; i < class_array.Length(); i++) {
     // TODO(iposva): Add real checks.
     cls ^= class_array.At(i);
     if (cls.is_finalized() || cls.is_prefinalized()) {
       // Pre-finalized bootstrap classes must not define any fields.
       ASSERT(!cls.HasInstanceFields());
     }
   }
 
-  // Finalize classes that aren't pre-finalized by Object::Init().
-  if (!FinalizePendingClasses()) {
+  // Finalize type hierarchy for types that aren't pre-finalized
+  // by Object::Init().
+  if (!FinalizeTypeHierarchy()) {
     // TODO(srdjan): Exit like a real VM instead.
     const Error& err = Error::Handle(object_store->sticky_error());
     OS::PrintErr("Could not verify bootstrap classes : %s\n",
                  err.ToErrorCString());
     OS::Exit(255);
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("VerifyBootstrapClasses END.\n");
   }
   Isolate::Current()->heap()->Verify();
@@ skipping 1796 matching lines @@
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
   }
   if (cls.IsMixinApplication()) {
     // Copy instance methods and fields from the mixin class.
     // This has to happen before the check whether the methods of
     // the class conflict with inherited methods.
     ApplyMixinMembers(cls);
   }
+  GrowableArray<intptr_t> added_subclass_to_cids;
+  CollectFinalizedSuperClasses(cls, &added_subclass_to_cids);
   // Ensure super class is finalized.
   const Class& super = Class::Handle(cls.SuperClass());
   if (!super.IsNull()) {
     FinalizeClass(super);
   }
   // Mark as parsed and finalized.
   cls.Finalize();
   // Mixin app alias classes may still lack their forwarding constructor.
   if (cls.is_mixin_app_alias() &&
       (cls.functions() == Object::empty_array().raw())) {
     const GrowableObjectArray& cloned_funcs =
         GrowableObjectArray::Handle(GrowableObjectArray::New());
     CreateForwardingConstructors(cls, cloned_funcs);
     const Array& functions = Array::Handle(Array::MakeArray(cloned_funcs));
     cls.SetFunctions(functions);
   }
   // Every class should have at least a constructor, unless it is a top level
   // class or a signature class.
   ASSERT(cls.IsTopLevel() ||
          cls.IsSignatureClass() ||
          (Array::Handle(cls.functions()).Length() > 0));
   // Resolve and finalize all member types.
   ResolveAndFinalizeMemberTypes(cls);
   // Run additional checks after all types are finalized.
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
   }
+  if (FLAG_use_cha) {
+    RemoveOptimizedCode(added_subclass_to_cids);
+  }
 }
 
 
 bool ClassFinalizer::IsSuperCycleFree(const Class& cls) {
   Class& test1 = Class::Handle(cls.raw());
   Class& test2 = Class::Handle(cls.SuperClass());
   // A finalized class has been checked for cycles.
   // Using the hare and tortoise algorithm for locating cycles.
   while (!test1.is_type_finalized() &&
          !test2.IsNull() && !test2.is_type_finalized()) {
@@ skipping 667 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart