[turbofan] Nuke class types.

src/types.h

 // 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.
 
 #ifndef V8_TYPES_H_
 #define V8_TYPES_H_
 
 #include "src/conversions.h"
 #include "src/handles.h"
 #include "src/objects.h"
@@ skipping 27 matching lines @@
 //   UniqueName = InternalizedString \/ Symbol
 //   InternalizedString < String
 //
 //   Receiver = Object \/ Proxy
 //   Array < Object
 //   Function < Object
 //   RegExp < Object
 //   OtherUndetectable < Object
 //   DetectableReceiver = Receiver - OtherUndetectable
 //
-//   Class(map) < T   iff instance_type(map) < T
 //   Constant(x) < T  iff instance_type(map(x)) < T
 //   Array(T) < Array
 //   Function(R, S, T0, T1, ...) < Function
 //   Context(T) < Internal
 //
 // Both structural Array and Function types are invariant in all parameters;
 // relaxing this would make Union and Intersect operations more involved.
 // There is no subtyping relation between Array, Function, or Context types
 // and respective Constant types, since these types cannot be reconstructed
 // for arbitrary heap values.
-// Note also that Constant(x) < Class(map(x)) does _not_ hold, since x's map can
-// change! (Its instance type cannot, however.)
-// TODO(rossberg): the latter is not currently true for proxies, because of fix,
-// but will hold once we implement direct proxies.
-// However, we also define a 'temporal' variant of the subtyping relation that
-// considers the _current_ state only, i.e., Constant(x) <_now Class(map(x)).
 //
 //
 // REPRESENTATIONAL DIMENSION
 //
 // For the representation axis, the following holds:
 //
 //   None <= R
 //   R <= Any
 //
 //   UntaggedInt = UntaggedInt1 \/ UntaggedInt8 \/
@@ skipping 58 matching lines @@
 // complete partial order.
 //
 // See test/cctest/test-types.cc for a comprehensive executable specification,
 // especially with respect to the properties of the more exotic 'temporal'
 // constructors and predicates (those prefixed 'Now').
 //
 //
 // IMPLEMENTATION
 //
 // Internally, all 'primitive' types, and their unions, are represented as
-// bitsets. Bit 0 is reserved for tagging. Class is a heap pointer to the
-// respective map. Only structured types require allocation.
+// bitsets. Bit 0 is reserved for tagging. Only structured types require
+// allocation.
 // Note that the bitset representation is closed under both Union and Intersect.
 
-
 // -----------------------------------------------------------------------------
 // Values for bitset types
 
 // clang-format off
 
 #define MASK_BITSET_TYPE_LIST(V) \
   V(Representation, 0xffc00000u) \
   V(Semantic,       0x003ffffeu)
 
 #define REPRESENTATION(k) ((k) & BitsetType::kRepresentation)
@@ skipping 191 matching lines @@
   static inline size_t BoundariesSize();
 };
 
 // -----------------------------------------------------------------------------
 // Superclass for non-bitset types (internal).
 class TypeBase {
  protected:
   friend class Type;
 
   enum Kind {
-    kClass,
     kConstant,
     kContext,
     kArray,
     kFunction,
     kTuple,
     kUnion,
     kRange
   };
 
   Kind kind() const { return kind_; }
   explicit TypeBase(Kind kind) : kind_(kind) {}
 
   static bool IsKind(Type* type, Kind kind) {
     if (BitsetType::IsBitset(type)) return false;
     TypeBase* base = reinterpret_cast<TypeBase*>(type);
     return base->kind() == kind;
   }
 
   // The hacky conversion to/from Type*.
   static Type* AsType(TypeBase* type) { return reinterpret_cast<Type*>(type); }
   static TypeBase* FromType(Type* type) {
     return reinterpret_cast<TypeBase*>(type);
   }
 
  private:
   Kind kind_;
 };
 
 // -----------------------------------------------------------------------------
