Faster IC stubs by specializing them for Binary Smi operations

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 6628 matching lines @@
   }
 }
 
 
 void Function::RestoreICDataMap(
     ZoneGrowableArray<const ICData*>* deopt_id_to_ic_data) const {
   Isolate* isolate = Isolate::Current();
   const Array& saved_icd = Array::Handle(isolate, ic_data_array());
   if (saved_icd.Length() == 0) {
     deopt_id_to_ic_data->Clear();
-    return;;
+    return;
   }
   ICData& icd = ICData::Handle();
   icd ^= saved_icd.At(saved_icd.Length() - 1);
   const intptr_t len = icd.deopt_id() + 1;
   deopt_id_to_ic_data->SetLength(len);
   for (intptr_t i = 0; i < len; i++) {
     (*deopt_id_to_ic_data)[i] = NULL;
   }
   for (intptr_t i = 0; i < saved_icd.Length(); i++) {
     ICData& icd = ICData::ZoneHandle(isolate);
@@ skipping 4647 matching lines @@
   return TestEntryLengthFor(NumArgsTested());
 }
 
 
 intptr_t ICData::NumberOfChecks() const {
   // Do not count the sentinel;
   return (Smi::Value(ic_data()->ptr()->length_) / TestEntryLength()) - 1;
 }
 
 
+// Discounts any checks with usage of zero.
+intptr_t ICData::NumberOfUsedChecks() const {
+  intptr_t n = NumberOfChecks();
+  if (n == 0) {
+    return 0;
+  }
+  intptr_t count = 0;
+  for (intptr_t i = 0; i < n; i++) {
+    if (GetCountAt(i) > 0) {
+      count++;
+    }
+  }
+  return count;
+}
+
+
 void ICData::WriteSentinel(const Array& data) const {
   ASSERT(!data.IsNull());
   for (intptr_t i = 1; i <= TestEntryLength(); i++) {
     data.SetAt(data.Length() - i, smi_illegal_cid());
   }
 }
 
 
 #if defined(DEBUG)
 // Used in asserts to verify that a check is not added twice.
@@ skipping 28 matching lines @@
       AddReceiverCheck(kObjectCid, target, 1);
     } else {
       GrowableArray<intptr_t> class_ids(NumArgsTested());
       for (intptr_t i = 0; i < NumArgsTested(); i++) {
         class_ids.Add(kObjectCid);
       }
       AddCheck(class_ids, target);
     }
     return;
   }
-  ASSERT(NumArgsTested() >= 0);
+  ASSERT(NumArgsTested() == 0);
   // Can add only once.
   const intptr_t old_num = NumberOfChecks();
   ASSERT(old_num == 0);
   Array& data = Array::Handle(ic_data());
   const intptr_t new_len = data.Length() + TestEntryLength();
   data = Array::Grow(data, new_len, Heap::kOld);
   set_ic_data(data);
   WriteSentinel(data);
   intptr_t data_pos = old_num * TestEntryLength();
   ASSERT(!target.IsNull());
   data.SetAt(data_pos++, target);
