Allow dispatch to use a range of Class-ids in tests

runtime/vm/intermediate_language_dbc.cc

 // Copyright (c) 2016, 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/globals.h"  // Needed here to get TARGET_ARCH_DBC.
 #if defined(TARGET_ARCH_DBC)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 229 matching lines @@
                  LocationSummary::kCall) {
   ASSERT(ic_data().NumArgsTested() == 1);
   const Array& arguments_descriptor = Array::Handle(ArgumentsDescriptor::New(
       instance_call()->ArgumentCount(), instance_call()->argument_names()));
   const intptr_t argdesc_kidx = __ AddConstant(arguments_descriptor);
 
   // Push the target onto the stack.
   if (with_checks()) {
     const intptr_t may_be_smi =
         (ic_data().GetReceiverClassIdAt(0) == kSmiCid) ? 1 : 0;
-    GrowableArray<CidTarget> sorted_ic_data;
+    GrowableArray<CidRangeTarget> sorted_ic_data;
     FlowGraphCompiler::SortICDataByCount(ic_data(), &sorted_ic_data,
                                          /* drop_smi = */ true);
     const intptr_t sorted_length = sorted_ic_data.length();
     if (!Utils::IsUint(8, sorted_length)) {
       Unsupported(compiler);
       UNREACHABLE();
     }
-    __ PushPolymorphicInstanceCall(instance_call()->ArgumentCount(),
-                                   sorted_length + may_be_smi);
+    bool using_ranges = false;
+    for (intptr_t i = 0; i < sorted_length; i++) {
+      if (sorted_ic_data[i].cid_start != sorted_ic_data[i].cid_end) {
+        using_ranges = true;
+        break;
+      }
+    }
+
+    if (using_ranges) {
+      __ PushPolymorphic3InstanceCall(instance_call()->ArgumentCount(),
+                                      sorted_length + may_be_smi);
+    } else {
+      __ PushPolymorphicInstanceCall(instance_call()->ArgumentCount(),
+                                     sorted_length + may_be_smi);
+    }
     if (may_be_smi == 1) {
       const Function& target =
           Function::ZoneHandle(compiler->zone(), ic_data().GetTargetAt(0));
       __ Nop(compiler->ToEmbeddableCid(kSmiCid, this));
+      if (using_ranges) {
+        __ Nop(compiler->ToEmbeddableCid(1, this));
+      }
       __ Nop(__ AddConstant(target));
     }
     for (intptr_t i = 0; i < sorted_length; i++) {
       const Function& target = *sorted_ic_data[i].target;
-      __ Nop(compiler->ToEmbeddableCid(sorted_ic_data[i].cid, this));
+      intptr_t cid_start = sorted_ic_data[i].cid_start;
+      intptr_t cid_end = sorted_ic_data[i].cid_end;
+
+      __ Nop(compiler->ToEmbeddableCid(cid_start, this));
+      if (using_ranges) {
+        __ Nop(compiler->ToEmbeddableCid(1 + cid_end - cid_start, this));
+      }
       __ Nop(__ AddConstant(target));
     }
     compiler->EmitDeopt(deopt_id(),
                         ICData::kDeoptPolymorphicInstanceCallTestFail, 0);
   } else {
     ASSERT(ic_data().HasOneTarget());
     const Function& target = Function::ZoneHandle(ic_data().GetTargetAt(0));
     __ PushConstant(target);
   }
 
@@ skipping 1182 matching lines @@
       ASSERT(cids_[0] < cids_[cids_.length() - 1]);
       cid_mask = ComputeCidMask();
       is_dense_switch = Smi::IsValid(cid_mask);
     }
     if (is_dense_switch) {
       const intptr_t low_cid = cids_[0];
       __ CheckDenseSwitch(value, may_be_smi);
       __ Nop(compiler->ToEmbeddableCid(low_cid, this));
       __ Nop(__ AddConstant(Smi::Handle(Smi::New(cid_mask))));
     } else {
-      GrowableArray<CidTarget> sorted_ic_data;
+      GrowableArray<CidRangeTarget> sorted_ic_data;
       FlowGraphCompiler::SortICDataByCount(unary_checks(), &sorted_ic_data,
                                            /* drop_smi = */ true);
       const intptr_t sorted_length = sorted_ic_data.length();
+
+      bool using_ranges = false;

[Vyacheslav Egorov (Google), 2017/03/10 10:31:30]

Actually we could be smarter about using ranges on DBC, e.g. 

[1, 2], [5, 5], [10 , 10]

are better represented as 

1, 2, 5, 10

then range based call. 

[erikcorry, 2017/03/10 13:30:01]

It really depends on the frequency with which we have seen 1, 2, 5 and 10.  I
don't have a good idea right now for how to best choose between the two.

+      for (intptr_t i = 0; i < sorted_length; i++) {
+        if (sorted_ic_data[i].cid_start != sorted_ic_data[i].cid_end) {
+          using_ranges = true;
+          break;
+        }
+      }
+
       if (!Utils::IsUint(8, sorted_length)) {
         Unsupported(compiler);
         UNREACHABLE();
       }
-      __ CheckCids(value, may_be_smi, sorted_length);
+      if (using_ranges) {
+        __ CheckCids2(value, may_be_smi, sorted_length * 2);
+      } else {
+        __ CheckCids(value, may_be_smi, sorted_length);
+      }
       for (intptr_t i = 0; i < sorted_length; i++) {
-        __ Nop(compiler->ToEmbeddableCid(sorted_ic_data[i].cid, this));
+        intptr_t cid_start = sorted_ic_data[i].cid_start;
+        intptr_t cid_end = sorted_ic_data[i].cid_end;
+        __ Nop(compiler->ToEmbeddableCid(cid_start, this));
+        if (using_ranges) {
+          __ Nop(compiler->ToEmbeddableCid(1 + cid_end - cid_start, this));
+        }
       }
     }
   }
   compiler->EmitDeopt(deopt_id(), ICData::kDeoptCheckClass,
                       licm_hoisted_ ? ICData::kHoisted : 0);
 }
 
 
 EMIT_NATIVE_CODE(BinarySmiOp, 2, Location::RequiresRegister()) {
   const Register left = locs()->in(0).reg();
@@ skipping 518 matching lines @@
   }
   __ IfULe(length, index);
   compiler->EmitDeopt(deopt_id(), ICData::kDeoptCheckArrayBound,
                       (generalized_ ? ICData::kGeneralized : 0) |
                           (licm_hoisted_ ? ICData::kHoisted : 0));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC