[turbofan] Nuke class 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 <iomanip>
 
 #include "src/types.h"
 
 #include "src/handles-inl.h"
 #include "src/ostreams.h"
@@ skipping 126 matching lines @@
   if (type->IsUnion()) {
     // Take the representation from the first element, which is always
     // a bitset.
     int bitset = type->AsUnion()->Get(0)->BitsetLub();
     for (int i = 0, n = type->AsUnion()->Length(); i < n; ++i) {
       // Other elements only contribute their semantic part.
       bitset |= SEMANTIC(type->AsUnion()->Get(i)->BitsetLub());
     }
     return bitset;
   }
-  if (type->IsClass()) return type->AsClass()->Lub();
   if (type->IsConstant()) return type->AsConstant()->Lub();
   if (type->IsRange()) return type->AsRange()->Lub();
   if (type->IsContext()) return kOtherInternal & kTaggedPointer;
   if (type->IsArray()) return kOtherObject;
   if (type->IsFunction()) return kFunction;
   if (type->IsTuple()) return kOtherInternal;
   UNREACHABLE();
   return kNone;
 }
 
@@ skipping 244 matching lines @@
   if (mz) return 0;
   return std::numeric_limits<double>::quiet_NaN();
 }
 
 
 // -----------------------------------------------------------------------------
 // Predicates.
 
 bool Type::SimplyEquals(Type* that) {
   DisallowHeapAllocation no_allocation;
-  if (this->IsClass()) {
-    return that->IsClass()
-        && *this->AsClass()->Map() == *that->AsClass()->Map();
-  }
   if (this->IsConstant()) {
     return that->IsConstant()
         && *this->AsConstant()->Value() == *that->AsConstant()->Value();
   }
   if (this->IsContext()) {
     return that->IsContext()
         && this->AsContext()->Outer()->Equals(that->AsContext()->Outer());
   }
   if (this->IsArray()) {
     return that->IsArray()
@@ skipping 91 matching lines @@
   if (that->IsRange()) {
     return (this->IsRange() && Contains(that->AsRange(), this->AsRange())) ||
            (this->IsConstant() &&
             Contains(that->AsRange(), this->AsConstant()));
   }
   if (this->IsRange()) return false;
 
   return this->SimplyEquals(that);
 }
 
-// Most precise _current_ type of a value (usually its class).
-Type* Type::NowOf(i::Object* value, Zone* zone) {
-  if (value->IsSmi() ||
-      i::HeapObject::cast(value)->map()->instance_type() == HEAP_NUMBER_TYPE) {
-    return Of(value, zone);
-  }
-  return Class(i::handle(i::HeapObject::cast(value)->map()), zone);
-}
-
-bool Type::NowContains(i::Object* value) {
-  DisallowHeapAllocation no_allocation;
-  if (this->IsAny()) return true;
-  if (value->IsHeapObject()) {
-    i::Map* map = i::HeapObject::cast(value)->map();
-    for (Iterator<i::Map> it = this->Classes(); !it.Done(); it.Advance()) {
-      if (*it.Current() == map) return true;
-    }
-  }
-  return this->Contains(value);
-}
-
-bool Type::NowIs(Type* that) {
-  DisallowHeapAllocation no_allocation;
-
-  // TODO(rossberg): this is incorrect for
-  //   Union(Constant(V), T)->NowIs(Class(M))
-  // but fuzzing does not cover that!
-  if (this->IsConstant()) {
-    i::Object* object = *this->AsConstant()->Value();
-    if (object->IsHeapObject()) {
-      i::Map* map = i::HeapObject::cast(object)->map();
-      for (Iterator<i::Map> it = that->Classes(); !it.Done(); it.Advance()) {
-        if (*it.Current() == map) return true;
-      }
-    }
-  }
-  return this->Is(that);
-}
-
-
-// Check if [this] contains only (currently) stable classes.
-bool Type::NowStable() {
-  DisallowHeapAllocation no_allocation;
-  return !this->IsClass() || this->AsClass()->Map()->is_stable();
-}
-
 
 // Check if [this] and [that] overlap.
 bool Type::Maybe(Type* that) {
   DisallowHeapAllocation no_allocation;
 
   // Take care of the representation part (and also approximate
   // the semantic part).
   if (!BitsetType::IsInhabited(this->BitsetLub() & that->BitsetLub()))
     return false;
 
@@ skipping 17 matching lines @@
       if (this->SemanticMaybe(that->AsUnion()->Get(i))) return true;
     }
     return false;
   }
 
   if (!BitsetType::SemanticIsInhabited(this->BitsetLub() & that->BitsetLub()))
     return false;
 
   if (this->IsBitset() && that->IsBitset()) return true;
 