+  // Set count to 0 as this is called during compilation, before the
+  // call has been executed.
   const Smi& value = Smi::Handle(Smi::New(0));
   data.SetAt(data_pos, value);
 }
 
 
 void ICData::AddCheck(const GrowableArray<intptr_t>& class_ids,
                       const Function& target) const {
   ASSERT(!target.IsNull());
+  ASSERT(target.name() == target_name());
   DEBUG_ASSERT(!HasCheck(class_ids));
   ASSERT(NumArgsTested() > 1);  // Otherwise use 'AddReceiverCheck'.
   ASSERT(class_ids.length() == NumArgsTested());
   const intptr_t old_num = NumberOfChecks();
   Array& data = Array::Handle(ic_data());
   // ICData of static calls with NumArgsTested() > 0 have initially a
   // dummy set of cids entered (see ICData::AddTarget). That entry is
   // overwritten by first real type feedback data.
   if (old_num == 1) {
     bool has_dummy_entry = true;
@@ skipping 191 matching lines @@
   ICData& result = ICData::Handle(ICData::New(
       Function::Handle(owner()),
       String::Handle(target_name()),
       Array::Handle(arguments_descriptor()),
       deopt_id(),
       kNumArgsTested));
   const intptr_t len = NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     const intptr_t class_id = GetClassIdAt(i, arg_nr);
     const intptr_t count = GetCountAt(i);
+    if (count == 0) {
+      continue;
+    }
     intptr_t duplicate_class_id = -1;
     const intptr_t result_len = result.NumberOfChecks();
     for (intptr_t k = 0; k < result_len; k++) {
       if (class_id == result.GetReceiverClassIdAt(k)) {
         duplicate_class_id = k;
         break;
       }
     }
     if (duplicate_class_id >= 0) {
       // This check is valid only when checking the receiver.
@@ skipping 12 matching lines @@
 
   return result.raw();
 }
 
 
 bool ICData::AllTargetsHaveSameOwner(intptr_t owner_cid) const {
   if (NumberOfChecks() == 0) return false;
   Class& cls = Class::Handle();
   const intptr_t len = NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
-    cls = Function::Handle(GetTargetAt(i)).Owner();
-    if (cls.id() != owner_cid) {
-      return false;
+    if (IsUsedAt(i)) {
+      cls = Function::Handle(GetTargetAt(i)).Owner();
+      if (cls.id() != owner_cid) {
+        return false;
+      }
     }
   }
   return true;
 }
 
 
 bool ICData::AllReceiversAreNumbers() const {
   if (NumberOfChecks() == 0) return false;
   Class& cls = Class::Handle();
   const intptr_t len = NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
-    cls = Function::Handle(GetTargetAt(i)).Owner();
-    const intptr_t cid = cls.id();
-    if ((cid != kSmiCid) &&
-        (cid != kMintCid) &&
-        (cid != kBigintCid) &&
-        (cid != kDoubleCid)) {
-      return false;
+    if (IsUsedAt(i)) {
+      cls = Function::Handle(GetTargetAt(i)).Owner();
+      const intptr_t cid = cls.id();
+      if ((cid != kSmiCid) &&
+          (cid != kMintCid) &&
+          (cid != kBigintCid) &&
+          (cid != kDoubleCid)) {
+        return false;
+      }
     }
   }
   return true;
 }
 
 
 bool ICData::HasReceiverClassId(intptr_t class_id) const {
   ASSERT(NumArgsTested() > 0);
   const intptr_t len = NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
-    const intptr_t test_class_id = GetReceiverClassIdAt(i);
-    if (test_class_id == class_id) {
-      return true;
+    if (IsUsedAt(i)) {
+      const intptr_t test_class_id = GetReceiverClassIdAt(i);
+      if (test_class_id == class_id) {
+        return true;
+      }
     }
   }
   return false;
 }
 
 
 // Returns true if all targets are the same.
 // TODO(srdjan): if targets are native use their C_function to compare.
 bool ICData::HasOneTarget() const {
   ASSERT(NumberOfChecks() > 0);
   const Function& first_target = Function::Handle(GetTargetAt(0));
   const intptr_t len = NumberOfChecks();
   for (intptr_t i = 1; i < len; i++) {
-    if (GetTargetAt(i) != first_target.raw()) {
+    if (IsUsedAt(i) && (GetTargetAt(i) != first_target.raw())) {
       return false;
     }
   }
   return true;
 }
 
 
+void ICData::GetUsedCidsForTwoArgs(GrowableArray<intptr_t>* first,
+                                   GrowableArray<intptr_t>* second) const {
+  ASSERT(NumArgsTested() == 2);
+  first->Clear();
+  second->Clear();
+  Function& target = Function::Handle();
+  GrowableArray<intptr_t> class_ids;
+  const intptr_t len = NumberOfChecks();
+  for (intptr_t i = 0; i < len; i++) {
+    if (GetCountAt(i) > 0) {
+      GetCheckAt(i, &class_ids, &target);
+      ASSERT(class_ids.length() == 2);
+      first->Add(class_ids[0]);
+      second->Add(class_ids[1]);
+    }
+  }
+}
+
+
+bool ICData::IsUsedAt(intptr_t i) const {
+  if (GetCountAt(i) <= 0) {
+    // Do not mistake unoptimized static call ICData for unused.
+    // See ICData::AddTarget.
+    // TODO(srdjan): Make this test more robust.
+    if (NumArgsTested() > 0) {
+      const intptr_t cid = GetReceiverClassIdAt(i);
+      if (cid == kObjectCid) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return true;
+}
+
+
 RawICData* ICData::New(const Function& owner,
                        const String& target_name,
                        const Array& arguments_descriptor,
                        intptr_t deopt_id,
                        intptr_t num_args_tested) {
   ASSERT(!owner.IsNull());
   ASSERT(!target_name.IsNull());
   ASSERT(!arguments_descriptor.IsNull());
   ASSERT(Object::icdata_class() != Class::null());
   ASSERT(num_args_tested >= 0);
@@ skipping 7826 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart