LCOV - code coverage report
Current view: top level - src/compiler - types.h (source / functions) Hit Total Coverage
Test: app.info Lines: 49 49 100.0 %
Date: 2017-04-26 Functions: 11 11 100.0 %

          Line data    Source code
       1             : // Copyright 2014 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_COMPILER_TYPES_H_
       6             : #define V8_COMPILER_TYPES_H_
       7             : 
       8             : #include "src/base/compiler-specific.h"
       9             : #include "src/conversions.h"
      10             : #include "src/globals.h"
      11             : #include "src/handles.h"
      12             : #include "src/objects.h"
      13             : #include "src/ostreams.h"
      14             : 
      15             : namespace v8 {
      16             : namespace internal {
      17             : namespace compiler {
      18             : 
      19             : // SUMMARY
      20             : //
      21             : // A simple type system for compiler-internal use. It is based entirely on
      22             : // union types, and all subtyping hence amounts to set inclusion. Besides the
      23             : // obvious primitive types and some predefined unions, the type language also
      24             : // can express class types (a.k.a. specific maps) and singleton types (i.e.,
      25             : // concrete constants).
      26             : //
      27             : // The following equations and inequations hold:
      28             : //
      29             : //   None <= T
      30             : //   T <= Any
      31             : //
      32             : //   Number = Signed32 \/ Unsigned32 \/ Double
      33             : //   Smi <= Signed32
      34             : //   Name = String \/ Symbol
      35             : //   UniqueName = InternalizedString \/ Symbol
      36             : //   InternalizedString < String
      37             : //
      38             : //   Receiver = Object \/ Proxy
      39             : //   OtherUndetectable < Object
      40             : //   DetectableReceiver = Receiver - OtherUndetectable
      41             : //
      42             : //   Constant(x) < T  iff instance_type(map(x)) < T
      43             : //
      44             : //
      45             : // RANGE TYPES
      46             : //
      47             : // A range type represents a continuous integer interval by its minimum and
      48             : // maximum value.  Either value may be an infinity, in which case that infinity
      49             : // itself is also included in the range.   A range never contains NaN or -0.
      50             : //
      51             : // If a value v happens to be an integer n, then Constant(v) is considered a
      52             : // subtype of Range(n, n) (and therefore also a subtype of any larger range).
      53             : // In order to avoid large unions, however, it is usually a good idea to use
      54             : // Range rather than Constant.
      55             : //
      56             : //
      57             : // PREDICATES
      58             : //
      59             : // There are two main functions for testing types:
      60             : //
      61             : //   T1->Is(T2)     -- tests whether T1 is included in T2 (i.e., T1 <= T2)
      62             : //   T1->Maybe(T2)  -- tests whether T1 and T2 overlap (i.e., T1 /\ T2 =/= 0)
      63             : //
      64             : // Typically, the former is to be used to select representations (e.g., via
      65             : // T->Is(SignedSmall())), and the latter to check whether a specific case needs
      66             : // handling (e.g., via T->Maybe(Number())).
      67             : //
      68             : // There is no functionality to discover whether a type is a leaf in the
      69             : // lattice. That is intentional. It should always be possible to refine the
      70             : // lattice (e.g., splitting up number types further) without invalidating any
      71             : // existing assumptions or tests.
      72             : // Consequently, do not normally use Equals for type tests, always use Is!
      73             : //
      74             : // The NowIs operator implements state-sensitive subtying, as described above.
      75             : // Any compilation decision based on such temporary properties requires runtime
      76             : // guarding!
      77             : //
      78             : //
      79             : // PROPERTIES
      80             : //
      81             : // Various formal properties hold for constructors, operators, and predicates
      82             : // over types. For example, constructors are injective and subtyping is a
      83             : // complete partial order.
      84             : //
      85             : // See test/cctest/test-types.cc for a comprehensive executable specification,
      86             : // especially with respect to the properties of the more exotic 'temporal'
      87             : // constructors and predicates (those prefixed 'Now').
      88             : //
      89             : //
      90             : // IMPLEMENTATION
      91             : //
      92             : // Internally, all 'primitive' types, and their unions, are represented as
      93             : // bitsets. Bit 0 is reserved for tagging. Only structured types require
      94             : // allocation.
      95             : 
      96             : // -----------------------------------------------------------------------------
      97             : // Values for bitset types
      98             : 
      99             : // clang-format off
     100             : 
     101             : #define INTERNAL_BITSET_TYPE_LIST(V)                                      \
     102             :   V(OtherUnsigned31, 1u << 1)  \
     103             :   V(OtherUnsigned32, 1u << 2)  \
     104             :   V(OtherSigned32,   1u << 3)  \
     105             :   V(OtherNumber,     1u << 4)  \
     106             : 
     107             : #define PROPER_BITSET_TYPE_LIST(V) \
     108             :   V(None,                0u)        \
     109             :   V(Negative31,          1u << 5)   \
     110             :   V(Null,                1u << 6)   \
     111             :   V(Undefined,           1u << 7)   \
     112             :   V(Boolean,             1u << 8)   \
     113             :   V(Unsigned30,          1u << 9)   \
     114             :   V(MinusZero,           1u << 10)  \
     115             :   V(NaN,                 1u << 11)  \
     116             :   V(Symbol,              1u << 12)  \
     117             :   V(InternalizedString,  1u << 13)  \
     118             :   V(OtherString,         1u << 14)  \
     119             :   V(OtherCallable,       1u << 15)  \
     120             :   V(OtherObject,         1u << 16)  \
     121             :   V(OtherUndetectable,   1u << 17)  \
     122             :   V(CallableProxy,       1u << 18)  \
     123             :   V(OtherProxy,          1u << 19)  \
     124             :   V(Function,            1u << 20)  \
     125             :   V(BoundFunction,       1u << 21)  \
     126             :   V(Hole,                1u << 22)  \
     127             :   V(OtherInternal,       1u << 23)  \
     128             :   V(ExternalPointer,     1u << 24)  \
     129             :   V(Array,               1u << 25)  \
     130             :   \
     131             :   V(Signed31,                     kUnsigned30 | kNegative31) \
     132             :   V(Signed32,                     kSigned31 | kOtherUnsigned31 | \
     133             :                                   kOtherSigned32) \
     134             :   V(Signed32OrMinusZero,          kSigned32 | kMinusZero) \
     135             :   V(Signed32OrMinusZeroOrNaN,     kSigned32 | kMinusZero | kNaN) \
     136             :   V(Negative32,                   kNegative31 | kOtherSigned32) \
     137             :   V(Unsigned31,                   kUnsigned30 | kOtherUnsigned31) \
     138             :   V(Unsigned32,                   kUnsigned30 | kOtherUnsigned31 | \
     139             :                                   kOtherUnsigned32) \
     140             :   V(Unsigned32OrMinusZero,        kUnsigned32 | kMinusZero) \
     141             :   V(Unsigned32OrMinusZeroOrNaN,   kUnsigned32 | kMinusZero | kNaN) \
     142             :   V(Integral32,                   kSigned32 | kUnsigned32) \
     143             :   V(Integral32OrMinusZero,        kIntegral32 | kMinusZero) \
     144             :   V(Integral32OrMinusZeroOrNaN,   kIntegral32OrMinusZero | kNaN) \
     145             :   V(PlainNumber,                  kIntegral32 | kOtherNumber) \
     146             :   V(OrderedNumber,                kPlainNumber | kMinusZero) \
     147             :   V(MinusZeroOrNaN,               kMinusZero | kNaN) \
     148             :   V(Number,                       kOrderedNumber | kNaN) \
     149             :   V(String,                       kInternalizedString | kOtherString) \
     150             :   V(UniqueName,                   kSymbol | kInternalizedString) \
     151             :   V(Name,                         kSymbol | kString) \
     152             :   V(InternalizedStringOrNull,     kInternalizedString | kNull) \
     153             :   V(BooleanOrNumber,              kBoolean | kNumber) \
     154             :   V(BooleanOrNullOrNumber,        kBooleanOrNumber | kNull) \
     155             :   V(BooleanOrNullOrUndefined,     kBoolean | kNull | kUndefined) \
     156             :   V(Oddball,                      kBooleanOrNullOrUndefined | kHole) \
     157             :   V(NullOrNumber,                 kNull | kNumber) \
     158             :   V(NullOrUndefined,              kNull | kUndefined) \
     159             :   V(Undetectable,                 kNullOrUndefined | kOtherUndetectable) \
     160             :   V(NumberOrHole,                 kNumber | kHole) \
     161             :   V(NumberOrOddball,              kNumber | kNullOrUndefined | kBoolean | \
     162             :                                   kHole) \
     163             :   V(NumberOrString,               kNumber | kString) \
     164             :   V(NumberOrUndefined,            kNumber | kUndefined) \
     165             :   V(PlainPrimitive,               kNumberOrString | kBoolean | \
     166             :                                   kNullOrUndefined) \
     167             :   V(Primitive,                    kSymbol | kPlainPrimitive) \
     168             :   V(OtherUndetectableOrUndefined, kOtherUndetectable | kUndefined) \
     169             :   V(Proxy,                        kCallableProxy | kOtherProxy) \
     170             :   V(ArrayOrOtherObject,           kArray | kOtherObject) \
     171             :   V(ArrayOrProxy,                 kArray | kProxy) \
     172             :   V(DetectableCallable,           kFunction | kBoundFunction | \
     173             :                                   kOtherCallable | kCallableProxy) \
     174             :   V(Callable,                     kDetectableCallable | kOtherUndetectable) \
     175             :   V(NonCallable,                  kArray | kOtherObject | kOtherProxy) \
     176             :   V(NonCallableOrNull,            kNonCallable | kNull) \
     177             :   V(DetectableObject,             kArray | kFunction | kBoundFunction | \
     178             :                                   kOtherCallable | kOtherObject) \
     179             :   V(DetectableReceiver,           kDetectableObject | kProxy) \
     180             :   V(DetectableReceiverOrNull,     kDetectableReceiver | kNull) \
     181             :   V(Object,                       kDetectableObject | kOtherUndetectable) \
     182             :   V(Receiver,                     kObject | kProxy) \
     183             :   V(ReceiverOrUndefined,          kReceiver | kUndefined) \
     184             :   V(ReceiverOrNullOrUndefined,    kReceiver | kNull | kUndefined) \
     185             :   V(SymbolOrReceiver,             kSymbol | kReceiver) \
     186             :   V(StringOrReceiver,             kString | kReceiver) \
     187             :   V(Unique,                       kBoolean | kUniqueName | kNull | \
     188             :                                   kUndefined | kReceiver) \
     189             :   V(Internal,                     kHole | kExternalPointer | kOtherInternal) \
     190             :   V(NonInternal,                  kPrimitive | kReceiver) \
     191             :   V(NonNumber,                    kUnique | kString | kInternal) \
     192             :   V(Any,                          0xfffffffeu)
     193             : 
     194             : // clang-format on
     195             : 
     196             : /*
     197             :  * The following diagrams show how integers (in the mathematical sense) are
     198             :  * divided among the different atomic numerical types.
     199             :  *
     200             :  *   ON    OS32     N31     U30     OU31    OU32     ON
     201             :  * ______[_______[_______[_______[_______[_______[_______
     202             :  *     -2^31   -2^30     0      2^30    2^31    2^32
     203             :  *
     204             :  * E.g., OtherUnsigned32 (OU32) covers all integers from 2^31 to 2^32-1.
     205             :  *
     206             :  * Some of the atomic numerical bitsets are internal only (see
     207             :  * INTERNAL_BITSET_TYPE_LIST).  To a types user, they should only occur in
     208             :  * union with certain other bitsets.  For instance, OtherNumber should only
     209             :  * occur as part of PlainNumber.
     210             :  */
     211             : 
     212             : #define BITSET_TYPE_LIST(V)    \
     213             :   INTERNAL_BITSET_TYPE_LIST(V) \
     214             :   PROPER_BITSET_TYPE_LIST(V)
     215             : 
     216             : class Type;
     217             : 
     218             : // -----------------------------------------------------------------------------
     219             : // Bitset types (internal).
     220             : 
     221             : class V8_EXPORT_PRIVATE BitsetType {
     222             :  public:
     223             :   typedef uint32_t bitset;  // Internal
     224             : 
     225             :   enum : uint32_t {
     226             : #define DECLARE_TYPE(type, value) k##type = (value),
     227             :     BITSET_TYPE_LIST(DECLARE_TYPE)
     228             : #undef DECLARE_TYPE
     229             :         kUnusedEOL = 0
     230             :   };
     231             : 
     232             :   static bitset SignedSmall();
     233             :   static bitset UnsignedSmall();
     234             : 
     235             :   bitset Bitset() {
     236   441690879 :     return static_cast<bitset>(reinterpret_cast<uintptr_t>(this) ^ 1u);
     237             :   }
     238             : 
     239             :   static bool IsInhabited(bitset bits) { return bits != kNone; }
     240             : 
     241             :   static bool Is(bitset bits1, bitset bits2) {
     242   245764425 :     return (bits1 | bits2) == bits2;
     243             :   }
     244             : 
     245             :   static double Min(bitset);
     246             :   static double Max(bitset);
     247             : 
     248             :   static bitset Glb(Type* type);  // greatest lower bound that's a bitset
     249             :   static bitset Glb(double min, double max);
     250             :   static bitset Lub(Type* type);  // least upper bound that's a bitset
     251             :   static bitset Lub(i::Map* map);
     252             :   static bitset Lub(i::Object* value);
     253             :   static bitset Lub(double value);
     254             :   static bitset Lub(double min, double max);
     255             :   static bitset ExpandInternals(bitset bits);
     256             : 
     257             :   static const char* Name(bitset);
     258             :   static void Print(std::ostream& os, bitset);  // NOLINT
     259             : #ifdef DEBUG
     260             :   static void Print(bitset);
     261             : #endif
     262             : 
     263             :   static bitset NumberBits(bitset bits);
     264             : 
     265             :   static bool IsBitset(Type* type) {
     266   997139433 :     return reinterpret_cast<uintptr_t>(type) & 1;
     267             :   }
     268             : 
     269             :   static Type* NewForTesting(bitset bits) { return New(bits); }
     270             : 
     271             :  private:
     272             :   friend class Type;
     273             : 
     274             :   static Type* New(bitset bits) {
     275    41186739 :     return reinterpret_cast<Type*>(static_cast<uintptr_t>(bits | 1u));
     276             :   }
     277             : 
     278             :   struct Boundary {
     279             :     bitset internal;
     280             :     bitset external;
     281             :     double min;
     282             :   };
     283             :   static const Boundary BoundariesArray[];
     284             :   static inline const Boundary* Boundaries();
     285             :   static inline size_t BoundariesSize();
     286             : };
     287             : 
     288             : // -----------------------------------------------------------------------------
     289             : // Superclass for non-bitset types (internal).
     290             : class TypeBase {
     291             :  protected:
     292             :   friend class Type;
     293             : 
     294             :   enum Kind { kHeapConstant, kOtherNumberConstant, kTuple, kUnion, kRange };
     295             : 
     296   865799397 :   Kind kind() const { return kind_; }
     297    40942592 :   explicit TypeBase(Kind kind) : kind_(kind) {}
     298             : 
     299             :   static bool IsKind(Type* type, Kind kind) {
     300   912728006 :     if (BitsetType::IsBitset(type)) return false;
     301             :     TypeBase* base = reinterpret_cast<TypeBase*>(type);
     302   865799397 :     return base->kind() == kind;
     303             :   }
     304             : 
     305             :   // The hacky conversion to/from Type*.
     306             :   static Type* AsType(TypeBase* type) { return reinterpret_cast<Type*>(type); }
     307             :   static TypeBase* FromType(Type* type) {
     308             :     return reinterpret_cast<TypeBase*>(type);
     309             :   }
     310             : 
     311             :  private:
     312             :   Kind kind_;
     313             : };
     314             : 
     315             : // -----------------------------------------------------------------------------
     316             : // Constant types.
     317             : 
     318             : class OtherNumberConstantType : public TypeBase {
     319             :  public:
     320             :   double Value() { return value_; }
     321             : 
     322             :   static bool IsOtherNumberConstant(double value);
     323             :   static bool IsOtherNumberConstant(Object* value);
     324             : 
     325             :  private:
     326             :   friend class Type;
     327             :   friend class BitsetType;
     328             : 
     329     1720863 :   static Type* New(double value, Zone* zone) {
     330             :     return AsType(new (zone->New(sizeof(OtherNumberConstantType)))
     331     1720863 :                       OtherNumberConstantType(value));  // NOLINT
     332             :   }
     333             : 
     334             :   static OtherNumberConstantType* cast(Type* type) {
     335             :     DCHECK(IsKind(type, kOtherNumberConstant));
     336             :     return static_cast<OtherNumberConstantType*>(FromType(type));
     337             :   }
     338             : 
     339     1720863 :   explicit OtherNumberConstantType(double value)
     340     1720863 :       : TypeBase(kOtherNumberConstant), value_(value) {
     341     1720863 :     CHECK(IsOtherNumberConstant(value));
     342     1720863 :   }
     343             : 
     344             :   BitsetType::bitset Lub() { return BitsetType::kOtherNumber; }
     345             : 
     346             :   double value_;
     347             : };
     348             : 
     349             : class V8_EXPORT_PRIVATE HeapConstantType : public NON_EXPORTED_BASE(TypeBase) {
     350             :  public:
     351             :   i::Handle<i::HeapObject> Value() { return object_; }
     352             : 
     353             :  private:
     354             :   friend class Type;
     355             :   friend class BitsetType;
     356             : 
     357     9429179 :   static Type* New(i::Handle<i::HeapObject> value, Zone* zone) {
     358     9429179 :     BitsetType::bitset bitset = BitsetType::Lub(*value);
     359             :     return AsType(new (zone->New(sizeof(HeapConstantType)))
     360    14878442 :                       HeapConstantType(bitset, value));
     361             :   }
     362             : 
     363             :   static HeapConstantType* cast(Type* type) {
     364             :     DCHECK(IsKind(type, kHeapConstant));
     365             :     return static_cast<HeapConstantType*>(FromType(type));
     366             :   }
     367             : 
     368             :   HeapConstantType(BitsetType::bitset bitset, i::Handle<i::HeapObject> object);
     369             : 
     370             :   BitsetType::bitset Lub() { return bitset_; }
     371             : 
     372             :   BitsetType::bitset bitset_;
     373             :   Handle<i::HeapObject> object_;
     374             : };
     375             : 
     376             : // -----------------------------------------------------------------------------
     377             : // Range types.
     378             : 
     379             : class RangeType : public TypeBase {
     380             :  public:
     381             :   struct Limits {
     382             :     double min;
     383             :     double max;
     384    12046051 :     Limits(double min, double max) : min(min), max(max) {}
     385     6333390 :     explicit Limits(RangeType* range) : min(range->Min()), max(range->Max()) {}
     386             :     bool IsEmpty();
     387             :     static Limits Empty() { return Limits(1, 0); }
     388             :     static Limits Intersect(Limits lhs, Limits rhs);
     389             :     static Limits Union(Limits lhs, Limits rhs);
     390             :   };
     391             : 
     392             :   double Min() { return limits_.min; }
     393             :   double Max() { return limits_.max; }
     394             : 
     395             :  private:
     396             :   friend class Type;
     397             :   friend class BitsetType;
     398             :   friend class UnionType;
     399             : 
     400             :   static Type* New(double min, double max, Zone* zone) {
     401    12046051 :     return New(Limits(min, max), zone);
     402             :   }
     403             : 
     404             :   static bool IsInteger(double x) {
     405             :     return nearbyint(x) == x && !i::IsMinusZero(x);  // Allows for infinities.
     406             :   }
     407             : 
     408    15403315 :   static Type* New(Limits lim, Zone* zone) {
     409             :     DCHECK(IsInteger(lim.min) && IsInteger(lim.max));
     410             :     DCHECK(lim.min <= lim.max);
     411     4105909 :     BitsetType::bitset bits = BitsetType::Lub(lim.min, lim.max);
     412             : 
     413    30806589 :     return AsType(new (zone->New(sizeof(RangeType))) RangeType(bits, lim));
     414             :   }
     415             : 
     416             :   static RangeType* cast(Type* type) {
     417             :     DCHECK(IsKind(type, kRange));
     418             :     return static_cast<RangeType*>(FromType(type));
     419             :   }
     420             : 
     421             :   RangeType(BitsetType::bitset bitset, Limits limits)
     422    15403217 :       : TypeBase(kRange), bitset_(bitset), limits_(limits) {}
     423             : 
     424             :   BitsetType::bitset Lub() { return bitset_; }
     425             : 
     426             :   BitsetType::bitset bitset_;
     427             :   Limits limits_;
     428             : };
     429             : 
     430             : // -----------------------------------------------------------------------------
     431             : // Superclass for types with variable number of type fields.
     432             : class StructuralType : public TypeBase {
     433             :  public:
     434             :   int LengthForTesting() { return Length(); }
     435             : 
     436             :  protected:
     437             :   friend class Type;
     438             : 
     439             :   int Length() { return length_; }
     440             : 
     441             :   Type* Get(int i) {
     442             :     DCHECK(0 <= i && i < this->Length());
     443   197218630 :     return elements_[i];
     444             :   }
     445             : 
     446             :   void Set(int i, Type* type) {
     447             :     DCHECK(0 <= i && i < this->Length());
     448    38571124 :     elements_[i] = type;
     449             :   }
     450             : 
     451             :   void Shrink(int length) {
     452             :     DCHECK(2 <= length && length <= this->Length());
     453    12456770 :     length_ = length;
     454             :   }
     455             : 
     456             :   StructuralType(Kind kind, int length, i::Zone* zone)
     457    14388644 :       : TypeBase(kind), length_(length) {
     458    14388644 :     elements_ = reinterpret_cast<Type**>(zone->New(sizeof(Type*) * length));
     459             :   }
     460             : 
     461             :  private:
     462             :   int length_;
     463             :   Type** elements_;
     464             : };
     465             : 
     466             : // -----------------------------------------------------------------------------
     467             : // Tuple types.
     468             : 
     469             : class TupleType : public StructuralType {
     470             :  public:
     471        4047 :   int Arity() { return this->Length(); }
     472        4617 :   Type* Element(int i) { return this->Get(i); }
     473             : 
     474        4104 :   void InitElement(int i, Type* type) { this->Set(i, type); }
     475             : 
     476             :  private:
     477             :   friend class Type;
     478             : 
     479             :   TupleType(int length, Zone* zone) : StructuralType(kTuple, length, zone) {}
     480             : 
     481        1368 :   static Type* New(int length, Zone* zone) {
     482        2736 :     return AsType(new (zone->New(sizeof(TupleType))) TupleType(length, zone));
     483             :   }
     484             : 
     485             :   static TupleType* cast(Type* type) {
     486             :     DCHECK(IsKind(type, kTuple));
     487             :     return static_cast<TupleType*>(FromType(type));
     488             :   }
     489             : };
     490             : 
     491             : // -----------------------------------------------------------------------------
     492             : // Union types (internal).
     493             : // A union is a structured type with the following invariants:
     494             : // - its length is at least 2
     495             : // - at most one field is a bitset, and it must go into index 0
     496             : // - no field is a union
     497             : // - no field is a subtype of any other field
     498             : class UnionType : public StructuralType {
     499             :  private:
     500             :   friend Type;
     501             :   friend BitsetType;
     502             : 
     503             :   UnionType(int length, Zone* zone) : StructuralType(kUnion, length, zone) {}
     504             : 
     505    14387280 :   static Type* New(int length, Zone* zone) {
     506    28774548 :     return AsType(new (zone->New(sizeof(UnionType))) UnionType(length, zone));
     507             :   }
     508             : 
     509             :   static UnionType* cast(Type* type) {
     510             :     DCHECK(IsKind(type, kUnion));
     511             :     return static_cast<UnionType*>(FromType(type));
     512             :   }
     513             : 
     514             :   bool Wellformed();
     515             : };
     516             : 
     517             : class V8_EXPORT_PRIVATE Type {
     518             :  public:
     519             :   typedef BitsetType::bitset bitset;  // Internal
     520             : 
     521             : // Constructors.
     522             : #define DEFINE_TYPE_CONSTRUCTOR(type, value) \
     523             :   static Type* type() { return BitsetType::New(BitsetType::k##type); }
     524             :   PROPER_BITSET_TYPE_LIST(DEFINE_TYPE_CONSTRUCTOR)
     525             : #undef DEFINE_TYPE_CONSTRUCTOR
     526             : 
     527             :   static Type* SignedSmall() {
     528     2195690 :     return BitsetType::New(BitsetType::SignedSmall());
     529             :   }
     530             :   static Type* UnsignedSmall() {
     531       15517 :     return BitsetType::New(BitsetType::UnsignedSmall());
     532             :   }
     533             : 
     534             :   static Type* OtherNumberConstant(double value, Zone* zone) {
     535     1720863 :     return OtherNumberConstantType::New(value, zone);
     536             :   }
     537             :   static Type* HeapConstant(i::Handle<i::HeapObject> value, Zone* zone) {
     538     9429213 :     return HeapConstantType::New(value, zone);
     539             :   }
     540             :   static Type* Range(double min, double max, Zone* zone) {
     541             :     return RangeType::New(min, max, zone);
     542             :   }
     543             :   static Type* Tuple(Type* first, Type* second, Type* third, Zone* zone) {
     544        1368 :     Type* tuple = TupleType::New(3, zone);
     545             :     tuple->AsTuple()->InitElement(0, first);
     546             :     tuple->AsTuple()->InitElement(1, second);
     547             :     tuple->AsTuple()->InitElement(2, third);
     548             :     return tuple;
     549             :   }
     550             : 
     551             :   // NewConstant is a factory that returns Constant, Range or Number.
     552             :   static Type* NewConstant(i::Handle<i::Object> value, Zone* zone);
     553             :   static Type* NewConstant(double value, Zone* zone);
     554             : 
     555             :   static Type* Union(Type* type1, Type* type2, Zone* zone);
     556             :   static Type* Intersect(Type* type1, Type* type2, Zone* zone);
     557             : 
     558             :   static Type* Of(double value, Zone* zone) {
     559             :     return BitsetType::New(BitsetType::ExpandInternals(BitsetType::Lub(value)));
     560             :   }
     561             :   static Type* Of(i::Object* value, Zone* zone) {
     562             :     return BitsetType::New(BitsetType::ExpandInternals(BitsetType::Lub(value)));
     563             :   }
     564             :   static Type* Of(i::Handle<i::Object> value, Zone* zone) {
     565             :     return Of(*value, zone);
     566             :   }
     567             : 
     568       17651 :   static Type* For(i::Map* map) {
     569       35302 :     return BitsetType::New(BitsetType::ExpandInternals(BitsetType::Lub(map)));
     570             :   }
     571       17651 :   static Type* For(i::Handle<i::Map> map) { return For(*map); }
     572             : 
     573             :   // Predicates.
     574             :   bool IsInhabited() { return BitsetType::IsInhabited(this->BitsetLub()); }
     575             : 
     576   255987511 :   bool Is(Type* that) { return this == that || this->SlowIs(that); }
     577             :   bool Maybe(Type* that);
     578        1026 :   bool Equals(Type* that) { return this->Is(that) && that->Is(this); }
     579             : 
     580             :   // Inspection.
     581             :   bool IsRange() { return IsKind(TypeBase::kRange); }
     582             :   bool IsHeapConstant() { return IsKind(TypeBase::kHeapConstant); }
     583             :   bool IsOtherNumberConstant() {
     584             :     return IsKind(TypeBase::kOtherNumberConstant);
     585             :   }
     586             :   bool IsTuple() { return IsKind(TypeBase::kTuple); }
     587             : 
     588             :   HeapConstantType* AsHeapConstant() { return HeapConstantType::cast(this); }
     589             :   OtherNumberConstantType* AsOtherNumberConstant() {
     590             :     return OtherNumberConstantType::cast(this);
     591             :   }
     592             :   RangeType* AsRange() { return RangeType::cast(this); }
     593             :   TupleType* AsTuple() { return TupleType::cast(this); }
     594             : 
     595             :   // Minimum and maximum of a numeric type.
     596             :   // These functions do not distinguish between -0 and +0.  If the type equals
     597             :   // kNaN, they return NaN; otherwise kNaN is ignored.  Only call these
     598             :   // functions on subtypes of Number.
     599             :   double Min();
     600             :   double Max();
     601             : 
     602             :   // Extracts a range from the type: if the type is a range or a union
     603             :   // containing a range, that range is returned; otherwise, NULL is returned.
     604             :   Type* GetRange();
     605             : 
     606             :   static bool IsInteger(i::Object* x);
     607             :   static bool IsInteger(double x) {
     608    17703425 :     return nearbyint(x) == x && !i::IsMinusZero(x);  // Allows for infinities.
     609             :   }
     610             : 
     611             :   int NumConstants();
     612             : 
     613             :   // Printing.
     614             : 
     615             :   void PrintTo(std::ostream& os);
     616             : 
     617             : #ifdef DEBUG
     618             :   void Print();
     619             : #endif
     620             : 
     621             :   // Helpers for testing.
     622             :   bool IsBitsetForTesting() { return IsBitset(); }
     623             :   bool IsUnionForTesting() { return IsUnion(); }
     624             :   bitset AsBitsetForTesting() { return AsBitset(); }
     625             :   UnionType* AsUnionForTesting() { return AsUnion(); }
     626             : 
     627             :  private:
     628             :   // Friends.
     629             :   template <class>
     630             :   friend class Iterator;
     631             :   friend BitsetType;
     632             :   friend UnionType;
     633             : 
     634             :   // Internal inspection.
     635             :   bool IsKind(TypeBase::Kind kind) { return TypeBase::IsKind(this, kind); }
     636             : 
     637             :   bool IsNone() { return this == None(); }
     638             :   bool IsAny() { return this == Any(); }
     639             :   bool IsBitset() { return BitsetType::IsBitset(this); }
     640             :   bool IsUnion() { return IsKind(TypeBase::kUnion); }
     641             : 
     642             :   bitset AsBitset() {
     643             :     DCHECK(this->IsBitset());
     644             :     return reinterpret_cast<BitsetType*>(this)->Bitset();
     645             :   }
     646             :   UnionType* AsUnion() { return UnionType::cast(this); }
     647             : 
     648    78541480 :   bitset BitsetGlb() { return BitsetType::Glb(this); }
     649   261277723 :   bitset BitsetLub() { return BitsetType::Lub(this); }
     650             : 
     651             :   bool SlowIs(Type* that);
     652             : 
     653             :   static bool Overlap(RangeType* lhs, RangeType* rhs);
     654             :   static bool Contains(RangeType* lhs, RangeType* rhs);
     655             :   static bool Contains(RangeType* range, i::Object* val);
     656             : 
     657             :   static int UpdateRange(Type* type, UnionType* result, int size, Zone* zone);
     658             : 
     659             :   static RangeType::Limits IntersectRangeAndBitset(Type* range, Type* bits,
     660             :                                                    Zone* zone);
     661             :   static RangeType::Limits ToLimits(bitset bits, Zone* zone);
     662             : 
     663             :   bool SimplyEquals(Type* that);
     664             : 
     665             :   static int AddToUnion(Type* type, UnionType* result, int size, Zone* zone);
     666             :   static int IntersectAux(Type* type, Type* other, UnionType* result, int size,
     667             :                           RangeType::Limits* limits, Zone* zone);
     668             :   static Type* NormalizeUnion(Type* unioned, int size, Zone* zone);
     669             :   static Type* NormalizeRangeAndBitset(Type* range, bitset* bits, Zone* zone);
     670             : };
     671             : 
     672             : }  // namespace compiler
     673             : }  // namespace internal
     674             : }  // namespace v8
     675             : 
     676             : #endif  // V8_COMPILER_TYPES_H_

Generated by: LCOV version 1.10