Faster IC stubs by specializing them for Binary Smi operations

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 94 matching lines @@
 
 // TODO(srdjan): Test/support other number types as well.
 static bool IsNumberCid(intptr_t cid) {
   return (cid == kSmiCid) || (cid == kDoubleCid);
 }
 
 
 // Attempt to build ICData for call using propagated class-ids.
 bool FlowGraphOptimizer::TryCreateICData(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
-  if (call->ic_data()->NumberOfChecks() > 0) {
+  if (call->ic_data()->NumberOfUsedChecks() > 0) {
     // This occurs when an instance call has too many checks, will be converted
     // to megamorphic call.
     return false;
   }
   if (FLAG_warn_on_javascript_compatibility) {
     // Do not make the instance call megamorphic if the callee needs to decode
     // the calling code sequence to lookup the ic data and verify if a warning
     // has already been issued or not.
     // TryCreateICData is only invoked if the ic_data target has not been called
     // yet, so no warning can possibly have been issued.
@@ skipping 62 matching lines @@
   }
   call->set_ic_data(&ic_data);
   return true;
 }
 
 
 const ICData& FlowGraphOptimizer::TrySpecializeICData(const ICData& ic_data,
                                                       intptr_t cid) {
   ASSERT(ic_data.NumArgsTested() == 1);
 
-  if ((ic_data.NumberOfChecks() == 1) &&
-      (ic_data.GetReceiverClassIdAt(0) == cid)) {
+  if ((ic_data.NumberOfUsedChecks() == 1) && ic_data.HasReceiverClassId(cid)) {
     return ic_data;  // Nothing to do
   }
 
   const Function& function =
       Function::Handle(I, ic_data.GetTargetForReceiverClassId(cid));
   // TODO(fschneider): Try looking up the function on the class if it is
   // not found in the ICData.
   if (!function.IsNull()) {
     const ICData& new_ic_data = ICData::ZoneHandle(I, ICData::New(
         Function::Handle(I, ic_data.owner()),
@@ skipping 631 matching lines @@
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       Definition* def = it.Current()->AsDefinition();
       if (def != NULL) {
         InsertConversionsFor(def);
       }
     }
   }
 }
 
 
-static bool ICDataHasReceiverArgumentClassIds(const ICData& ic_data,
-                                              intptr_t receiver_class_id,
-                                              intptr_t argument_class_id) {
-  ASSERT(receiver_class_id != kIllegalCid);
-  ASSERT(argument_class_id != kIllegalCid);
-  if (ic_data.NumArgsTested() != 2) return false;
-
-  Function& target = Function::Handle();
-  const intptr_t len = ic_data.NumberOfChecks();
-  for (intptr_t i = 0; i < len; i++) {
-    GrowableArray<intptr_t> class_ids;
-    ic_data.GetCheckAt(i, &class_ids, &target);
-    ASSERT(class_ids.length() == 2);
-    if ((class_ids[0] == receiver_class_id) &&
-        (class_ids[1] == argument_class_id)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-
 static bool ClassIdIsOneOf(intptr_t class_id,
                            const GrowableArray<intptr_t>& class_ids) {
   for (intptr_t i = 0; i < class_ids.length(); i++) {
+    ASSERT(class_ids[i] != kIllegalCid);
     if (class_ids[i] == class_id) {
       return true;
     }
   }
   return false;
 }
 
 
 // Returns true if ICData tests two arguments and all ICData cids are in the
 // required sets 'receiver_class_ids' or 'argument_class_ids', respectively.
 static bool ICDataHasOnlyReceiverArgumentClassIds(
     const ICData& ic_data,
     const GrowableArray<intptr_t>& receiver_class_ids,
     const GrowableArray<intptr_t>& argument_class_ids) {
-  if (ic_data.NumArgsTested() != 2) return false;
+  if (ic_data.NumArgsTested() != 2) {
+    return false;
+  }
   Function& target = Function::Handle();
   const intptr_t len = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
-    GrowableArray<intptr_t> class_ids;
-    ic_data.GetCheckAt(i, &class_ids, &target);
-    ASSERT(class_ids.length() == 2);
-    if (!ClassIdIsOneOf(class_ids[0], receiver_class_ids) ||
-        !ClassIdIsOneOf(class_ids[1], argument_class_ids)) {
+    if (ic_data.IsUsedAt(i)) {
+      GrowableArray<intptr_t> class_ids;
+      ic_data.GetCheckAt(i, &class_ids, &target);
+      ASSERT(class_ids.length() == 2);
+      if (!ClassIdIsOneOf(class_ids[0], receiver_class_ids) ||
+          !ClassIdIsOneOf(class_ids[1], argument_class_ids)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+
+static bool ICDataHasReceiverArgumentClassIds(const ICData& ic_data,
+                                              intptr_t receiver_class_id,
+                                              intptr_t argument_class_id) {
+  GrowableArray<intptr_t> receiver_cids(1);
+  receiver_cids.Add(receiver_class_id);
+  GrowableArray<intptr_t> argument_cids(1);
+  argument_cids.Add(argument_class_id);
+  return ICDataHasOnlyReceiverArgumentClassIds(
+      ic_data, receiver_cids, argument_cids);
+}
+
+
+static bool HasOnlyOneSmi(const ICData& ic_data) {
+  return (ic_data.NumberOfUsedChecks() == 1)
+      && ic_data.HasReceiverClassId(kSmiCid);
+}
+
+
+static bool HasOnlySmiOrMint(const ICData& ic_data) {
+  if (ic_data.NumberOfUsedChecks() == 1) {
+    return ic_data.HasReceiverClassId(kSmiCid)
+        || ic_data.HasReceiverClassId(kMintCid);
+  }
+  return (ic_data.NumberOfUsedChecks() == 2)
+      && ic_data.HasReceiverClassId(kSmiCid)
+      && ic_data.HasReceiverClassId(kMintCid);
+}
+
+
+static bool HasOnlyTwoOf(const ICData& ic_data, intptr_t cid) {
+  if (ic_data.NumberOfUsedChecks() != 1) {
+    return false;
+  }
+  GrowableArray<intptr_t> first;
+  GrowableArray<intptr_t> second;
+  ic_data.GetUsedCidsForTwoArgs(&first, &second);
+  return (first[0] == cid) && (second[0] == cid);
+}
+
+// Returns false if the ICData contains anything other than the 4 combinations
+// of Mint and Smi for the receiver and argument classes.
+static bool HasTwoMintOrSmi(const ICData& ic_data) {
+  GrowableArray<intptr_t> first;
+  GrowableArray<intptr_t> second;
+  ic_data.GetUsedCidsForTwoArgs(&first, &second);
+  for (intptr_t i = 0; i < first.length(); i++) {
+    if ((first[i] != kSmiCid) && (first[i] != kMintCid)) {
+      return false;
+    }
+    if ((second[i] != kSmiCid) && (second[i] != kMintCid)) {
       return false;
     }
   }
   return true;
 }
 
 
-static bool HasOnlyOneSmi(const ICData& ic_data) {
-  return (ic_data.NumberOfChecks() == 1)
-      && ic_data.HasReceiverClassId(kSmiCid);
-}
-
-
-static bool HasOnlySmiOrMint(const ICData& ic_data) {
-  if (ic_data.NumberOfChecks() == 1) {
-    return ic_data.HasReceiverClassId(kSmiCid)
-        || ic_data.HasReceiverClassId(kMintCid);
-  }
-  return (ic_data.NumberOfChecks() == 2)
-      && ic_data.HasReceiverClassId(kSmiCid)
-      && ic_data.HasReceiverClassId(kMintCid);
-}
-
-
-static bool HasOnlyTwoOf(const ICData& ic_data, intptr_t cid) {
-  return (ic_data.NumberOfChecks() == 1) &&
-      ICDataHasReceiverArgumentClassIds(ic_data, cid, cid);
-}
-
-// Returns false if the ICData contains anything other than the 4 combinations
-// of Mint and Smi for the receiver and argument classes.
-static bool HasTwoMintOrSmi(const ICData& ic_data) {
-  GrowableArray<intptr_t> class_ids(2);
-  class_ids.Add(kSmiCid);
-  class_ids.Add(kMintCid);
-  return ICDataHasOnlyReceiverArgumentClassIds(ic_data, class_ids, class_ids);
-}
-
-
 // Returns false if the ICData contains anything other than the 4 combinations
 // of Double and Smi for the receiver and argument classes.
 static bool HasTwoDoubleOrSmi(const ICData& ic_data) {
   GrowableArray<intptr_t> class_ids(2);
   class_ids.Add(kSmiCid);
   class_ids.Add(kDoubleCid);
   return ICDataHasOnlyReceiverArgumentClassIds(ic_data, class_ids, class_ids);
 }
 
 
 static bool HasOnlyOneDouble(const ICData& ic_data) {
-  return (ic_data.NumberOfChecks() == 1)
+  return (ic_data.NumberOfUsedChecks() == 1)
       && ic_data.HasReceiverClassId(kDoubleCid);
 }
 
 
 static bool ShouldSpecializeForDouble(const ICData& ic_data) {
   // Don't specialize for double if we can't unbox them.
   if (!CanUnboxDouble()) {
     return false;
   }
 
@@ skipping 34 matching lines @@
                  deopt_environment,
                  FlowGraph::kEffect);
   }
 }
 
 
 Instruction* FlowGraphOptimizer::GetCheckClass(Definition* to_check,
                                                const ICData& unary_checks,
                                                intptr_t deopt_id,
                                                intptr_t token_pos) {
-  if ((unary_checks.NumberOfChecks() == 1) &&
-      (unary_checks.GetReceiverClassIdAt(0) == kSmiCid)) {
+  if ((unary_checks.NumberOfUsedChecks() == 1) &&
+      unary_checks.HasReceiverClassId(kSmiCid)) {
     return new(I) CheckSmiInstr(new(I) Value(to_check),
                                 deopt_id,
                                 token_pos);
   }
   return new(I) CheckClassInstr(
       new(I) Value(to_check), deopt_id, unary_checks, token_pos);
 }
 
 
 void FlowGraphOptimizer::AddCheckClass(Definition* to_check,
@@ skipping 14 matching lines @@
                 call->deopt_id(),
                 call->env(),
                 call);
 }
 
 
 static bool ArgIsAlways(intptr_t cid,
                         const ICData& ic_data,
                         intptr_t arg_number) {
   ASSERT(ic_data.NumArgsTested() > arg_number);
+  if (ic_data.NumberOfUsedChecks() == 0) {
+    return false;
+  }
   const intptr_t num_checks = ic_data.NumberOfChecks();
-  if (num_checks == 0) return false;
   for (intptr_t i = 0; i < num_checks; i++) {
-    if (ic_data.GetClassIdAt(i, arg_number) != cid) return false;
+    if (ic_data.IsUsedAt(i) && ic_data.GetClassIdAt(i, arg_number) != cid) {
+      return false;
+    }
   }
   return true;
 }
 
 
 static bool CanUnboxInt32() {
   // Int32/Uint32 can be unboxed if it fits into a smi or the platform
   // supports unboxed mints.
   return (kSmiBits >= 32) || FlowGraphCompiler::SupportsUnboxedMints();
 }
@@ skipping 73 matching lines @@
   }
   return kIllegalCid;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithStoreIndexed(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
   const ICData& ic_data =
       ICData::Handle(I, call->ic_data()->AsUnaryClassChecks());
-  if (ic_data.NumberOfChecks() != 1) return false;
+  if (ic_data.NumberOfChecks() != 1) {
+    return false;
+  }
+  ASSERT(ic_data.NumberOfUsedChecks() == 1);
   ASSERT(ic_data.HasOneTarget());
 
   const Function& target = Function::Handle(I, ic_data.GetTargetAt(0));
   TargetEntryInstr* entry;
   Definition* last;
   if (!TryInlineRecognizedMethod(ic_data.GetReceiverClassIdAt(0),
                                  target,
                                  call,
                                  call->ArgumentAt(0),
                                  call->token_pos(),
@@ skipping 546 matching lines @@
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
   const ICData& ic_data =
       ICData::Handle(I, call->ic_data()->AsUnaryClassChecks());
-  if (ic_data.NumberOfChecks() != 1) return false;
+  if (ic_data.NumberOfChecks() != 1) {
+    return false;
+  }
+  ASSERT(ic_data.NumberOfUsedChecks() == 1);
   ASSERT(ic_data.HasOneTarget());
 
   const Function& target = Function::Handle(I, ic_data.GetTargetAt(0));
   TargetEntryInstr* entry;
   Definition* last;
   if (!TryInlineRecognizedMethod(ic_data.GetReceiverClassIdAt(0),
                                  target,
                                  call,
                                  call->ArgumentAt(0),
                                  call->token_pos(),
@@ skipping 899 matching lines @@
           call->deopt_id());
   ReplaceCall(call, float64x2_bin_op);
   return true;
 }
 
 
 // Only unique implicit instance getters can be currently handled.
 bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
-  if (ic_data.NumberOfChecks() == 0) {
+  if (ic_data.NumberOfUsedChecks() == 0) {
     // No type feedback collected.
     return false;
   }
 
   if (!ic_data.HasOneTarget()) {
     // Polymorphic sites are inlined like normal methods by conventional
     // inlining in FlowGraphInliner.
     return false;
   }
 
@@ skipping 219 matching lines @@
     default:
       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) || !ic_data.HasOneTarget()) {
+  if ((ic_data.NumberOfUsedChecks() == 0) || !ic_data.HasOneTarget()) {
     // No type feedback collected or multiple targets found.
     return false;
   }
 
   Function& target = Function::Handle(I);
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
@@ skipping 1279 matching lines @@
   // must have a deoptimization id that is valid for lookup in the unoptimized
   // code.
   assert_as->deopt_id_ = call->deopt_id();
   ReplaceCall(call, assert_as);
 }
 
 
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
-  if (!instr->HasICData() || (instr->ic_data()->NumberOfChecks() == 0)) {
+  if (!instr->HasICData() || (instr->ic_data()->NumberOfUsedChecks() == 0)) {
     return;
   }
 
   const Token::Kind op_kind = instr->token_kind();
   // Type test is special as it always gets converted into inlined code.
   if (Token::IsTypeTestOperator(op_kind)) {
     ReplaceWithInstanceOf(instr);
     return;
   }
 
   if (Token::IsTypeCastOperator(op_kind)) {
     ReplaceWithTypeCast(instr);
     return;
   }
 
   const ICData& unary_checks =
       ICData::ZoneHandle(I, instr->ic_data()->AsUnaryClassChecks());
 
-  intptr_t max_checks = (op_kind == Token::kEQ)
+  const intptr_t max_checks = (op_kind == Token::kEQ)
       ? FLAG_max_equality_polymorphic_checks
       : FLAG_max_polymorphic_checks;
   if ((unary_checks.NumberOfChecks() > max_checks) &&
       InstanceCallNeedsClassCheck(instr, RawFunction::kRegularFunction)) {
     // Too many checks, it will be megamorphic which needs unary checks.
     instr->set_ic_data(&unary_checks);
     return;
   }
 
   if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithStoreIndexed(instr)) {
@@ skipping 5402 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