Remove value check from ICData checks/house-keeping

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 11714 matching lines @@
   const intptr_t len = NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     if (GetReceiverClassIdAt(i) == class_id) {
       return GetTargetAt(i);
     }
   }
   return Function::null();
 }
 
 
+RawICData* ICData::AsUnaryClassChecksForCids(
+    const GrowableArray<intptr_t>& cids, const Function& target) const {
+  ASSERT(!IsNull());
+  const intptr_t kNumArgsTested = 1;
+  ICData& result = ICData::Handle(ICData::NewFrom(*this, kNumArgsTested));
+  for (intptr_t i = 0; i < cids.length(); i++) {
+    const intptr_t class_id = cids[i];
+    const intptr_t count = GetCountAt(0);

[Cutch, 2015/05/27 02:53:55]

We are creating a new ICData and filling it with class ids, but, we're reusing
the count from *this? Why?

[srdjan, 2015/05/27 19:10:57]

The count is interesting as as it means different things if it is 0 or > 0. By
copying it we can pass that information to the newly generated ICData. In
current use (value checks) it does not matter, but IMO, it makes it more robust
if we pass that information.

Added comment.

+    // This will make sure that Smi is first if it exists.
+    result.AddReceiverCheck(class_id, target, count);
+  }
+  return result.raw();
+}
+
+
+RawICData* ICData::AsUnaryClassChecksForCid(
+    intptr_t cid, const Function& target) const {
+  ASSERT(!IsNull());
+  const intptr_t kNumArgsTested = 1;
+  ICData& result = ICData::Handle(ICData::NewFrom(*this, kNumArgsTested));
+
+  result.AddReceiverCheck(cid, target, GetCountAt(0));
+  return result.raw();
+}
+
+
 RawICData* ICData::AsUnaryClassChecksForArgNr(intptr_t arg_nr) const {
   ASSERT(!IsNull());
   ASSERT(NumArgsTested() > arg_nr);
   if ((arg_nr == 0) && (NumArgsTested() == 1)) {
     // Frequent case.
     return raw();
   }
   const intptr_t kNumArgsTested = 1;
-  ICData& result = ICData::Handle(ICData::New(
-      Function::Handle(owner()),
-      String::Handle(target_name()),
-      Array::Handle(arguments_descriptor()),
-      deopt_id(),
-      kNumArgsTested));
+  ICData& result = ICData::Handle(ICData::NewFrom(*this, 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.
       ASSERT((arg_nr != 0) ||
              (result.GetTargetAt(duplicate_class_id) == GetTargetAt(i)));
       result.IncrementCountAt(duplicate_class_id, count);
     } else {
       // This will make sure that Smi is first if it exists.
       result.AddReceiverCheck(class_id,
                               Function::Handle(GetTargetAt(i)),
                               count);
     }
   }
-  // Copy deoptimization reasons.
-  result.SetDeoptReasons(DeoptReasons());
 
   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++) {
@@ skipping 102 matching lines @@
   // Number of array elements in one test entry.
   intptr_t len = result.TestEntryLength();
   // IC data array must be null terminated (sentinel entry).
   const Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   result.WriteSentinel(ic_data);
   return result.raw();
 }
 
 
+RawICData* ICData::NewFrom(const ICData& from, intptr_t num_args_tested) {
+  const ICData& result = ICData::Handle(ICData::New(
+      Function::Handle(from.owner()),
+      String::Handle(from.target_name()),
+      Array::Handle(from.arguments_descriptor()),
+      from.deopt_id(),
+      num_args_tested));
+  // Copy deoptimization reasons.
+  result.SetDeoptReasons(from.DeoptReasons());
+  return result.raw();
+}
+
+
 void ICData::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 void ICData::PrintToJSONArray(const JSONArray& jsarray,
                               intptr_t token_pos,
                               bool is_static_call) const {
   Isolate* isolate = Isolate::Current();
   Class& cls = Class::Handle();
@@ skipping 8891 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart