Add --use_cha (default true, switch to false if you use dynamic class loading). Use CHA to specify …

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2012, 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/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/scopes.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
 DEFINE_FLAG(bool, trace_optimization, false, "Print optimization details.");
 DECLARE_FLAG(bool, trace_type_check_elimination);
+DEFINE_FLAG(bool, use_cha, true, "Use class hierarchy analysis.");
 
 void FlowGraphOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
 
 void FlowGraphOptimizer::OptimizeComputations() {
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
     entry->Accept(this);
@@ skipping 830 matching lines @@
 }
 
 
 void FlowGraphTypePropagator::VisitParameter(ParameterInstr* param) {
   // TODO(regis): Once we inline functions, the propagated type of the formal
   // parameter will reflect the compile type of the passed-in argument.
   // For now, we do not know anything about the argument type and therefore set
   // it to the DynamicType, unless the argument is a compiler generated value,
   // i.e. the receiver argument or the constructor phase argument.
   AbstractType& param_type = AbstractType::Handle(Type::DynamicType());
+  param->SetPropagatedCid(kDynamicCid);
   if (param->index() < 2) {
     const Function& function = parsed_function().function();
     if (((param->index() == 0) && function.IsDynamicFunction()) ||
         ((param->index() == 1) && function.IsConstructor())) {
       // Parameter is the receiver or the constructor phase.
       LocalScope* scope = parsed_function().node_sequence()->scope();
       param_type = scope->VariableAt(param->index())->type().raw();
+      if (FLAG_use_cha) {
+        const intptr_t cid = Class::Handle(param_type.type_class()).id();
+        if (!CHA::HasSubclasses(cid)) {
+          // Receiver's class has no subclasses.
+          param->SetPropagatedCid(cid);
+        }
+      }
     }
   }
   bool changed = param->SetPropagatedType(param_type);
   if (changed) {
     still_changing_ = true;
   }
-  param->SetPropagatedCid(kDynamicCid);
 }
 
 
 void FlowGraphTypePropagator::PropagateTypes() {
   // TODO(regis): Is there a way to make this more efficient, e.g. by visiting
   // only blocks depending on blocks that have changed and not the whole graph.
   do {
     still_changing_ = false;
     VisitBlocks();
   } while (still_changing_);
@@ skipping 35 matching lines @@
         OS::Print("Replacing v%d with v%d\n",
                   instr->ssa_temp_index(),
                   result->ssa_temp_index());
       }
     }
   }
 }
 
 
 }  // namespace dart