Home | History | Annotate | Download | only in compiler 
      1 // Copyright 2015 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_TYPE_HINTS_H_
      6 #define V8_COMPILER_TYPE_HINTS_H_
      7 
      8 #include "src/base/flags.h"
      9 #include "src/utils.h"
     10 
     11 namespace v8 {
     12 namespace internal {
     13 namespace compiler {
     14 
     15 // Type hints for an binary operation.
     16 class BinaryOperationHints final {
     17  public:
     18   enum Hint {
     19     kNone,
     20     kSignedSmall,
     21     kSigned32,
     22     kNumberOrUndefined,
     23     kString,
     24     kAny
     25   };
     26 
     27   BinaryOperationHints() : BinaryOperationHints(kNone, kNone, kNone) {}
     28   BinaryOperationHints(Hint left, Hint right, Hint result)
     29       : bit_field_(LeftField::encode(left) | RightField::encode(right) |
     30                    ResultField::encode(result)) {}
     31 
     32   static BinaryOperationHints Any() {
     33     return BinaryOperationHints(kAny, kAny, kAny);
     34   }
     35 
     36   Hint left() const { return LeftField::decode(bit_field_); }
     37   Hint right() const { return RightField::decode(bit_field_); }
     38   Hint result() const { return ResultField::decode(bit_field_); }
     39   Hint combined() const { return Combine(Combine(left(), right()), result()); }
     40 
     41   // Hint 'subtyping' and generalization.
     42   static bool Is(Hint h1, Hint h2);
     43   static Hint Combine(Hint h1, Hint h2);
     44 
     45   bool operator==(BinaryOperationHints const& that) const {
     46     return this->bit_field_ == that.bit_field_;
     47   }
     48   bool operator!=(BinaryOperationHints const& that) const {
     49     return !(*this == that);
     50   }
     51 
     52   friend size_t hash_value(BinaryOperationHints const& hints) {
     53     return hints.bit_field_;
     54   }
     55 
     56  private:
     57   typedef BitField<Hint, 0, 3> LeftField;
     58   typedef BitField<Hint, 3, 3> RightField;
     59   typedef BitField<Hint, 6, 3> ResultField;
     60 
     61   uint32_t bit_field_;
     62 };
     63 
     64 std::ostream& operator<<(std::ostream&, BinaryOperationHints::Hint);
     65 std::ostream& operator<<(std::ostream&, BinaryOperationHints);
     66 
     67 // Type hints for an binary operation.
     68 class CompareOperationHints final {
     69  public:
     70   enum Hint {
     71     kNone,
     72     kBoolean,
     73     kSignedSmall,
     74     kNumber,
     75     kString,
     76     kInternalizedString,
     77     kUniqueName,
     78     kReceiver,
     79     kAny
     80   };
     81 
     82   CompareOperationHints() : CompareOperationHints(kNone, kNone, kNone) {}
     83   CompareOperationHints(Hint left, Hint right, Hint combined)
     84       : bit_field_(LeftField::encode(left) | RightField::encode(right) |
     85                    CombinedField::encode(combined)) {}
     86 
     87   static CompareOperationHints Any() {
     88     return CompareOperationHints(kAny, kAny, kAny);
     89   }
     90 
     91   Hint left() const { return LeftField::decode(bit_field_); }
     92   Hint right() const { return RightField::decode(bit_field_); }
     93   Hint combined() const { return CombinedField::decode(bit_field_); }
     94 
     95   bool operator==(CompareOperationHints const& that) const {
     96     return this->bit_field_ == that.bit_field_;
     97   }
     98   bool operator!=(CompareOperationHints const& that) const {
     99     return !(*this == that);
    100   }
    101 
    102   friend size_t hash_value(CompareOperationHints const& hints) {
    103     return hints.bit_field_;
    104   }
    105 
    106  private:
    107   typedef BitField<Hint, 0, 4> LeftField;
    108   typedef BitField<Hint, 4, 4> RightField;
    109   typedef BitField<Hint, 8, 4> CombinedField;
    110 
    111   uint32_t bit_field_;
    112 };
    113 
    114 std::ostream& operator<<(std::ostream&, CompareOperationHints::Hint);
    115 std::ostream& operator<<(std::ostream&, CompareOperationHints);
    116 
    117 // Type hints for the ToBoolean type conversion.
    118 enum class ToBooleanHint : uint16_t {
    119   kNone = 0u,
    120   kUndefined = 1u << 0,
    121   kBoolean = 1u << 1,
    122   kNull = 1u << 2,
    123   kSmallInteger = 1u << 3,
    124   kReceiver = 1u << 4,
    125   kString = 1u << 5,
    126   kSymbol = 1u << 6,
    127   kHeapNumber = 1u << 7,
    128   kSimdValue = 1u << 8,
    129   kAny = kUndefined | kBoolean | kNull | kSmallInteger | kReceiver | kString |
    130          kSymbol | kHeapNumber | kSimdValue
    131 };
    132 
    133 std::ostream& operator<<(std::ostream&, ToBooleanHint);
    134 
    135 typedef base::Flags<ToBooleanHint, uint16_t> ToBooleanHints;
    136 
    137 std::ostream& operator<<(std::ostream&, ToBooleanHints);
    138 
    139 DEFINE_OPERATORS_FOR_FLAGS(ToBooleanHints)
    140 
    141 }  // namespace compiler
    142 }  // namespace internal
    143 }  // namespace v8
    144 
    145 #endif  // V8_COMPILER_TYPE_HINTS_H_
    146