hphp/runtime/vm/jit/type-specialization.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 #ifndef incl_HPHP_JIT_TYPE_SPECIALIZATION_H_
  18 #define incl_HPHP_JIT_TYPE_SPECIALIZATION_H_
  19
  20 #include "hphp/runtime/base/array-data.h"
  21 #include "hphp/runtime/base/repo-auth-type.h"
  22
  23 #include <folly/Optional.h>
  24
  25 #include <cstdint>
  26
  27 namespace HPHP {
  28 ///////////////////////////////////////////////////////////////////////////////
  29
  30 struct Class;
  31 struct Shape;
  32
  33 namespace jit {
  34 ///////////////////////////////////////////////////////////////////////////////
  35
  36 /*
  37  * Array type specialization.
  38  *
  39  * May contain an ArrayKind and/or a pointer to a RAT or a Shape.
  40  */
  41 struct ArraySpec {
  42   /*
  43    * Constructors.
  44    */
  45   constexpr ArraySpec();
  46   explicit ArraySpec(ArrayData::ArrayKind kind);
  47   explicit ArraySpec(const RepoAuthType::Array* arrTy);
  48   ArraySpec(ArrayData::ArrayKind kind, const RepoAuthType::Array* arrTy);
  49   explicit ArraySpec(const Shape* shape);
  50
  51   /*
  52    * Accessors.
  53    *
  54    * These return falsey values (folly::none or nullptr) if the respective bit
  55    * in `m_sort' is not set.
  56    *
  57    * bits() returns the raw bits.
  58    */
  59   uintptr_t bits() const;
  60   folly::Optional<ArrayData::ArrayKind> kind() const;
  61   const RepoAuthType::Array* type() const;
  62   const Shape* shape() const;
  63
  64   /*
  65    * Casts.
  66    *
  67    * Bottom and Top cast to false; everything else casts to true.
  68    */
  69   explicit operator bool() const;
  70
  71   /*
  72    * Comparisons.
  73    */
  74   bool operator==(const ArraySpec& rhs) const;
  75   bool operator!=(const ArraySpec& rhs) const;
  76   bool operator<=(const ArraySpec& rhs) const;
  77   bool operator>=(const ArraySpec& rhs) const;
  78   bool operator<(const ArraySpec& rhs) const;
  79   bool operator>(const ArraySpec& rhs) const;
  80
  81   /*
  82    * Combinators.
  83    */
  84   ArraySpec operator|(const ArraySpec& rhs) const;
  85   ArraySpec operator&(const ArraySpec& rhs) const;
  86   ArraySpec operator-(const ArraySpec& rhs) const;
  87
  88   /*
  89    * Top and bottom types.
  90    */
  91   static const ArraySpec Top;
  92   static const ArraySpec Bottom;
  93
  94 private:
  95   /*
  96    * Bottom constructor.
  97    */
  98   enum class BottomTag {};
  99   explicit ArraySpec(BottomTag);
 100
 101   /*
 102    * Mask of specializations that a given ArraySpec represents.
 103    */
 104   enum SortOf : uint8_t {
 105     IsTop     = 0,
 106     IsBottom  = 1 << 0,
 107     HasKind   = 1 << 1,
 108     HasType   = 1 << 2,
 109     HasShape  = 1 << 3,
 110   };
 111   friend SortOf operator|(SortOf, SortOf);
 112   friend SortOf operator&(SortOf, SortOf);
 113
 114   /*
 115    * Data members.
 116    */
 117   union {
 118     struct {
 119       uintptr_t m_sort : 8;
 120       uintptr_t m_kind : 8;
 121       uintptr_t m_ptr : 48;
 122     };
 123     uintptr_t m_bits;
 124   };
 125 };
 126
 127 ArraySpec::SortOf operator|(ArraySpec::SortOf l, ArraySpec::SortOf r);
 128 ArraySpec::SortOf operator&(ArraySpec::SortOf l, ArraySpec::SortOf r);
 129
 130 ///////////////////////////////////////////////////////////////////////////////
 131
 132 /*
 133  * Class type specialization.
 134  */
 135 struct ClassSpec {
 136   /*
 137    * Constructor tags.
 138    */
 139   enum class SubTag {};
 140   enum class ExactTag {};
 141
 142   /*
 143    * Constructors.
 144    */
 145   constexpr ClassSpec();
 146   ClassSpec(const Class* cls, SubTag);
 147   ClassSpec(const Class* cls, ExactTag);
 148
 149   /*
 150    * Accessors.
 151    */
 152   uintptr_t bits() const;
 153   bool exact() const;
 154   const Class* cls() const;
 155   const Class* exactCls() const;
 156
 157   /*
 158    * Casts.
 159    *
 160    * Bottom and Top cast to false; everything else casts to true.
 161    */
 162   explicit operator bool() const;
 163
 164   /*
 165    * Comparisons.
 166    */
 167   bool operator==(const ClassSpec& rhs) const;
 168   bool operator!=(const ClassSpec& rhs) const;
 169   bool operator<=(const ClassSpec& rhs) const;
 170   bool operator>=(const ClassSpec& rhs) const;
 171   bool operator<(const ClassSpec& rhs) const;
 172   bool operator>(const ClassSpec& rhs) const;
 173
 174   /*
 175    * Combinators.
 176    */
 177   ClassSpec operator|(const ClassSpec& rhs) const;
 178   ClassSpec operator&(const ClassSpec& rhs) const;
 179   ClassSpec operator-(const ClassSpec& rhs) const;
 180
 181   /*
 182    * Top and bottom types.
 183    */
 184   static const ClassSpec Top;
 185   static const ClassSpec Bottom;
 186
 187 private:
 188   /*
 189    * Bottom constructor.
 190    */
 191   enum class BottomTag {};
 192   explicit ClassSpec(BottomTag);
 193
 194   /*
 195    * Sort tag.
 196    */
 197   enum SortOf : uint8_t {
 198     IsTop,
 199     IsBottom,
 200     IsSub,
 201     IsExact,
 202   };
 203
 204   /*
 205    * Data members.
 206    */
 207   union {
 208     struct {
 209       uintptr_t m_sort : 8;
 210       uintptr_t m_ptr : 56;
 211     };
 212     uintptr_t m_bits;
 213   };
 214 };
 215
 216 ///////////////////////////////////////////////////////////////////////////////
 217
 218 /*
 219  * Specialization kinds.
 220  */
 221 enum class SpecKind : uint8_t {
 222   None = 0,
 223   Array = 1 << 0,
 224   Class = 1 << 1,
 225 };
 226
 227 SpecKind operator|(SpecKind l, SpecKind r);
 228 SpecKind operator&(SpecKind l, SpecKind r);
 229 SpecKind& operator|=(SpecKind& l, SpecKind r);
 230
 231 /*
 232  * Discriminated specialization union.
 233  *
 234  * Used to encapsulate combinator logic.
 235  */
 236 struct TypeSpec {
 237   /*
 238    * Constructors.
 239    */
 240   TypeSpec();
 241   TypeSpec(ArraySpec, ClassSpec);
 242
 243   /*
 244    * Accessors.
 245    */
 246   SpecKind kind() const;
 247   ArraySpec arrSpec() const;
 248   ClassSpec clsSpec() const;
 249
 250   /*
 251    * Comparisons.
 252    */
 253   bool operator==(const TypeSpec& rhs) const;
 254   bool operator!=(const TypeSpec& rhs) const;
 255   bool operator<=(const TypeSpec& rhs) const;
 256   bool operator>=(const TypeSpec& rhs) const;
 257
 258   /*
 259    * Combinators.
 260    */
 261   TypeSpec operator|(const TypeSpec& rhs) const;
 262   TypeSpec operator&(const TypeSpec& rhs) const;
 263   TypeSpec operator-(const TypeSpec& rhs) const;
 264
 265 private:
 266   /*
 267    * Data members.
 268    */
 269   SpecKind m_kind;
 270   ArraySpec m_arrSpec;
 271   ClassSpec m_clsSpec;
 272 };
 273
 274 ///////////////////////////////////////////////////////////////////////////////
 275 }}
 276
 277 #include "hphp/runtime/vm/jit/type-specialization-inl.h"
 278
 279 #endif