Support for mixed null/smi equality: do not deoptimize, emit same optimized code as if that was smi…

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/bigint_operations.h"
@@ skipping 7361 matching lines @@
 
 void ICData::WriteSentinel() const {
   const Smi& sentinel_value = Smi::Handle(Smi::New(kIllegalCid));
   const Array& data = Array::Handle(ic_data());
   for (intptr_t i = 1; i <= TestEntryLength(); i++) {
     data.SetAt(data.Length() - i, sentinel_value);
   }
 }
 
 
+// Used in asserts to verify that a check is not added twice.
+bool ICData::HasCheck(const GrowableArray<intptr_t>& cids) const {

[Florian Schneider, 2012/10/05 09:17:35]

Do we want this inside #ifdef DEBUG as well to avoid having it in the release
build?

[srdjan, 2012/10/09 18:06:03]

#if defined(DEBUG)

+  for (intptr_t i = 0; i < NumberOfChecks(); i++) {
+    GrowableArray<intptr_t> class_ids;
+    Function& target = Function::Handle();
+    GetCheckAt(i, &class_ids, &target);
+    bool matches = true;
+    for (intptr_t k = 0; k < class_ids.length(); k++) {
+      if (class_ids[k] != cids[k]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      return true;
+    }
+  }
+  return false;
+}
+
+
 void ICData::AddCheck(const GrowableArray<intptr_t>& class_ids,
                       const Function& target) const {
+  ASSERT(!HasCheck(class_ids));

[Florian Schneider, 2012/10/05 09:17:35]

Maybe DEBUG_ASSERT?

[srdjan, 2012/10/09 18:06:03]

Done.

   ASSERT(num_args_tested() > 1);  // Otherwise use 'AddReceiverCheck'.
   ASSERT(class_ids.length() == num_args_tested());
   const intptr_t old_num = NumberOfChecks();
   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();
   intptr_t data_pos = old_num * TestEntryLength();
   for (intptr_t i = 0; i < class_ids.length(); i++) {
     // kIllegalCid is used as terminating value, do not add it.
     ASSERT(class_ids[i] != kIllegalCid);
     data.SetAt(data_pos++, Smi::Handle(Smi::New(class_ids[i])));
   }
   ASSERT(!target.IsNull());
   data.SetAt(data_pos, target);
 }
 
 
 void ICData::AddReceiverCheck(intptr_t receiver_class_id,
                               const Function& target) const {
+#if defined(DEBUG)
+  GrowableArray<intptr_t> class_ids(1);
+  class_ids.Add(receiver_class_id);
+  ASSERT(!HasCheck(class_ids));
+#endif  // DEBUG
   ASSERT(num_args_tested() == 1);  // Otherwise use 'AddCheck'.
   ASSERT(receiver_class_id != kIllegalCid);
   ASSERT(!target.IsNull());
 
   const intptr_t old_num = NumberOfChecks();
   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();
@@ skipping 10 matching lines @@
   } else {
     data.SetAt(data_pos, Smi::Handle(Smi::New(receiver_class_id)));
     data.SetAt(data_pos + 1, target);
   }
 }
 
 
 void ICData::GetCheckAt(intptr_t index,
                         GrowableArray<intptr_t>* class_ids,
                         Function* target) const {
+  ASSERT(index < NumberOfChecks());
   ASSERT(class_ids != NULL);
   ASSERT(target != NULL);
   class_ids->Clear();
   const Array& data = Array::Handle(ic_data());
   intptr_t data_pos = index * TestEntryLength();
   Smi& smi = Smi::Handle();
   for (intptr_t i = 0; i < num_args_tested(); i++) {
     smi ^= data.At(data_pos++);
     class_ids->Add(smi.Value());
   }
   (*target) ^= data.At(data_pos);
 }
 
 
-void ICData::GetOneClassCheckAt(
-    int index, intptr_t* class_id, Function* target) const {
+void ICData::GetOneClassCheckAt(intptr_t index,
+                                intptr_t* class_id,
+                                Function* target) const {
   ASSERT(class_id != NULL);
   ASSERT(target != NULL);
   ASSERT(num_args_tested() == 1);
   const Array& data = Array::Handle(ic_data());
   intptr_t data_pos = index * TestEntryLength();
   Smi& smi = Smi::Handle();
   smi ^= data.At(data_pos);
   *class_id = smi.Value();
   *target ^= data.At(data_pos + 1);
 }
 
 
+intptr_t ICData::GetClassIdAt(intptr_t index, intptr_t arg_nr) const {
+  GrowableArray<intptr_t> class_ids;
+  Function& target = Function::Handle();
+  GetCheckAt(index, &class_ids, &target);
+  return class_ids[arg_nr];
+}
+
+
 intptr_t ICData::GetReceiverClassIdAt(intptr_t index) const {
   ASSERT(index < NumberOfChecks());
   const Array& data = Array::Handle(ic_data());
   const intptr_t data_pos = index * TestEntryLength();
   Smi& smi = Smi::Handle();
   smi ^= data.At(data_pos);
   return smi.Value();
 }
 
 
 RawFunction* ICData::GetTargetAt(intptr_t index) const {
   const Array& data = Array::Handle(ic_data());
   const intptr_t data_pos = index * TestEntryLength() + num_args_tested();
   Function& target = Function::Handle();
   target ^= data.At(data_pos);
   return target.raw();
 }
 
 
 RawFunction* ICData::GetTargetForReceiverClassId(intptr_t class_id) const {
   for (intptr_t i = 0; i < NumberOfChecks(); i++) {
     if (GetReceiverClassIdAt(i) == class_id) {
       return GetTargetAt(i);
     }
   }
   return Function::null();
 }
 
 
-RawICData* ICData::AsUnaryClassChecks() const {
+RawICData* ICData::AsUnaryClassChecksForArgNr(intptr_t arg_nr) const {
   ASSERT(!IsNull());
-  ASSERT(num_args_tested() > 0);
-  if (num_args_tested() == 1) return raw();
+  ASSERT(num_args_tested() > arg_nr);
+  if ((arg_nr == 0) && (num_args_tested() == 1)) {
+    // Frequent case.
+    return raw();
+  }
   const intptr_t kNumArgsTested = 1;
   ICData& result = ICData::Handle(ICData::New(
       Function::Handle(function()),
       String::Handle(target_name()),
       deopt_id(),
       kNumArgsTested));
   for (intptr_t i = 0; i < NumberOfChecks(); i++) {
-    const intptr_t class_id = GetReceiverClassIdAt(i);
+    const intptr_t class_id = GetClassIdAt(i, arg_nr);
     intptr_t duplicate_class_id = -1;
     for (intptr_t k = 0; k < result.NumberOfChecks(); k++) {
       if (class_id == result.GetReceiverClassIdAt(k)) {
         duplicate_class_id = k;
         break;
       }
     }
     if (duplicate_class_id >= 0) {
-      ASSERT(result.GetTargetAt(duplicate_class_id) == GetTargetAt(i));
+      // This check is valid only when checking the receiver.
+      ASSERT((arg_nr != 0) ||
+             (result.GetTargetAt(duplicate_class_id) == GetTargetAt(i)));
     } else {
       // This will make sure that Smi is first if it exists.
       result.AddReceiverCheck(class_id,
                               Function::Handle(GetTargetAt(i)));
     }
   }
   return result.raw();
 }
 
 
@@ skipping 4609 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart