Move HasOneTarget to ICData.

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/hash_map.h"
@@ skipping 284 matching lines @@
 static void RemovePushArguments(StaticCallInstr* call) {
   // Remove original push arguments.
   for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
     PushArgumentInstr* push = call->ArgumentAt(i);
     push->ReplaceUsesWith(push->value()->definition());
     push->RemoveFromGraph();
   }
 }
 
 
-// Returns true if all targets are the same.
-// TODO(srdjan): if targets are native use their C_function to compare.
-static bool HasOneTarget(const ICData& ic_data) {
-  ASSERT(ic_data.NumberOfChecks() > 0);
-  const Function& first_target = Function::Handle(ic_data.GetTargetAt(0));
-  Function& test_target = Function::Handle();
-  for (intptr_t i = 1; i < ic_data.NumberOfChecks(); i++) {
-    test_target = ic_data.GetTargetAt(i);
-    if (first_target.raw() != test_target.raw()) {
-      return false;
-    }
-  }
-  return true;
-}
-
-
 static intptr_t ReceiverClassId(InstanceCallInstr* call) {
   if (!call->HasICData()) return kIllegalCid;
 
   const ICData& ic_data = ICData::Handle(call->ic_data()->AsUnaryClassChecks());
 
   if (ic_data.NumberOfChecks() == 0) return kIllegalCid;
   // TODO(vegorov): Add multiple receiver type support.
   if (ic_data.NumberOfChecks() != 1) return kIllegalCid;
-  ASSERT(HasOneTarget(ic_data));
+  ASSERT(ic_data.HasOneTarget());
 
   Function& target = Function::Handle();
   intptr_t class_id;
   ic_data.GetOneClassCheckAt(0, &class_id, &target);
   return class_id;
 }
 
 
 void FlowGraphOptimizer::AddCheckClass(InstanceCallInstr* call,
                                        Value* value) {
@@ skipping 309 matching lines @@
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   ASSERT(class_ids.length() == 1);
 
   if (target.kind() == RawFunction::kImplicitGetter) {
-    if (!HasOneTarget(ic_data)) {
+    if (!ic_data.HasOneTarget()) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
     // Inline implicit instance getter.
     const String& field_name =
         String::Handle(Field::NameFromGetter(call->function_name()));
     const Field& field = Field::Handle(GetField(class_ids[0], field_name));
     ASSERT(!field.IsNull());
 
     if (InstanceCallNeedsClassCheck(call)) {
@@ skipping 12 matching lines @@
   }
 
   // Not an implicit getter.
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   // VM objects length getter.
   if ((recognized_kind == MethodRecognizer::kObjectArrayLength) ||
       (recognized_kind == MethodRecognizer::kImmutableArrayLength) ||
       (recognized_kind == MethodRecognizer::kGrowableArrayLength)) {
-    if (!HasOneTarget(ic_data)) {
+    if (!ic_data.HasOneTarget()) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
     intptr_t length_offset = -1;
     bool is_immutable = false;
     switch (recognized_kind) {
       case MethodRecognizer::kObjectArrayLength:
       case MethodRecognizer::kImmutableArrayLength:
         length_offset = Array::length_offset();
         is_immutable = true;
@@ skipping 35 matching lines @@
         Array::length_offset(),
         Type::ZoneHandle(Type::SmiType()));
     length_load->set_result_cid(kSmiCid);
 
     call->ReplaceWith(length_load, current_iterator());
     RemovePushArguments(call);
     return true;
   }
 
   if (recognized_kind == MethodRecognizer::kStringBaseLength) {
-    if (!HasOneTarget(ic_data)) {
+    if (!ic_data.HasOneTarget()) {
       // Target is not only StringBase_get_length.
       return false;
     }
     // Check receiver class.
     AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
 
     const bool is_immutable = true;  // String length is immutable.
     LoadFieldInstr* load = new LoadFieldInstr(
         call->ArgumentAt(0)->value(),
         String::length_offset(),
         Type::ZoneHandle(Type::SmiType()),
         is_immutable);
     load->set_result_cid(kSmiCid);
     call->ReplaceWith(load, current_iterator());
     RemovePushArguments(call);
     return true;
   }
   return false;
 }
 
 
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
-  if ((ic_data.NumberOfChecks() == 0) || !HasOneTarget(ic_data)) {
+  if ((ic_data.NumberOfChecks() == 0) || !ic_data.HasOneTarget()) {
     // No type feedback collected.
     return false;
   }
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   if ((recognized_kind == MethodRecognizer::kDoubleToDouble) &&
@@ skipping 47 matching lines @@
       PolymorphicInstanceCallInstr* call =
           new PolymorphicInstanceCallInstr(instr, unary_checks,
                                            call_with_checks);
       instr->ReplaceWith(call, current_iterator());
       return;
     }
     const intptr_t kMaxChecks = 4;
     if (instr->ic_data()->NumberOfChecks() <= kMaxChecks) {
       bool call_with_checks;
       // TODO(srdjan): Add check class instr for mixed smi/non-smi.
-      if (HasOneTarget(unary_checks) &&
+      if (unary_checks.HasOneTarget() &&
           (unary_checks.GetReceiverClassIdAt(0) != kSmiCid)) {
         // Type propagation has not run yet, we cannot eliminate the check.
         AddCheckClass(instr, instr->ArgumentAt(0)->value()->Copy());
         // Call can still deoptimize, do not detach environment from instr.
         call_with_checks = false;
       } else {
         call_with_checks = true;
       }
       PolymorphicInstanceCallInstr* call =
           new PolymorphicInstanceCallInstr(instr, unary_checks,
@@ skipping 23 matching lines @@
     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 (!HasOneTarget(unary_ic_data)) {
+  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;
   unary_ic_data.GetOneClassCheckAt(0, &class_id, &target);
   if (target.kind() != RawFunction::kImplicitSetter) {
     // Not an implicit setter.
     // TODO(srdjan): Inline special setters.
     return false;
@@ skipping 34 matching lines @@
 // and computation, this helper can go away.
 static void HandleRelationalOp(FlowGraphOptimizer* optimizer,
                                RelationalOpInstr* comp,
                                Instruction* instr) {
   if (!comp->HasICData()) return;
 
   const ICData& ic_data = *comp->ic_data();
   if (ic_data.NumberOfChecks() == 0) return;
   // TODO(srdjan): Add multiple receiver type support.
   if (ic_data.NumberOfChecks() != 1) return;
-  ASSERT(HasOneTarget(ic_data));
+  ASSERT(ic_data.HasOneTarget());
 
   if (HasOnlyTwoSmi(ic_data)) {
     optimizer->InsertBefore(
         instr,
         new CheckSmiInstr(comp->left()->Copy(), comp->deopt_id()),
         instr->env(),
         Definition::kEffect);
     optimizer->InsertBefore(
         instr,
         new CheckSmiInstr(comp->right()->Copy(), comp->deopt_id()),
@@ skipping 2095 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart