Remove unnecesssary auxiliary definitions.

src/types.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/types.h"
 
 #include "src/ostreams.h"
 #include "src/types-inl.h"
 
 namespace v8 {
@@ skipping 230 matching lines @@
 // Predicates.
 
 // Check this <= that.
 template<class Config>
 bool TypeImpl<Config>::SlowIs(TypeImpl* that) {
   DisallowHeapAllocation no_allocation;
 
   // Fast path for bitsets.
   if (this->IsNone()) return true;
   if (that->IsBitset()) {
-    return (BitsetType::Lub(this) | that->AsBitset()) == that->AsBitset();
+    return BitsetType::Is(BitsetType::Lub(this), that->AsBitset());
   }
   if (this->IsBitset() && SEMANTIC(this->AsBitset()) == BitsetType::kNone) {
     // Bitsets only have non-bitset supertypes along the representation axis.
-    int that_bitset = that->BitsetGlb();
-    return (BitsetType::Is(this->AsBitset(), that_bitset));
+    return BitsetType::Is(this->AsBitset(), that->BitsetGlb());
   }
 
   if (that->IsClass()) {
     return this->IsClass()
         && *this->AsClass()->Map() == *that->AsClass()->Map()
         && ((Config::is_class(that) && Config::is_class(this)) ||
             BitsetType::New(this->BitsetLub())->Is(
                 BitsetType::New(that->BitsetLub())));
   }
   if (that->IsConstant()) {
@@ skipping 212 matching lines @@
 }
 
 
 template<class Config>
 int TypeImpl<Config>::IndexInUnion(
     int bound, UnionHandle unioned, int current_size) {
   DCHECK(!this->IsUnion());
   for (int i = 0; i < current_size; ++i) {
     TypeHandle that = unioned->Get(i);
     if (that->IsBitset()) {
-      if ((bound | that->AsBitset()) == that->AsBitset()) return i;
+      if (BitsetType::Is(bound, that->AsBitset())) return i;
     } else if (that->IsClass() && this->IsClass()) {
       if (*this->AsClass()->Map() == *that->AsClass()->Map()) return i;
     } else if (that->IsConstant() && this->IsConstant()) {
       if (*this->AsConstant()->Value() == *that->AsConstant()->Value())
         return i;
     } else if (that->IsContext() && this->IsContext()) {
       if (this->Is(that)) return i;
     } else if (that->IsArray() && this->IsArray()) {
       if (this->Is(that)) return i;
     } else if (that->IsFunction() && this->IsFunction()) {
       if (this->Is(that)) return i;
     }
   }
   return -1;
 }
 
 
 // Get non-bitsets from type, bounded by upper.
 // Store at result starting at index. Returns updated index.
 template<class Config>
 int TypeImpl<Config>::ExtendUnion(
     UnionHandle result, int size, TypeHandle type,
     TypeHandle other, bool is_intersect, Region* region) {
-  int old_size = size;
   if (type->IsUnion()) {
     UnionHandle unioned = handle(type->AsUnion());
     for (int i = 0; i < unioned->Length(); ++i) {
       TypeHandle type_i = unioned->Get(i);
       DCHECK(i == 0 || !(type_i->IsBitset() || type_i->Is(unioned->Get(0))));
       if (!type_i->IsBitset()) {
         size = ExtendUnion(result, size, type_i, other, is_intersect, region);
       }
     }
   } else if (!type->IsBitset()) {
     DCHECK(type->IsClass() || type->IsConstant() ||
            type->IsArray() || type->IsFunction() || type->IsContext());
     int inherent_bound = type->InherentBitsetLub();
     int old_bound = type->BitsetLub();
     int other_bound = type->BoundBy(other->unhandle()) & inherent_bound;
     int new_bound =
         is_intersect ? (old_bound & other_bound) : (old_bound | other_bound);
     if (new_bound != BitsetType::kNone) {
-      int i = type->IndexInUnion(new_bound, result, old_size);
+      int i = type->IndexInUnion(new_bound, result, size);
       if (i == -1) {
         i = size++;
       } else if (result->Get(i)->IsBitset()) {
         return size;  // Already fully subsumed.
       } else {
         int type_i_bound = result->Get(i)->BitsetLub();
         new_bound |= type_i_bound;
         if (new_bound == type_i_bound) return size;
       }
       if (new_bound != old_bound) type = type->Rebound(new_bound, region);
@@ skipping 338 matching lines @@
 
 
 template <class Config>
 void TypeImpl<Config>::PrintTo(OStream& os, PrintDimension dim) {  // NOLINT
   DisallowHeapAllocation no_allocation;
   if (dim != REPRESENTATION_DIM) {
     if (this->IsBitset()) {
       BitsetType::Print(os, SEMANTIC(this->AsBitset()));
     } else if (this->IsClass()) {
       os << "Class(" << static_cast<void*>(*this->AsClass()->Map()) << " < ";
-      return BitsetType::New(BitsetType::Lub(this))->PrintTo(os, dim);
+      BitsetType::New(BitsetType::Lub(this))->PrintTo(os, dim);
       os << ")";
     } else if (this->IsConstant()) {
       os << "Constant(" << static_cast<void*>(*this->AsConstant()->Value())
          << " : ";
       BitsetType::New(BitsetType::Lub(this))->PrintTo(os, dim);
       os << ")";
     } else if (this->IsRange()) {
       os << "Range(" << this->AsRange()->Min()
          << ".." << this->AsRange()->Max() << " : ";
       BitsetType::New(BitsetType::Lub(this))->PrintTo(os, dim);
@@ skipping 50 matching lines @@
 template class TypeImpl<HeapTypeConfig>::Iterator<i::Object>;
 
 template TypeImpl<ZoneTypeConfig>::TypeHandle
   TypeImpl<ZoneTypeConfig>::Convert<HeapType>(
     TypeImpl<HeapTypeConfig>::TypeHandle, TypeImpl<ZoneTypeConfig>::Region*);
 template TypeImpl<HeapTypeConfig>::TypeHandle
   TypeImpl<HeapTypeConfig>::Convert<Type>(
     TypeImpl<ZoneTypeConfig>::TypeHandle, TypeImpl<HeapTypeConfig>::Region*);
 
 } }  // namespace v8::internal