hphp/runtime/vm/jit/type-specialization-inl.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-2016 Facebook, Inc. (http://www.facebook.com)     |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 namespace HPHP { namespace jit {
  18 ///////////////////////////////////////////////////////////////////////////////
  19
  20 inline SpecKind operator|(SpecKind l, SpecKind r) {
  21   return static_cast<SpecKind>(
  22       static_cast<uint8_t>(l) | static_cast<uint8_t>(r));
  23 }
  24
  25 inline SpecKind operator&(SpecKind l, SpecKind r) {
  26   return static_cast<SpecKind>(
  27       static_cast<uint8_t>(l) & static_cast<uint8_t>(r));
  28 }
  29
  30 inline SpecKind& operator|=(SpecKind& l, SpecKind r) {
  31   return l = l | r;
  32 }
  33
  34 ///////////////////////////////////////////////////////////////////////////////
  35
  36 inline TypeSpec::TypeSpec()
  37   : m_kind(SpecKind::None)
  38 {}
  39
  40 inline TypeSpec::TypeSpec(ArraySpec arrSpec, ClassSpec clsSpec)
  41   : m_kind(SpecKind::None)
  42   , m_arrSpec(arrSpec)
  43   , m_clsSpec(clsSpec)
  44 {
  45   if (arrSpec != ArraySpec::Bottom) m_kind |= SpecKind::Array;
  46   if (clsSpec != ClassSpec::Bottom) m_kind |= SpecKind::Class;
  47 }
  48
  49 inline SpecKind TypeSpec::kind() const {
  50   return m_kind;
  51 }
  52
  53 inline ArraySpec TypeSpec::arrSpec() const {
  54   return m_arrSpec;
  55 }
  56
  57 inline ClassSpec TypeSpec::clsSpec() const {
  58   return m_clsSpec;
  59 }
  60
  61 inline bool TypeSpec::operator==(const TypeSpec& rhs) const {
  62   auto const& lhs = *this;
  63   return lhs.arrSpec() == rhs.arrSpec() &&
  64          lhs.clsSpec() == rhs.clsSpec();
  65 }
  66
  67 inline bool TypeSpec::operator!=(const TypeSpec& rhs) const {
  68   return !(*this == rhs);
  69 }
  70
  71 inline bool TypeSpec::operator<=(const TypeSpec& rhs) const {
  72   auto const& lhs = *this;
  73   return lhs.arrSpec() <= rhs.arrSpec() &&
  74          lhs.clsSpec() <= rhs.clsSpec();
  75 }
  76
  77 inline bool TypeSpec::operator>=(const TypeSpec& rhs) const {
  78   return rhs <= *this;
  79 }
  80
  81 inline TypeSpec TypeSpec::operator|(const TypeSpec& rhs) const {
  82   auto const& lhs = *this;
  83   return TypeSpec(lhs.arrSpec() | rhs.arrSpec(),
  84                   lhs.clsSpec() | rhs.clsSpec());
  85 }
  86
  87 inline TypeSpec TypeSpec::operator&(const TypeSpec& rhs) const {
  88   auto const& lhs = *this;
  89   return TypeSpec(lhs.arrSpec() & rhs.arrSpec(),
  90                   lhs.clsSpec() & rhs.clsSpec());
  91 }
  92
  93 inline TypeSpec TypeSpec::operator-(const TypeSpec& rhs) const {
  94   auto const& lhs = *this;
  95   return TypeSpec(lhs.arrSpec() - rhs.arrSpec(),
  96                   lhs.clsSpec() - rhs.clsSpec());
  97 }
  98
  99 ///////////////////////////////////////////////////////////////////////////////
 100
 101 #define IMPLEMENT_SPEC_OPERS(Spec)                        \
 102   inline uintptr_t Spec::bits() const {                   \
 103     return m_bits;                                        \
 104   }                                                       \
 105   inline Spec::operator bool() const {                    \
 106     return *this != Top && *this != Spec::Bottom;         \
 107   }                                                       \
 108   inline bool Spec::operator==(const Spec& rhs) const {   \
 109     return m_bits == rhs.m_bits;                          \
 110   }                                                       \
 111   inline bool Spec::operator!=(const Spec& rhs) const {   \
 112     return !(*this == rhs);                               \
 113   }                                                       \
 114   inline bool Spec::operator>=(const Spec& rhs) const {   \
 115     return rhs <= *this;                                  \
 116   }                                                       \
 117   inline bool Spec::operator<(const Spec& rhs) const {    \
 118     return *this <= rhs && *this != rhs;                  \
 119   }                                                       \
 120   inline bool Spec::operator>(const Spec& rhs) const {    \
 121     return *this >= rhs && *this != rhs;                  \
 122   }                                                       \
 123   inline Spec Spec::operator-(const Spec& rhs) const {    \
 124     return *this <= rhs ? Bottom : *this;                 \
 125   }
 126
 127 ///////////////////////////////////////////////////////////////////////////////
 128 // ArraySpec.
 129
 130 constexpr inline ArraySpec::ArraySpec()
 131   : m_sort(IsTop)
 132   , m_kind(ArrayData::ArrayKind{})
 133   , m_ptr(0)
 134 {}
 135
 136 inline ArraySpec::ArraySpec(ArraySpec::BottomTag)
 137   : m_sort(IsBottom)
 138   , m_kind(ArrayData::ArrayKind{})
 139   , m_ptr(0)
 140 {}
 141
 142 inline ArraySpec::ArraySpec(ArrayData::ArrayKind kind)
 143   : m_sort(HasKind)
 144   , m_kind(kind)
 145   , m_ptr(0)
 146 {}
 147
 148 inline ArraySpec::ArraySpec(const RepoAuthType::Array* arrTy)
 149   : m_sort(HasType)
 150   , m_kind(ArrayData::ArrayKind{})
 151   , m_ptr(reinterpret_cast<uintptr_t>(arrTy))
 152 {}
 153
 154 inline ArraySpec::ArraySpec(ArrayData::ArrayKind kind,
 155                             const RepoAuthType::Array* arrTy)
 156   : m_sort(HasKind | HasType)
 157   , m_kind(kind)
 158   , m_ptr(reinterpret_cast<uintptr_t>(arrTy))
 159 {}
 160
 161 inline folly::Optional<ArrayData::ArrayKind> ArraySpec::kind() const {
 162   auto kind = static_cast<ArrayData::ArrayKind>(m_kind);
 163   return (m_sort & HasKind) ? folly::make_optional(kind) : folly::none;
 164 }
 165
 166 inline const RepoAuthType::Array* ArraySpec::type() const {
 167   return (m_sort & HasType)
 168     ? reinterpret_cast<const RepoAuthType::Array*>(m_ptr)
 169     : nullptr;
 170 }
 171
 172 IMPLEMENT_SPEC_OPERS(ArraySpec)
 173
 174 ///////////////////////////////////////////////////////////////////////////////
 175
 176 inline ArraySpec::SortOf operator|(ArraySpec::SortOf l, ArraySpec::SortOf r) {
 177   return static_cast<ArraySpec::SortOf>(
 178       static_cast<uint8_t>(l) | static_cast<uint8_t>(r));
 179 }
 180
 181 inline ArraySpec::SortOf operator&(ArraySpec::SortOf l, ArraySpec::SortOf r) {
 182   return static_cast<ArraySpec::SortOf>(
 183       static_cast<uint8_t>(l) & static_cast<uint8_t>(r));
 184 }
 185
 186 ///////////////////////////////////////////////////////////////////////////////
 187 // ClassSpec.
 188
 189 constexpr inline ClassSpec::ClassSpec()
 190   : m_sort(IsTop)
 191   , m_ptr(0)
 192 {}
 193
 194 inline ClassSpec::ClassSpec(ClassSpec::BottomTag)
 195   : m_sort(IsBottom)
 196   , m_ptr(0)
 197 {}
 198
 199 inline ClassSpec::ClassSpec(const Class* cls, ClassSpec::SubTag)
 200   : m_sort(IsSub)
 201   , m_ptr(reinterpret_cast<uintptr_t>(cls))
 202 {}
 203
 204 inline ClassSpec::ClassSpec(const Class* cls, ClassSpec::ExactTag)
 205   : m_sort(IsExact)
 206   , m_ptr(reinterpret_cast<uintptr_t>(cls))
 207 {}
 208
 209 inline bool ClassSpec::exact() const {
 210   return m_sort == IsExact;
 211 }
 212
 213 inline const Class* ClassSpec::cls() const {
 214   return (m_sort == IsSub || m_sort == IsExact)
 215     ? reinterpret_cast<const Class*>(m_ptr)
 216     : nullptr;
 217 }
 218
 219 inline const Class* ClassSpec::exactCls() const {
 220   return (m_sort == IsExact)
 221     ? reinterpret_cast<const Class*>(m_ptr)
 222     : nullptr;
 223 }
 224
 225 IMPLEMENT_SPEC_OPERS(ClassSpec)
 226
 227 ///////////////////////////////////////////////////////////////////////////////
 228
 229 #undef IMPLEMENT_SPEC_OPERS
 230
 231 }}