[turbofan] Separate representation type operations from the semantic 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/factory.h"
 #include "src/handles.h"
@@ skipping 331 matching lines @@
   #define DEFINE_TYPE_CONSTRUCTOR(type, value)                                \
     static TypeImpl* type() {                                                 \
       return BitsetType::New(BitsetType::k##type);                            \
     }                                                                         \
     static TypeHandle type(Region* region) {                                  \
       return BitsetType::New(BitsetType::k##type, region);                    \
     }
   PROPER_BITSET_TYPE_LIST(DEFINE_TYPE_CONSTRUCTOR)
   #undef DEFINE_TYPE_CONSTRUCTOR
 
+#define DEFINE_TYPE_CONSTRUCTOR(type, value)                 \
+  static TypeImpl* Mask##type##ForTesting() {                \
+    return BitsetType::New(BitsetType::k##type);             \
+  }                                                          \
+  static TypeHandle Mask##type##ForTesting(Region* region) { \
+    return BitsetType::New(BitsetType::k##type, region);     \
+  }
+  MASK_BITSET_TYPE_LIST(DEFINE_TYPE_CONSTRUCTOR)
+#undef DEFINE_TYPE_CONSTRUCTOR
+
   static TypeImpl* SignedSmall() {
     return BitsetType::New(BitsetType::SignedSmall());
   }
   static TypeHandle SignedSmall(Region* region) {
     return BitsetType::New(BitsetType::SignedSmall(), region);
   }
   static TypeImpl* UnsignedSmall() {
     return BitsetType::New(BitsetType::UnsignedSmall());
   }
   static TypeHandle UnsignedSmall(Region* region) {
@@ skipping 166 matching lines @@
 
   enum PrintDimension { BOTH_DIMS, SEMANTIC_DIM, REPRESENTATION_DIM };
 
   void PrintTo(std::ostream& os, PrintDimension dim = BOTH_DIMS);  // NOLINT
 
 #ifdef DEBUG
   void Print();
 #endif
 
   bool IsUnionForTesting() { return IsUnion(); }
+  bitset GetRepresentationForTesting() { return GetRepresentation(); }
 
  protected:
   // Friends.
 
   template<class> friend class Iterator;
   template<class> friend class TypeImpl;
 
   // Handle conversion.
 
   template<class T>
   static typename Config::template Handle<T>::type handle(T* type) {
     return Config::handle(type);
   }
   TypeImpl* unhandle() { return this; }
 
   // Internal inspection.
 
   bool IsNone() { return this == None(); }
   bool IsAny() { return this == Any(); }
   bool IsBitset() { return Config::is_bitset(this); }
   bool IsUnion() { return Config::is_struct(this, StructuralType::kUnionTag); }
 
   bitset AsBitset() {
     DCHECK(this->IsBitset());
     return static_cast<BitsetType*>(this)->Bitset();
   }
   UnionType* AsUnion() { return UnionType::cast(this); }
 
+  bitset GetRepresentation();
+
   // Auxiliary functions.
+  bool SemanticMaybe(TypeImpl* that);
 
   bitset BitsetGlb() { return BitsetType::Glb(this); }
   bitset BitsetLub() { return BitsetType::Lub(this); }
 
   bool SlowIs(TypeImpl* that);
+  bool SemanticIs(TypeImpl* that);
 
   static bool IsInteger(double x) {
     return nearbyint(x) == x && !i::IsMinusZero(x);  // Allows for infinities.
   }
   static bool IsInteger(i::Object* x) {
     return x->IsNumber() && IsInteger(x->Number());
   }
 
   struct Limits {
     double min;
     double max;
-    bitset representation;
-    Limits(double min, double max, bitset representation)
-        : min(min), max(max), representation(representation) {}
-    explicit Limits(RangeType* range)
-        : min(range->Min()),
-          max(range->Max()),
-          representation(REPRESENTATION(range->Bound())) {}
-    static Limits Empty(Region* region) {
-      return Limits(1, 0, BitsetType::kNone);
-    }
+    Limits(double min, double max) : min(min), max(max) {}
+    explicit Limits(RangeType* range) : min(range->Min()), max(range->Max()) {}
+    static Limits Empty(Region* region) { return Limits(1, 0); }
   };
 
   static bool IsEmpty(Limits lim);
   static Limits Intersect(Limits lhs, Limits rhs);
   static Limits Union(Limits lhs, Limits rhs);
   static bool Overlap(RangeType* lhs, RangeType* rhs);
   static bool Contains(RangeType* lhs, RangeType* rhs);
   static bool Contains(RangeType* range, ConstantType* constant);
   static bool Contains(RangeType* range, i::Object* val);
 
@@ skipping 39 matching lines @@
   bitset Bitset() { return Config::as_bitset(this); }
 
   static TypeImpl* New(bitset bits) {
     if (FLAG_enable_slow_asserts) CheckNumberBits(bits);
     return Config::from_bitset(bits);
   }
   static TypeHandle New(bitset bits, Region* region) {
     if (FLAG_enable_slow_asserts) CheckNumberBits(bits);
     return Config::from_bitset(bits, region);
   }
-  // TODO(neis): Eventually allow again for types with empty semantics
-  // part and modify intersection and possibly subtyping accordingly.
 
   static bool IsInhabited(bitset bits) {
-    return bits & kSemantic;
+    return SEMANTIC(bits) != kNone && REPRESENTATION(bits) != kNone;
+  }
+
+  static bool SemanticIsInhabited(bitset bits) {
+    return SEMANTIC(bits) != kNone;
   }
 
   static bool Is(bitset bits1, bitset bits2) {
     return (bits1 | bits2) == bits2;
   }
 
   static double Min(bitset);
   static double Max(bitset);
 
   static bitset Glb(TypeImpl* type);  // greatest lower bound that's a bitset
@@ skipping 181 matching lines @@
     typename Config::template Handle<typename Config::Range>::type range =
         Config::range_create(region);
 
     bitset bits = SEMANTIC(BitsetType::Lub(min, max)) | representation_bits;
     Config::range_set_bitset(range, bits);
     Config::range_set_double(range, 0, min, region);
     Config::range_set_double(range, 1, max, region);
     return Config::template cast<RangeType>(Config::from_range(range));
   }
 
-  static RangeHandle New(Limits lim, Region* region) {
-    return New(lim.min, lim.max, BitsetType::New(lim.representation, region),
+  static RangeHandle New(Limits lim, bitset representation, Region* region) {
+    return New(lim.min, lim.max, BitsetType::New(representation, region),
                region);
   }
 
   static RangeType* cast(TypeImpl* type) {
     DCHECK(type->IsRange());
     return static_cast<RangeType*>(type);
   }
 };
 // TODO(neis): Also cache min and max values.
-// TODO(neis): Allow restricting the representation.
 
 
 // -----------------------------------------------------------------------------
 // Context types.
 
 template<class Config>
 class TypeImpl<Config>::ContextType : public StructuralType {
  public:
   TypeHandle Outer() { return this->Get(0); }
 
@@ skipping 269 matching lines @@
   bool Narrows(BoundsImpl that) {
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
 
 typedef BoundsImpl<ZoneTypeConfig> Bounds;
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_