Cleanup: Make CheckClassId instruction more general so it

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 234 matching lines @@
 
   // Push the target onto the stack.
   if (with_checks()) {
     const intptr_t length = targets_.length();
     if (!Utils::IsUint(8, length)) {
       Unsupported(compiler);
       UNREACHABLE();
     }
     bool using_ranges = false;
     for (intptr_t i = 0; i < length; i++) {
-      if (targets_[i].cid_start != targets_[i].cid_end) {
+      if (!targets_[i].IsSingleCid()) {
         using_ranges = true;
         break;
       }
     }
 
     if (using_ranges) {
       __ PushPolymorphicInstanceCallByRange(instance_call()->ArgumentCount(),
                                             length);
     } else {
       __ PushPolymorphicInstanceCall(instance_call()->ArgumentCount(), length);
     }
     for (intptr_t i = 0; i < length; i++) {
       const Function& target = *targets_.TargetAt(i)->target;
-      intptr_t cid_start = targets_[i].cid_start;
-      intptr_t cid_end = targets_[i].cid_end;
 
-      __ Nop(compiler->ToEmbeddableCid(cid_start, this));
+      __ Nop(compiler->ToEmbeddableCid(targets_[i].cid_start, this));
       if (using_ranges) {
-        __ Nop(compiler->ToEmbeddableCid(1 + cid_end - cid_start, this));
+        __ Nop(compiler->ToEmbeddableCid(1 + targets_[i].Extent(), this));
       }
       __ Nop(__ AddConstant(target));
     }
     compiler->EmitDeopt(deopt_id(),
                         ICData::kDeoptPolymorphicInstanceCallTestFail, 0);
   } else {
     ASSERT(targets().HasSingleTarget());
     const Function& target = targets().FirstTarget();
     __ PushConstant(target);
   }
@@ skipping 1198 matching lines @@
 EMIT_NATIVE_CODE(CheckEitherNonSmi, 2) {
   const Register left = locs()->in(0).reg();
   const Register right = locs()->in(1).reg();
   __ CheckEitherNonSmi(left, right);
   compiler->EmitDeopt(deopt_id(), ICData::kDeoptBinaryDoubleOp,
                       licm_hoisted_ ? ICData::kHoisted : 0);
 }
 
 
 EMIT_NATIVE_CODE(CheckClassId, 1) {
-  __ CheckClassId(locs()->in(0).reg(), compiler->ToEmbeddableCid(cid_, this));
+  if (cids_.IsSingleCid()) {
+    __ CheckClassId(locs()->in(0).reg(),
+                    compiler->ToEmbeddableCid(cids_.cid_start, this));
+  } else {
+    __ CheckClassIdRange(locs()->in(0).reg(),
+                         compiler->ToEmbeddableCid(cids_.cid_start, this));
+    __ Nop(__ AddConstant(Smi::Handle(Smi::New(cids_.Extent()))));
+  }
   compiler->EmitDeopt(deopt_id(), ICData::kDeoptCheckClass);
 }
 
 
 EMIT_NATIVE_CODE(CheckClass, 1) {
   const Register value = locs()->in(0).reg();
   if (IsNullCheck()) {
     ASSERT(IsDeoptIfNull() || IsDeoptIfNotNull());
     if (IsDeoptIfNull()) {
       __ IfEqNull(value);
@@ skipping 12 matching lines @@
     if (is_bit_test) {
       intptr_t min = cids_.ComputeLowestCid();
       __ CheckBitTest(value, may_be_smi);
       __ Nop(compiler->ToEmbeddableCid(min, this));
       __ Nop(__ AddConstant(Smi::Handle(Smi::New(cid_mask))));
     } else {
       bool using_ranges = false;
       int smi_adjustment = 0;
       int length = cids_.length();
       for (intptr_t i = 0; i < length; i++) {
-        if (cids_[i].cid_start != cids_[i].cid_end) {
+        if (!cids_[i].IsSingleCid()) {
           using_ranges = true;
         } else if (cids_[i].cid_start == kSmiCid) {
           ASSERT(cids_[i].cid_end == kSmiCid);  // We are in the else clause.
           ASSERT(smi_adjustment == 0);
           smi_adjustment = 1;
         }
       }
 
       if (!Utils::IsUint(8, length)) {
         Unsupported(compiler);
         UNREACHABLE();
       }
       if (using_ranges) {
         __ CheckCidsByRange(value, may_be_smi, (length - smi_adjustment) * 2);
       } else {
         __ CheckCids(value, may_be_smi, length - smi_adjustment);
       }
       for (intptr_t i = 0; i < length; i++) {
         intptr_t cid_start = cids_[i].cid_start;
         intptr_t cid_end = cids_[i].cid_end;
         if (cid_start == kSmiCid && cid_end == kSmiCid) {
           ASSERT(smi_adjustment == 1);
           continue;
         }
         __ Nop(compiler->ToEmbeddableCid(cid_start, this));
         if (using_ranges) {
-          __ Nop(compiler->ToEmbeddableCid(1 + cid_end - cid_start, this));
+          __ Nop(compiler->ToEmbeddableCid(1 + cids_[i].Extent(), this));
         }
       }
     }
   }
   compiler->EmitDeopt(deopt_id(), ICData::kDeoptCheckClass,
                       licm_hoisted_ ? ICData::kHoisted : 0);
 }
 
 
 EMIT_NATIVE_CODE(BinarySmiOp, 2, Location::RequiresRegister()) {
@@ skipping 519 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