-// Class types.
-
-class ClassType : public TypeBase {
- public:
-  i::Handle<i::Map> Map() { return map_; }
-
- private:
-  friend class Type;
-  friend class BitsetType;
-
-  static Type* New(i::Handle<i::Map> map, Zone* zone) {
-    return AsType(new (zone->New(sizeof(ClassType)))
-                      ClassType(BitsetType::Lub(*map), map));
-  }
-
-  static ClassType* cast(Type* type) {
-    DCHECK(IsKind(type, kClass));
-    return static_cast<ClassType*>(FromType(type));
-  }
-
-  ClassType(BitsetType::bitset bitset, i::Handle<i::Map> map)
-      : TypeBase(kClass), bitset_(bitset), map_(map) {}
-
-  BitsetType::bitset Lub() { return bitset_; }
-
-  BitsetType::bitset bitset_;
-  Handle<i::Map> map_;
-};
-
-// -----------------------------------------------------------------------------
 // Constant types.
 
 class ConstantType : public TypeBase {
  public:
   i::Handle<i::Object> Value() { return object_; }
 
  private:
   friend class Type;
   friend class BitsetType;
 
@@ skipping 253 matching lines @@
   PROPER_BITSET_TYPE_LIST(DEFINE_TYPE_CONSTRUCTOR)
 #undef DEFINE_TYPE_CONSTRUCTOR
 
   static Type* SignedSmall() {
     return BitsetType::New(BitsetType::SignedSmall());
   }
   static Type* UnsignedSmall() {
     return BitsetType::New(BitsetType::UnsignedSmall());
   }
 
-  static Type* Class(i::Handle<i::Map> map, Zone* zone) {
-    return ClassType::New(map, zone);
-  }
   static Type* Constant(i::Handle<i::Object> value, Zone* zone) {
     return ConstantType::New(value, zone);
   }
   static Type* Range(double min, double max, Zone* zone) {
     return RangeType::New(min, max, REPRESENTATION(BitsetType::kTagged |
                                                    BitsetType::kUntaggedNumber),
                           zone);
   }
   static Type* Context(Type* outer, Zone* zone) {
     return ContextType::New(outer, zone);
@@ skipping 34 matching lines @@
     return function;
   }
   static Type* Tuple(Type* first, Type* second, Type* third, Zone* zone) {
     Type* tuple = TupleType::New(3, zone);
     tuple->AsTuple()->InitElement(0, first);
     tuple->AsTuple()->InitElement(1, second);
     tuple->AsTuple()->InitElement(2, third);
     return tuple;
   }
 
-#define CONSTRUCT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) \
-  static Type* Name(Isolate* isolate, Zone* zone);
-  SIMD128_TYPES(CONSTRUCT_SIMD_TYPE)
-#undef CONSTRUCT_SIMD_TYPE
-
   static Type* Union(Type* type1, Type* type2, Zone* zone);
   static Type* Intersect(Type* type1, Type* type2, Zone* zone);
 
   static Type* Of(double value, Zone* zone) {
     return BitsetType::New(BitsetType::ExpandInternals(BitsetType::Lub(value)));
   }
   static Type* Of(i::Object* value, Zone* zone) {
     return BitsetType::New(BitsetType::ExpandInternals(BitsetType::Lub(value)));
   }
   static Type* Of(i::Handle<i::Object> value, Zone* zone) {
@@ skipping 13 matching lines @@
   bool IsInhabited() { return BitsetType::IsInhabited(this->BitsetLub()); }
 
   bool Is(Type* that) { return this == that || this->SlowIs(that); }
   bool Maybe(Type* that);
   bool Equals(Type* that) { return this->Is(that) && that->Is(this); }
 
   // Equivalent to Constant(val)->Is(this), but avoiding allocation.
   bool Contains(i::Object* val);
   bool Contains(i::Handle<i::Object> val) { return this->Contains(*val); }
 
-  // State-dependent versions of the above that consider subtyping between
-  // a constant and its map class.
-  static Type* NowOf(i::Object* value, Zone* zone);
-  static Type* NowOf(i::Handle<i::Object> value, Zone* zone) {
-    return NowOf(*value, zone);
-  }
-  bool NowIs(Type* that);
-  bool NowContains(i::Object* val);
-  bool NowContains(i::Handle<i::Object> val) { return this->NowContains(*val); }
-
-  bool NowStable();
-
   // Inspection.
   bool IsRange() { return IsKind(TypeBase::kRange); }
-  bool IsClass() { return IsKind(TypeBase::kClass); }
   bool IsConstant() { return IsKind(TypeBase::kConstant); }
   bool IsContext() { return IsKind(TypeBase::kContext); }
   bool IsArray() { return IsKind(TypeBase::kArray); }
   bool IsFunction() { return IsKind(TypeBase::kFunction); }
   bool IsTuple() { return IsKind(TypeBase::kTuple); }
 
-  ClassType* AsClass() { return ClassType::cast(this); }
   ConstantType* AsConstant() { return ConstantType::cast(this); }
   RangeType* AsRange() { return RangeType::cast(this); }
   ContextType* AsContext() { return ContextType::cast(this); }
   ArrayType* AsArray() { return ArrayType::cast(this); }
   FunctionType* AsFunction() { return FunctionType::cast(this); }
   TupleType* AsTuple() { return TupleType::cast(this); }
 
   // Minimum and maximum of a numeric type.
   // These functions do not distinguish between -0 and +0.  If the type equals
   // kNaN, they return NaN; otherwise kNaN is ignored.  Only call these
   // functions on subtypes of Number.
   double Min();
   double Max();
 
   // Extracts a range from the type: if the type is a range or a union
   // containing a range, that range is returned; otherwise, NULL is returned.
   Type* GetRange();
 
   static bool IsInteger(i::Object* x);
   static bool IsInteger(double x) {
     return nearbyint(x) == x && !i::IsMinusZero(x);  // Allows for infinities.
   }
 
-  int NumClasses();
   int NumConstants();
 
   template <class T>
   class Iterator {
    public:
     bool Done() const { return index_ < 0; }
     i::Handle<T> Current();
     void Advance();
 
    private:
     friend class Type;
 
     Iterator() : index_(-1) {}
     explicit Iterator(Type* type) : type_(type), index_(-1) { Advance(); }
 
     inline bool matches(Type* type);
     inline Type* get_type();
 
     Type* type_;
     int index_;
   };
 
-  Iterator<i::Map> Classes() {
-    if (this->IsBitset()) return Iterator<i::Map>();
-    return Iterator<i::Map>(this);
-  }
   Iterator<i::Object> Constants() {
     if (this->IsBitset()) return Iterator<i::Object>();
     return Iterator<i::Object>(this);
   }
 
   // Printing.
 
   enum PrintDimension { BOTH_DIMS, SEMANTIC_DIM, REPRESENTATION_DIM };
 
   void PrintTo(std::ostream& os, PrintDimension dim = BOTH_DIMS);  // NOLINT
@@ skipping 108 matching lines @@
   }
 
   bool Narrows(Bounds that) {
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TYPES_H_