-  if (this->IsClass() != that->IsClass()) return true;
-
   if (this->IsRange()) {
     if (that->IsConstant()) {
       return Contains(this->AsRange(), that->AsConstant());
     }
     if (that->IsRange()) {
       return Overlap(this->AsRange(), that->AsRange());
     }
     if (that->IsBitset()) {
       bitset number_bits = BitsetType::NumberBits(that->AsBitset());
       if (number_bits == BitsetType::kNone) {
@@ skipping 201 matching lines @@
 
   if (lhs->IsRange()) {
     if (rhs->IsBitset()) {
       RangeType::Limits lim = IntersectRangeAndBitset(lhs, rhs, zone);
 
       if (!lim.IsEmpty()) {
         *lims = RangeType::Limits::Union(lim, *lims);
       }
       return size;
     }
-    if (rhs->IsClass()) {
-      *lims =
-          RangeType::Limits::Union(RangeType::Limits(lhs->AsRange()), *lims);
-    }
     if (rhs->IsConstant() && Contains(lhs->AsRange(), rhs->AsConstant())) {
       return AddToUnion(rhs, result, size, zone);
     }
     if (rhs->IsRange()) {
       RangeType::Limits lim = RangeType::Limits::Intersect(
           RangeType::Limits(lhs->AsRange()), RangeType::Limits(rhs->AsRange()));
       if (!lim.IsEmpty()) {
         *lims = RangeType::Limits::Union(lim, *lims);
       }
     }
     return size;
   }
   if (rhs->IsRange()) {
     // This case is handled symmetrically above.
     return IntersectAux(rhs, lhs, result, size, lims, zone);
   }
   if (lhs->IsBitset() || rhs->IsBitset()) {
     return AddToUnion(lhs->IsBitset() ? rhs : lhs, result, size, zone);
   }
-  if (lhs->IsClass() != rhs->IsClass()) {
-    return AddToUnion(lhs->IsClass() ? rhs : lhs, result, size, zone);
-  }
   if (lhs->SimplyEquals(rhs)) {
     return AddToUnion(lhs, result, size, zone);
   }
   return size;
 }
 
 
 // Make sure that we produce a well-formed range and bitset:
 // If the range is non-empty, the number bits in the bitset should be
 // clear. Moreover, if we have a canonical range (such as Signed32),
@@ skipping 155 matching lines @@
 
 // static
 Type* Type::Semantic(Type* t, Zone* zone) {
   return Intersect(t, BitsetType::New(BitsetType::kSemantic), zone);
 }
 
 
 // -----------------------------------------------------------------------------
 // Iteration.
 
-int Type::NumClasses() {
-  DisallowHeapAllocation no_allocation;
-  if (this->IsClass()) {
-    return 1;
-  } else if (this->IsUnion()) {
-    int result = 0;
-    for (int i = 0, n = this->AsUnion()->Length(); i < n; ++i) {
-      if (this->AsUnion()->Get(i)->IsClass()) ++result;
-    }
-    return result;
-  } else {
-    return 0;
-  }
-}
-
 int Type::NumConstants() {
   DisallowHeapAllocation no_allocation;
   if (this->IsConstant()) {
     return 1;
   } else if (this->IsUnion()) {
     int result = 0;
     for (int i = 0, n = this->AsUnion()->Length(); i < n; ++i) {
       if (this->AsUnion()->Get(i)->IsConstant()) ++result;
     }
     return result;
@@ skipping 11 matching lines @@
 
 // C++ cannot specialise nested templates, so we have to go through this
 // contortion with an auxiliary template to simulate it.
 template <class T>
 struct TypeImplIteratorAux {
   static bool matches(Type* type);
   static i::Handle<T> current(Type* type);
 };
 
 template <>
-struct TypeImplIteratorAux<i::Map> {
-  static bool matches(Type* type) { return type->IsClass(); }
-  static i::Handle<i::Map> current(Type* type) {
-    return type->AsClass()->Map();
-  }
-};
-
-template <>
 struct TypeImplIteratorAux<i::Object> {
   static bool matches(Type* type) { return type->IsConstant(); }
   static i::Handle<i::Object> current(Type* type) {
     return type->AsConstant()->Value();
   }
 };
 
 template <class T>
 bool Type::Iterator<T>::matches(Type* type) {
   return TypeImplIteratorAux<T>::matches(type);
@@ skipping 76 matching lines @@
   }
   DCHECK(bits == 0);
   os << ")";
 }
 
 void Type::PrintTo(std::ostream& os, PrintDimension dim) {
   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()) << " < ";
-      BitsetType::New(BitsetType::Lub(this))->PrintTo(os, dim);
-      os << ")";
     } else if (this->IsConstant()) {
       os << "Constant(" << Brief(*this->AsConstant()->Value()) << ")";
     } else if (this->IsRange()) {
       std::ostream::fmtflags saved_flags = os.setf(std::ios::fixed);
       std::streamsize saved_precision = os.precision(0);
       os << "Range(" << this->AsRange()->Min() << ", " << this->AsRange()->Max()
          << ")";
       os.flags(saved_flags);
       os.precision(saved_precision);
     } else if (this->IsContext()) {
@@ skipping 57 matching lines @@
 #endif
 
 BitsetType::bitset BitsetType::SignedSmall() {
   return i::SmiValuesAre31Bits() ? kSigned31 : kSigned32;
 }
 
 BitsetType::bitset BitsetType::UnsignedSmall() {
   return i::SmiValuesAre31Bits() ? kUnsigned30 : kUnsigned31;
 }
 
-#define CONSTRUCT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) \
-  Type* Type::Name(Isolate* isolate, Zone* zone) {                   \
-    return Class(i::handle(isolate->heap()->name##_map()), zone);    \
-  }
-SIMD128_TYPES(CONSTRUCT_SIMD_TYPE)
-#undef CONSTRUCT_SIMD_TYPE
-
 // -----------------------------------------------------------------------------
 // Instantiations.
 
-template class Type::Iterator<i::Map>;
 template class Type::Iterator<i::Object>;
 
 }  // namespace internal
 }  // namespace v8