Cleanup: Make CheckClassId instruction more general so it

runtime/vm/intermediate_language.cc

 // Copyright (c) 2013, 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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/bootstrap.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
@@ skipping 126 matching lines @@
 }
 
 
 bool Value::Equals(Value* other) const {
   return definition() == other->definition();
 }
 
 
 static int OrderById(CidRange* const* a, CidRange* const* b) {
   // Negative if 'a' should sort before 'b'.
-  ASSERT((*a)->cid_start == (*a)->cid_end);
-  ASSERT((*b)->cid_start == (*b)->cid_end);
+  ASSERT((*a)->IsSingleCid());
+  ASSERT((*b)->IsSingleCid());
   return (*a)->cid_start - (*b)->cid_start;
 }
 
 
 static int OrderByFrequency(CidRange* const* a, CidRange* const* b) {
   const TargetInfo* target_info_a = static_cast<const TargetInfo*>(*a);
   const TargetInfo* target_info_b = static_cast<const TargetInfo*>(*b);
   // Negative if 'a' should sort before 'b'.
   return target_info_b->count - target_info_a->count;
 }
@@ skipping 37 matching lines @@
   intptr_t max = -1;
   for (intptr_t i = 0; i < cid_ranges_.length(); ++i) {
     max = Utils::Maximum(max, cid_ranges_[i]->cid_end);
   }
   return max;
 }
 
 
 bool Cids::HasClassId(intptr_t cid) const {
   for (int i = 0; i < length(); i++) {
-    if (cid_ranges_[i]->cid_start <= cid && cid <= cid_ranges_[i]->cid_end) {
+    if (cid_ranges_[i]->Contains(cid)) {
       return true;
     }
   }
   return false;
 }
 
 
 Cids* Cids::CreateMonomorphic(Zone* zone, intptr_t cid) {
   Cids* cids = new (zone) Cids(zone);
   cids->Add(new (zone) CidRange(cid, cid));
@@ skipping 53 matching lines @@
                           TargetInfo(id, id, &function, ic_data.GetCountAt(i)));
     } else {
       cid_ranges_.Add(new (zone) CidRange(id, id));
     }
   }
 }
 
 
 bool Cids::IsMonomorphic() const {
   if (length() != 1) return false;
-  return cid_ranges_[0]->cid_start == cid_ranges_[0]->cid_end;
+  return cid_ranges_[0]->IsSingleCid();
 }
 
 
 intptr_t Cids::MonomorphicReceiverCid() const {
   ASSERT(IsMonomorphic());
   return cid_ranges_[0]->cid_start;
 }
 
 
 CheckClassInstr::CheckClassInstr(Value* value,
                                  intptr_t deopt_id,
                                  const Cids& cids,
                                  TokenPosition token_pos)
     : TemplateInstruction(deopt_id),
       cids_(cids),
       licm_hoisted_(false),
       is_bit_test_(IsCompactCidRange(cids)),
       token_pos_(token_pos) {
   // Expected useful check data.
   const intptr_t number_of_checks = cids.length();
   ASSERT(number_of_checks > 0);
   SetInputAt(0, value);
   // Otherwise use CheckSmiInstr.
-  ASSERT(number_of_checks != 1 || cids[0].cid_start != cids[0].cid_end ||
+  ASSERT(number_of_checks != 1 || !cids[0].IsSingleCid() ||
          cids[0].cid_start != kSmiCid);
 }
 
 
 bool CheckClassInstr::AttributesEqual(Instruction* other) const {
   CheckClassInstr* other_check = other->AsCheckClass();
   ASSERT(other_check != NULL);
   return cids().Equals(other_check->cids());
 }
 
 
 EffectSet CheckClassInstr::Dependencies() const {
   // Externalization of strings via the API can change the class-id.
   return cids_.ContainsExternalizableCids() ? EffectSet::Externalization()
                                             : EffectSet::None();
 }
 
 
 EffectSet CheckClassIdInstr::Dependencies() const {
   // Externalization of strings via the API can change the class-id.
-  return Field::IsExternalizableCid(cid_) ? EffectSet::Externalization()
-                                          : EffectSet::None();
+  for (intptr_t i = cids_.cid_start; i <= cids_.cid_end; i++) {
+    if (Field::IsExternalizableCid(i)) return EffectSet::Externalization();
+  }
+  return EffectSet::None();
 }
 
 
 bool CheckClassInstr::IsDeoptIfNull() const {
   if (!cids().IsMonomorphic()) {
     return false;
   }
   CompileType* in_type = value()->Type();
   const intptr_t cid = cids().MonomorphicReceiverCid();
   // Performance check: use CheckSmiInstr instead.
@@ skipping 32 matching lines @@
 bool CheckClassInstr::IsBitTest() const {
   return is_bit_test_;
 }
 
 
 intptr_t CheckClassInstr::ComputeCidMask() const {
   ASSERT(IsBitTest());
   intptr_t min = cids_.ComputeLowestCid();
   intptr_t mask = 0;
   for (intptr_t i = 0; i < cids_.length(); ++i) {
-    intptr_t cid_start = cids_[i].cid_start;
-    intptr_t cid_end = cids_[i].cid_end;
     intptr_t run;
-    uintptr_t range = 1ul + cid_end - cid_start;
+    uintptr_t range = 1ul + cids_[i].Extent();
     if (range >= kBitsPerWord) {
       run = -1;
     } else {
       run = (1 << range) - 1;
     }
-    mask |= run << (cid_start - min);
+    mask |= run << (cids_[i].cid_start - min);
   }
   return mask;
 }
 
 
 bool LoadFieldInstr::IsUnboxedLoad() const {
   return FLAG_unbox_numeric_fields && (field() != NULL) &&
          FlowGraphCompiler::IsUnboxedField(*field());
 }
 
@@ skipping 2282 matching lines @@
     return this;
   }
 
   return cids().HasClassId(value_cid) ? NULL : this;
 }
 
 
 Instruction* CheckClassIdInstr::Canonicalize(FlowGraph* flow_graph) {
   if (value()->BindsToConstant()) {
     const Object& constant_value = value()->BoundConstant();
-    if (constant_value.IsSmi() && Smi::Cast(constant_value).Value() == cid_) {
+    if (constant_value.IsSmi() &&
+        cids_.Contains(Smi::Cast(constant_value).Value())) {
       return NULL;
     }
   }
   return this;
 }
 
 
 Definition* TestCidsInstr::Canonicalize(FlowGraph* flow_graph) {
   CompileType* in_type = left()->Type();
   intptr_t cid = in_type->ToCid();
@@ skipping 1606 matching lines @@
                      "native function '%s' (%" Pd " arguments) cannot be found",
                      native_name().ToCString(), function().NumParameters());
   }
   set_is_auto_scope(auto_setup_scope);
   set_native_c_function(native_function);
 }
 
 #undef __
 
 }  // namespace dart