Do not recompute unary_checks repeatedly. Add special (and quicker) way to check for method overrid…

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/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 858 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)->value()->definition();
   ASSERT(callee_receiver != NULL);
   const Function& function = flow_graph_->parsed_function().function();
   if (function.IsDynamicFunction() &&
       callee_receiver->IsParameter() &&
       (callee_receiver->AsParameter()->index() == 0)) {
-    const intptr_t static_receiver_cid = Class::Handle(function.Owner()).id();
-    ZoneGrowableArray<intptr_t>* subclass_cids =
-        CHA::GetSubclassIdsOf(static_receiver_cid);
-    if (subclass_cids->is_empty()) {
-      // No subclasses, no check needed.
-      return false;
-    }
-    ZoneGrowableArray<Function*>* overriding_functions =
-        CHA::GetNamedInstanceFunctionsOf(*subclass_cids, call->function_name());
-    if (overriding_functions->is_empty()) {
-      // No overriding functions.
-      return false;
-    }
+    return CHA::HasOverride(Class::Handle(function.Owner()),
+                            call->function_name());
   }
   return true;
 }
 
 
 void FlowGraphOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
@@ skipping 246 matching lines @@
       TryReplaceWithBinaryOp(instr, op_kind)) {
     return;
   }
   if (Token::IsPrefixOperator(op_kind) &&
       TryReplaceWithUnaryOp(instr, op_kind)) {
     return;
   }
   if ((op_kind == Token::kGET) && TryInlineInstanceGetter(instr)) {
     return;
   }
-  if ((op_kind == Token::kSET) && TryInlineInstanceSetter(instr)) {
+  if ((op_kind == Token::kSET) &&
+      TryInlineInstanceSetter(instr, unary_checks)) {
     return;
   }
   if (TryInlineInstanceMethod(instr)) {
     return;
   }
   if (!InstanceCallNeedsClassCheck(instr)) {
     const bool call_with_checks = false;
     PolymorphicInstanceCallInstr* call =
         new PolymorphicInstanceCallInstr(instr, unary_checks,
                                          call_with_checks);
@@ skipping 22 matching lines @@
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(call->function());
   if (recognized_kind == MethodRecognizer::kMathSqrt) {
     MathSqrtInstr* sqrt = new MathSqrtInstr(call->ArgumentAt(0)->value(), call);
     call->ReplaceWith(sqrt, current_iterator());
     RemovePushArguments(call);
   }
 }
 
 
-bool FlowGraphOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr) {
+bool FlowGraphOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr,
+                                                 const ICData& unary_ic_data) {
+  ASSERT((unary_ic_data.NumberOfChecks() > 0) &&
+      (unary_ic_data.num_args_tested() == 1));
   if (FLAG_enable_type_checks) {
     // TODO(srdjan): Add assignable check node if --enable_type_checks.
     return false;
   }
 
   ASSERT(instr->HasICData());
-  const ICData& unary_ic_data =
-      ICData::Handle(instr->ic_data()->AsUnaryClassChecks());
   if (unary_ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
   if (!unary_ic_data.HasOneTarget()) {
     // TODO(srdjan): Implement when not all targets are the same.
     return false;
   }
   Function& target = Function::Handle();
   intptr_t class_id;
@@ skipping 2435 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart