[turbofan] Cleanup: Type only has a semantic dimension.

src/compiler/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_COMPILER_TYPES_H_
 #define V8_COMPILER_TYPES_H_
 
 #include "src/conversions.h"
 #include "src/handles.h"
 #include "src/objects.h"
 #include "src/ostreams.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // SUMMARY
 //
 // A simple type system for compiler-internal use. It is based entirely on
 // union types, and all subtyping hence amounts to set inclusion. Besides the
 // obvious primitive types and some predefined unions, the type language also
 // can express class types (a.k.a. specific maps) and singleton types (i.e.,
 // concrete constants).
 //
-// Types consist of two dimensions: semantic (value range) and representation.
-// Both are related through subtyping.
-//
-//
-// SEMANTIC DIMENSION
-//
-// The following equations and inequations hold for the semantic axis:
+// The following equations and inequations hold:
 //
 //   None <= T
 //   T <= Any
 //
 //   Number = Signed32 \/ Unsigned32 \/ Double
 //   Smi <= Signed32
 //   Name = String \/ Symbol
 //   UniqueName = InternalizedString \/ Symbol
 //   InternalizedString < String
 //
 //   Receiver = Object \/ Proxy
-//   RegExp < Object
 //   OtherUndetectable < Object
 //   DetectableReceiver = Receiver - OtherUndetectable
 //
 //   Constant(x) < T  iff instance_type(map(x)) < T
 //
 //
 // RANGE TYPES
 //
 // A range type represents a continuous integer interval by its minimum and
 // maximum value.  Either value may be an infinity, in which case that infinity
@@ skipping 42 matching lines @@
 //
 // Internally, all 'primitive' types, and their unions, are represented as
 // bitsets. Bit 0 is reserved for tagging. Only structured types require
 // allocation.
 
 // -----------------------------------------------------------------------------
 // Values for bitset types
 
 // clang-format off
 
-#define MASK_BITSET_TYPE_LIST(V) \
-  V(Semantic,       0xfffffffeu)
-
-#define SEMANTIC(k)       ((k) & BitsetType::kSemantic)
-
 #define INTERNAL_BITSET_TYPE_LIST(V)                                      \
   V(OtherUnsigned31, 1u << 1)  \
   V(OtherUnsigned32, 1u << 2)  \
   V(OtherSigned32,   1u << 3)  \
   V(OtherNumber,     1u << 4)  \
 
-#define SEMANTIC_BITSET_TYPE_LIST(V) \
+#define PROPER_BITSET_TYPE_LIST(V) \
   V(None,                0u)        \
   V(Negative31,          1u << 5)   \
   V(Null,                1u << 6)   \
   V(Undefined,           1u << 7)   \
   V(Boolean,             1u << 8)   \
   V(Unsigned30,          1u << 9)   \
   V(MinusZero,           1u << 10)  \
   V(NaN,                 1u << 11)  \
   V(Symbol,              1u << 12)  \
   V(InternalizedString,  1u << 13)  \
@@ skipping 58 matching lines @@
  *     -2^31   -2^30     0      2^30    2^31    2^32
  *
  * E.g., OtherUnsigned32 (OU32) covers all integers from 2^31 to 2^32-1.
  *
  * Some of the atomic numerical bitsets are internal only (see
  * INTERNAL_BITSET_TYPE_LIST).  To a types user, they should only occur in
  * union with certain other bitsets.  For instance, OtherNumber should only
  * occur as part of PlainNumber.
  */
 
-#define PROPER_BITSET_TYPE_LIST(V)   \
-  SEMANTIC_BITSET_TYPE_LIST(V)
-
-#define BITSET_TYPE_LIST(V)          \
-  MASK_BITSET_TYPE_LIST(V)           \
-  INTERNAL_BITSET_TYPE_LIST(V)       \
-  SEMANTIC_BITSET_TYPE_LIST(V)
+#define BITSET_TYPE_LIST(V)    \
+  INTERNAL_BITSET_TYPE_LIST(V) \
+  PROPER_BITSET_TYPE_LIST(V)
 
 class Type;
 
 // -----------------------------------------------------------------------------
 // Bitset types (internal).
 
 class BitsetType {
  public:
   typedef uint32_t bitset;  // Internal
 
   enum : uint32_t {
 #define DECLARE_TYPE(type, value) k##type = (value),
     BITSET_TYPE_LIST(DECLARE_TYPE)
 #undef DECLARE_TYPE
         kUnusedEOL = 0
   };
 
   static bitset SignedSmall();
   static bitset UnsignedSmall();
 
   bitset Bitset() {
     return static_cast<bitset>(reinterpret_cast<uintptr_t>(this) ^ 1u);
   }
 
-  static bool IsInhabited(bitset bits) { return SemanticIsInhabited(bits); }
-
-  static bool SemanticIsInhabited(bitset bits) {
-    return SEMANTIC(bits) != kNone;
-  }
+  static bool IsInhabited(bitset bits) { return bits != kNone; }
 
   static bool Is(bitset bits1, bitset bits2) {
     return (bits1 | bits2) == bits2;
   }
 
   static double Min(bitset);
   static double Max(bitset);
 
   static bitset Glb(Type* type);  // greatest lower bound that's a bitset
   static bitset Glb(double min, double max);
@@ skipping 122 matching lines @@
     return New(Limits(min, max), zone);
   }
 
   static bool IsInteger(double x) {
     return nearbyint(x) == x && !i::IsMinusZero(x);  // Allows for infinities.
   }
 
   static Type* New(Limits lim, Zone* zone) {
     DCHECK(IsInteger(lim.min) && IsInteger(lim.max));
     DCHECK(lim.min <= lim.max);
-    BitsetType::bitset bits = SEMANTIC(BitsetType::Lub(lim.min, lim.max));
+    BitsetType::bitset bits = BitsetType::Lub(lim.min, lim.max);
 
     return AsType(new (zone->New(sizeof(RangeType))) RangeType(bits, lim));
   }
 
   static RangeType* cast(Type* type) {
     DCHECK(IsKind(type, kRange));
     return static_cast<RangeType*>(FromType(type));
   }
 
   RangeType(BitsetType::bitset bitset, Limits limits)
@@ skipping 134 matching lines @@
   }
   static Type* Of(i::Handle<i::Object> value, Zone* zone) {
     return Of(*value, zone);
   }
 
   static Type* For(i::Map* map) {
     return BitsetType::New(BitsetType::ExpandInternals(BitsetType::Lub(map)));
   }
   static Type* For(i::Handle<i::Map> map) { return For(*map); }
 
-  // Extraction of components.
-  static Type* Semantic(Type* t, Zone* zone);
-
   // Predicates.
   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); }
@@ skipping 78 matching lines @@
   bool IsAny() { return this == Any(); }
   bool IsBitset() { return BitsetType::IsBitset(this); }
   bool IsUnion() { return IsKind(TypeBase::kUnion); }
 
   bitset AsBitset() {
     DCHECK(this->IsBitset());
     return reinterpret_cast<BitsetType*>(this)->Bitset();
   }
   UnionType* AsUnion() { return UnionType::cast(this); }
 
-  // Auxiliary functions.
-  bool SemanticMaybe(Type* that);
-
   bitset BitsetGlb() { return BitsetType::Glb(this); }
   bitset BitsetLub() { return BitsetType::Lub(this); }
 
   bool SlowIs(Type* that);
-  bool SemanticIs(Type* that);
 
   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);
 
   static int UpdateRange(Type* type, UnionType* result, int size, Zone* zone);
 
   static RangeType::Limits IntersectRangeAndBitset(Type* range, Type* bits,
                                                    Zone* zone);
   static RangeType::Limits ToLimits(bitset bits, Zone* zone);
 
   bool SimplyEquals(Type* that);
 
   static int AddToUnion(Type* type, UnionType* result, int size, Zone* zone);
   static int IntersectAux(Type* type, Type* other, UnionType* result, int size,
                           RangeType::Limits* limits, Zone* zone);
   static Type* NormalizeUnion(Type* unioned, int size, Zone* zone);
   static Type* NormalizeRangeAndBitset(Type* range, bitset* bits, Zone* zone);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_TYPES_H_