ICData::NumberOfChecks is O(n) so don't call it in loops

runtime/vm/aot_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/aot_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 483 matching lines @@
   }
   return true;
 }
 
 
 bool AotOptimizer::TryReplaceWithIndexedOp(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
   const ICData& ic_data =
       ICData::Handle(Z, call->ic_data()->AsUnaryClassChecks());
-  if (ic_data.NumberOfChecks() != 1) {
+  if (!ic_data.NumberOfChecksIs(1)) {
     return false;
   }
   return FlowGraphInliner::TryReplaceInstanceCallWithInline(
       flow_graph_, current_iterator(), call);
 }
 
 
 // Return true if d is a string of length one (a constant or result from
 // from string-from-char-code instruction.
 static bool IsLengthOneString(Definition* d) {
@@ skipping 781 matching lines @@
       // Unknown result.
       return Bool::null();
     }
   }
 
   const ClassTable& class_table = *isolate()->class_table();
   Bool& prev = Bool::Handle(Z);
   Class& cls = Class::Handle(Z);
 
   bool results_differ = false;
-  for (int i = 0; i < ic_data.NumberOfChecks(); i++) {
+  const intptr_t number_of_checks = ic_data.NumberOfChecks();
+  for (int i = 0; i < number_of_checks; i++) {
     cls = class_table.At(ic_data.GetReceiverClassIdAt(i));
     if (cls.NumTypeArguments() > 0) {
       return Bool::null();
     }
     // As of Dart 1.5, the Null type is a subtype of (and is more specific than)
     // any type. However, we are checking instances here and not types. The
     // null instance is only an instance of Null, Object, and dynamic.
     const bool is_subtype =
         cls.IsNullClass()
             ? (type_class.IsNullClass() || type_class.IsObjectClass() ||
@@ skipping 235 matching lines @@
       }
       call->RemoveEnvironment();
       ReplaceCall(call, new_call);
       copy->DeepCopyTo(Z, new_call);
       return;
     }
   }
 
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks());
-  if ((unary_checks.NumberOfChecks() > 0) &&
-      (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks)) {
+  const intptr_t number_of_checks = unary_checks.NumberOfChecks();
+  if (number_of_checks > 0 && number_of_checks <= FLAG_max_polymorphic_checks) {
     ZoneGrowableArray<intptr_t>* results =
-        new (Z) ZoneGrowableArray<intptr_t>(unary_checks.NumberOfChecks() * 2);
+        new (Z) ZoneGrowableArray<intptr_t>(number_of_checks * 2);
     InstanceOfAsBool(unary_checks, type, results);
-    if (results->length() == unary_checks.NumberOfChecks() * 2) {
+    if (results->length() == number_of_checks * 2) {
       const bool can_deopt = TryExpandTestCidsResult(results, type);
       if (can_deopt && !IsAllowedForInlining(call->deopt_id())) {
         // Guard against repeated speculative inlining.
         return;
       }
       TestCidsInstr* test_cids = new (Z)
           TestCidsInstr(call->token_pos(), negate ? Token::kISNOT : Token::kIS,
                         new (Z) Value(left), *results,
                         can_deopt ? call->deopt_id() : Thread::kNoDeoptId);
       // Remove type.
@@ skipping 12 matching lines @@
 // TODO(srdjan): Apply optimizations as in ReplaceWithInstanceOf (TestCids).
 void AotOptimizer::ReplaceWithTypeCast(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeCastOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* type_args = call->ArgumentAt(1);
   const AbstractType& type =
       AbstractType::Cast(call->ArgumentAt(2)->AsConstant()->value());
   ASSERT(!type.IsMalformedOrMalbounded());
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks());
-  if ((unary_checks.NumberOfChecks() > 0) &&
-      (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks)) {
+  const intptr_t number_of_checks = unary_checks.NumberOfChecks();
+  if (number_of_checks > 0 && number_of_checks <= FLAG_max_polymorphic_checks) {
     ZoneGrowableArray<intptr_t>* results =
-        new (Z) ZoneGrowableArray<intptr_t>(unary_checks.NumberOfChecks() * 2);
+        new (Z) ZoneGrowableArray<intptr_t>(number_of_checks * 2);
     const Bool& as_bool =
         Bool::ZoneHandle(Z, InstanceOfAsBool(unary_checks, type, results));
     if (as_bool.raw() == Bool::True().raw()) {
       // Guard against repeated speculative inlining.
       if (!IsAllowedForInlining(call->deopt_id())) {
         return;
       }
       AddReceiverCheck(call);
       // Remove the original push arguments.
       for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
@@ skipping 44 matching lines @@
 
 
 bool AotOptimizer::TryInlineFieldAccess(InstanceCallInstr* call) {
   const Token::Kind op_kind = call->token_kind();
   if ((op_kind == Token::kGET) && TryInlineInstanceGetter(call)) {
     return true;
   }
 
   const ICData& unary_checks =
       ICData::Handle(Z, call->ic_data()->AsUnaryClassChecks());
-  if ((unary_checks.NumberOfChecks() > 0) && (op_kind == Token::kSET) &&
+  if (!unary_checks.NumberOfChecksIs(0) && (op_kind == Token::kSET) &&
       TryInlineInstanceSetter(call, unary_checks)) {
     return true;
   }
 
   return false;
 }
 
 
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
@@ skipping 20 matching lines @@
   if (RecognizeRuntimeTypeGetter(instr)) {
     return;
   }
 
   if ((op_kind == Token::kEQ) && TryReplaceWithHaveSameRuntimeType(instr)) {
     return;
   }
 
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, instr->ic_data()->AsUnaryClassChecks());
-  if (IsAllowedForInlining(instr->deopt_id()) &&
-      (unary_checks.NumberOfChecks() > 0)) {
+  const intptr_t number_of_checks = unary_checks.NumberOfChecks();
+  if (IsAllowedForInlining(instr->deopt_id()) && number_of_checks > 0) {
     if ((op_kind == Token::kINDEX) && TryReplaceWithIndexedOp(instr)) {
       return;
     }
     if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithIndexedOp(instr)) {
       return;
     }
     if ((op_kind == Token::kEQ) && TryReplaceWithEqualityOp(instr, op_kind)) {
       return;
     }
 
     if (Token::IsRelationalOperator(op_kind) &&
         TryReplaceWithRelationalOp(instr, op_kind)) {
       return;
     }
 
     if (Token::IsBinaryOperator(op_kind) &&
         TryReplaceWithBinaryOp(instr, op_kind)) {
       return;
     }
     if (Token::IsUnaryOperator(op_kind) &&
         TryReplaceWithUnaryOp(instr, op_kind)) {
       return;
     }
 
     if (TryInlineInstanceMethod(instr)) {
       return;
     }
   }
 
-  bool has_one_target =
-      (unary_checks.NumberOfChecks() > 0) && unary_checks.HasOneTarget();
+  bool has_one_target = number_of_checks > 0 && unary_checks.HasOneTarget();
   if (has_one_target) {
     // Check if the single target is a polymorphic target, if it is,
     // we don't have one target.
     const Function& target = Function::Handle(Z, unary_checks.GetTargetAt(0));
     const bool polymorphic_target = MethodRecognizer::PolymorphicTarget(target);
     has_one_target = !polymorphic_target;
   }
 
   if (has_one_target) {
     RawFunction::Kind function_kind =
@@ skipping 173 matching lines @@
             ZoneGrowableArray<PushArgumentInstr*>(instr->ArgumentCount());
         for (intptr_t i = 0; i < instr->ArgumentCount(); i++) {
           args->Add(instr->PushArgumentAt(i));
         }
         StaticCallInstr* call = new (Z) StaticCallInstr(
             instr->token_pos(), Function::ZoneHandle(Z, single_target.raw()),
             instr->argument_names(), args, instr->deopt_id());
         instr->ReplaceWith(call, current_iterator());
         return;
       } else if ((ic_data.raw() != ICData::null()) &&
-                 (ic_data.NumberOfChecks() > 0)) {
+                 !ic_data.NumberOfChecksIs(0)) {
         PolymorphicInstanceCallInstr* call =
             new (Z) PolymorphicInstanceCallInstr(instr, ic_data,
                                                  /* with_checks = */ true,
                                                  /* complete = */ true);
         instr->ReplaceWith(call, current_iterator());
         return;
       }
     }
   }
 
@@ skipping 68 matching lines @@
     case MethodRecognizer::kMathAtan:
     case MethodRecognizer::kMathAtan2:
       FlowGraphInliner::TryReplaceStaticCallWithInline(
           flow_graph_, current_iterator(), call);
       break;
     case MethodRecognizer::kMathMin:
     case MethodRecognizer::kMathMax: {
       // We can handle only monomorphic min/max call sites with both arguments
       // being either doubles or smis.
       if (CanUnboxDouble() && call->HasICData() &&
-          (call->ic_data()->NumberOfChecks() == 1)) {
+          call->ic_data()->NumberOfChecksIs(1)) {
         const ICData& ic_data = *call->ic_data();
         intptr_t result_cid = kIllegalCid;
         if (ICDataHasReceiverArgumentClassIds(ic_data, kDoubleCid,
                                               kDoubleCid)) {
           result_cid = kDoubleCid;
         } else if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid,
                                                      kSmiCid)) {
           result_cid = kSmiCid;
         }
         if (result_cid != kIllegalCid) {
           MathMinMaxInstr* min_max = new (Z) MathMinMaxInstr(
               recognized_kind, new (Z) Value(call->ArgumentAt(0)),
               new (Z) Value(call->ArgumentAt(1)), call->deopt_id(), result_cid);
           const ICData& unary_checks =
               ICData::ZoneHandle(Z, ic_data.AsUnaryClassChecks());
           AddCheckClass(min_max->left()->definition(), unary_checks,
                         call->deopt_id(), call->env(), call);
           AddCheckClass(min_max->right()->definition(), unary_checks,
                         call->deopt_id(), call->env(), call);
           ReplaceCall(call, min_max);
         }
       }
       break;
     }
     case MethodRecognizer::kDoubleFromInteger: {
-      if (call->HasICData() && (call->ic_data()->NumberOfChecks() == 1)) {
+      if (call->HasICData() && call->ic_data()->NumberOfChecksIs(1)) {
         const ICData& ic_data = *call->ic_data();
         if (CanUnboxDouble()) {
           if (ArgIsAlways(kSmiCid, ic_data, 1)) {
             Definition* arg = call->ArgumentAt(1);
             AddCheckSmi(arg, call->deopt_id(), call->env(), call);
             ReplaceCall(call, new (Z) SmiToDoubleInstr(new (Z) Value(arg),
                                                        call->token_pos()));
           } else if (ArgIsAlways(kMintCid, ic_data, 1) &&
                      CanConvertUnboxedMintToDouble()) {
             Definition* arg = call->ArgumentAt(1);
@@ skipping 22 matching lines @@
                                            const ICData& unary_ic_data) {
   ASSERT((unary_ic_data.NumberOfChecks() > 0) &&
          (unary_ic_data.NumArgsTested() == 1));
   if (I->type_checks()) {
     // Checked mode setters are inlined like normal methods by conventional
     // inlining.
     return false;
   }
 
   ASSERT(instr->HasICData());
-  if (unary_ic_data.NumberOfChecks() == 0) {
+  if (unary_ic_data.NumberOfChecksIs(0)) {
     // No type feedback collected.
     return false;
   }
   if (!unary_ic_data.HasOneTarget()) {
     // Polymorphic sites are inlined like normal method calls by conventional
     // inlining.
     return false;
   }
   Function& target = Function::Handle(Z);
   intptr_t class_id;
@@ skipping 45 matching lines @@
                                   FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart