Fix bug with CHA dependencies by recording a set of classes for registering code.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 2257 matching lines @@
 // callee functions, then no class check is needed.
 bool FlowGraphOptimizer::InstanceCallNeedsClassCheck(
     InstanceCallInstr* call) const {
   if (!FLAG_use_cha) return true;
   Definition* callee_receiver = call->ArgumentAt(0);
   ASSERT(callee_receiver != NULL);
   const Function& function = flow_graph_->parsed_function().function();
   if (function.IsDynamicFunction() &&
       callee_receiver->IsParameter() &&
       (callee_receiver->AsParameter()->index() == 0)) {
-    return CHA::HasOverride(Class::Handle(I, function.Owner()),
-                            call->function_name());
+    return isolate()->cha()->HasOverride(Class::Handle(I, function.Owner()),
+                                         call->function_name());
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::MethodExtractorNeedsClassCheck(
     InstanceCallInstr* call) const {
   if (!FLAG_use_cha) return true;
   Definition* callee_receiver = call->ArgumentAt(0);
   ASSERT(callee_receiver != NULL);
   const Function& function = flow_graph_->parsed_function().function();
   if (function.IsDynamicFunction() &&
       callee_receiver->IsParameter() &&
       (callee_receiver->AsParameter()->index() == 0)) {
     const String& field_name =
       String::Handle(I, Field::NameFromGetter(call->function_name()));
-    return CHA::HasOverride(Class::Handle(I, function.Owner()), field_name);
+    return isolate()->cha()->HasOverride(
+        Class::Handle(I, function.Owner()), field_name);
   }
   return true;
 }
 
 
 void FlowGraphOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.HasOneTarget());
   Function& target = Function::Handle(I);
@@ skipping 1579 matching lines @@
       if (is_subtype != prev.value()) {
         results_differ = true;
       }
     }
   }
   return results_differ ?  Bool::null() : prev.raw();
 }
 
 
 // Returns true if checking against this type is a direct class id comparison.
-static bool TypeCheckAsClassEquality(const AbstractType& type) {
+bool FlowGraphOptimizer::TypeCheckAsClassEquality(const AbstractType& type) {
   ASSERT(type.IsFinalized() && !type.IsMalformedOrMalbounded());
   // Requires CHA.
   if (!FLAG_use_cha) return false;
   if (!type.IsInstantiated()) return false;
-  const Class& type_class = Class::Handle(type.type_class());
+  const Class& type_class = Class::ZoneHandle(type.type_class());

[Vyacheslav Egorov (Google), 2014/08/12 12:16:56]

Why ZoneHandle?

[Florian Schneider, 2014/08/13 10:34:40]

Done.

   // Signature classes have different type checking rules.
   if (type_class.IsSignatureClass()) return false;
   // Could be an interface check?
   if (type_class.is_implemented()) return false;
   const intptr_t type_cid = type_class.id();
-  if (CHA::HasSubclasses(type_cid)) return false;
+  if (isolate()->cha()->HasSubclasses(type_cid)) return false;
   const intptr_t num_type_args = type_class.NumTypeArguments();
   if (num_type_args > 0) {
     // Only raw types can be directly compared, thus disregarding type
     // arguments.
     const intptr_t num_type_params = type_class.NumTypeParameters();
     const intptr_t from_index = num_type_args - num_type_params;
     const TypeArguments& type_arguments =
         TypeArguments::Handle(type.arguments());
     const bool is_raw_type = type_arguments.IsNull() ||
         type_arguments.IsRaw(from_index, num_type_params);
@@ skipping 5582 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart