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

runtime/vm/class_finalizer.cc

Index: runtime/vm/class_finalizer.cc
===================================================================
--- runtime/vm/class_finalizer.cc	(revision 30577)
+++ runtime/vm/class_finalizer.cc	(working copy)
@@ -37,18 +37,18 @@
 // 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();
@@ -89,30 +89,25 @@
 // 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);
@@ -126,7 +121,6 @@
     return true;
   }
 
-  GrowableArray<intptr_t> added_subclasses_to_cids;
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
@@ -134,9 +128,6 @@
     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++) {
@@ -163,9 +154,6 @@
     retval = false;
   }
   isolate->set_long_jump_base(base);
-  if (FLAG_use_cha) {
-    RemoveOptimizedCode(added_subclasses_to_cids);
-  }
   return retval;
 }
 
@@ -237,8 +225,9 @@
     }
   }
 
-  // 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",
@@ -2055,6 +2044,8 @@
     // 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()) {
@@ -2082,6 +2073,9 @@
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
   }
+  if (FLAG_use_cha) {
+    RemoveOptimizedCode(added_subclass_to_cids);
+  }
 }