Remove non-trivial subtyping between bitset and non-bitset types.

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 {
 namespace internal {
 
 // -----------------------------------------------------------------------------
 // Glb and lub computation.
 
 // The largest bitset subsumed by this type.
 template<class Config>
 int TypeImpl<Config>::BitsetType::Glb(TypeImpl* type) {
   DisallowHeapAllocation no_allocation;
   if (type->IsBitset()) {
     return type->AsBitset();
   } else if (type->IsUnion()) {
     UnionHandle unioned = handle(type->AsUnion());
     int bitset = kNone;
     for (int i = 0; i < unioned->Length(); ++i) {

[rossberg, 2014/08/05 15:07:53]

You don't need this loop anymore: only the first element can be non-None.

[neis, 2014/08/05 17:01:10]

Good point.

       bitset |= unioned->Get(i)->BitsetGlb();
     }
     return bitset;
-  } else if (type->IsClass()) {
-    // Little hack to avoid the need for a region for handlification here...
-    return REPRESENTATION(Config::is_class(type)
-        ? Lub(*Config::as_class(type))
-        : type->AsClass()->Bound(NULL)->AsBitset());
-  } else if (type->IsConstant()) {
-    return REPRESENTATION(type->AsConstant()->Bound()->AsBitset());
-  } else if (type->IsContext()) {
-    return REPRESENTATION(type->AsContext()->Bound()->AsBitset());
-  } else if (type->IsArray()) {
-    return REPRESENTATION(type->AsArray()->Bound()->AsBitset());
-  } else if (type->IsFunction()) {
-    return REPRESENTATION(type->AsFunction()->Bound()->AsBitset());
   } else {
-    UNREACHABLE();
     return kNone;
   }
 }
 
 
 // The smallest bitset subsuming this type.
 template<class Config>
 int TypeImpl<Config>::BitsetType::Lub(TypeImpl* type) {
   DisallowHeapAllocation no_allocation;
   if (type->IsBitset()) {
@@ skipping 199 matching lines @@
 // 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::Is(BitsetType::Lub(this), that->AsBitset());
   }
-  if (this->IsBitset() && SEMANTIC(this->AsBitset()) == BitsetType::kNone) {
-    // Bitsets only have non-bitset supertypes along the representation axis.
-    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()) {
     return this->IsConstant()
@@ skipping 271 matching lines @@
         if (new_bound == type_i_bound) return size;
       }
       if (new_bound != old_bound) type = type->Rebound(new_bound, region);
       result->Set(i, type);
     }
   }
   return size;
 }
 
 
-// If bitset is subsumed by another entry in the result, remove it.
-// (Only bitsets with empty semantic axis can be subtypes of non-bitsets.)
-template<class Config>
-int TypeImpl<Config>::NormalizeUnion(UnionHandle result, int size, int bitset) {
-  if (bitset != BitsetType::kNone && SEMANTIC(bitset) == BitsetType::kNone) {
-    for (int i = 1; i < size; ++i) {
-      int glb = result->Get(i)->BitsetGlb();
-      if (BitsetType::Is(bitset, glb)) {
-        for (int j = 1; j < size; ++j) {
-          result->Set(j - 1, result->Get(j));
-        }
-        --size;
-        break;
-      }
-    }
-  }
-  return size;
-}
-
-
 // Union is O(1) on simple bitsets, but O(n*m) on structured unions.
 template<class Config>
 typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::Union(
     TypeHandle type1, TypeHandle type2, Region* region) {
   // Fast case: bit sets.
   if (type1->IsBitset() && type2->IsBitset()) {
     return BitsetType::New(type1->AsBitset() | type2->AsBitset(), region);
   }
 
   // Fast case: top or bottom types.
@@ skipping 18 matching lines @@
   if (bitset != BitsetType::kNone) ++size;
   DCHECK(size >= 1);
 
   UnionHandle unioned = UnionType::New(size, region);
   size = 0;
   if (bitset != BitsetType::kNone) {
     unioned->Set(size++, BitsetType::New(bitset, region));
   }
   size = ExtendUnion(unioned, size, type1, type2, false, region);
   size = ExtendUnion(unioned, size, type2, type1, false, region);
-  size = NormalizeUnion(unioned, size, bitset);
 
   if (size == 1) {
     return unioned->Get(0);
   } else {
     unioned->Shrink(size);
     DCHECK(unioned->Wellformed());
     return unioned;
   }
 }
 
@@ skipping 29 matching lines @@
   if (bitset != BitsetType::kNone) ++size;
   DCHECK(size >= 1);
 
   UnionHandle unioned = UnionType::New(size, region);
   size = 0;
   if (bitset != BitsetType::kNone) {
     unioned->Set(size++, BitsetType::New(bitset, region));
   }
   size = ExtendUnion(unioned, size, type1, type2, true, region);
   size = ExtendUnion(unioned, size, type2, type1, true, region);
-  size = NormalizeUnion(unioned, size, bitset);
 
   if (size == 0) {
     return None(region);
   } else if (size == 1) {
     return unioned->Get(0);
   } else {
     unioned->Shrink(size);
     DCHECK(unioned->Wellformed());
     return unioned;
   }
@@ skipping 283 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