hphp/runtime/vm/jit/types.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_TRANSL_TYPES_H_
  18 #define incl_HPHP_TRANSL_TYPES_H_
  19
  20 #include <vector>
  21
  22 #include "hphp/util/assertions.h"
  23 #include "hphp/util/hash-map-typedefs.h"
  24 #include "hphp/runtime/base/types.h"
  25
  26 namespace HPHP { namespace jit {
  27
  28 ///////////////////////////////////////////////////////////////////////////////
  29
  30 /*
  31  * Core types.
  32  */
  33 typedef unsigned char* TCA; // "Translation cache address."
  34 typedef const unsigned char* CTCA;
  35
  36 using LowTCA = LowPtr<uint8_t>;
  37 using AtomicLowTCA = AtomicLowPtr<uint8_t,
  38                                   std::memory_order_acquire,
  39                                   std::memory_order_release>;
  40
  41 struct ctca_identity_hash {
  42   size_t operator()(CTCA val) const {
  43     // Experiments show that this is a sufficient "hash function" on
  44     // TCAs for now; using stronger functions didn't help given current
  45     // data. Patterns of code emission in the translator could invalidate
  46     // this finding going forward, though; e.g., if we frequently emit
  47     // a call instruction N bytes into a cache-aligned region.
  48     return uintptr_t(val);
  49   }
  50 };
  51
  52 ///////////////////////////////////////////////////////////////////////////////
  53
  54 using TransIDSet = hphp_hash_set<TransID>;
  55 using TransIDVec = std::vector<TransID>;
  56
  57 using Annotation = std::pair<std::string, std::string>;
  58 using Annotations = std::vector<Annotation>;
  59
  60 using LiteralMap = hphp_hash_map<uint64_t,const uint64_t*>;
  61
  62 ///////////////////////////////////////////////////////////////////////////////
  63
  64 /**
  65  * The different kinds of translations that the JIT generates:
  66  *
  67  *   - Anchor   : a service request for retranslating
  68  *   - Prologue : function prologue
  69  *   - Interp   : a service request to interpret at least one instruction
  70  *   - Live     : translate one tracelet by inspecting live VM state
  71  *   - Profile  : translate one block by inspecting live VM state and
  72  *                inserting profiling counters
  73  *   - Optimize : translate one region performing optimizations that may
  74  *                leverage data collected by Profile translations
  75  *   - Proflogue: a profiling function prologue
  76  */
  77 #define TRANS_KINDS \
  78     DO(Anchor)      \
  79     DO(Prologue)    \
  80     DO(Interp)      \
  81     DO(Live)        \
  82     DO(Profile)     \
  83     DO(Optimize)    \
  84     DO(Proflogue)   \
  85     DO(Invalid)     \
  86
  87 enum class TransKind {
  88 #define DO(KIND) KIND,
  89   TRANS_KINDS
  90 #undef DO
  91 };
  92
  93 constexpr size_t NumTransKinds =
  94 #define DO(KIND) + 1
  95   TRANS_KINDS
  96 #undef DO
  97   ;
  98
  99 inline std::string show(TransKind k) {
 100 #define DO(name) case TransKind::name: return "Trans" #name;
 101   switch (k) { TRANS_KINDS }
 102 #undef DO
 103   not_reached();
 104 }
 105
 106 /*
 107  * Compact flags which may be threaded through a service request to provide
 108  * hints or demands for retranslations.
 109  */
 110 struct TransFlags {
 111   /* implicit */ TransFlags(uint64_t flags = 0) : packed(flags) {}
 112
 113   union {
 114     struct {
 115       bool noinlineSingleton : 1;
 116       bool noProfiledFPush : 1;
 117     };
 118     uint64_t packed;
 119   };
 120 };
 121
 122 static_assert(sizeof(TransFlags) <= sizeof(uint64_t), "Too many TransFlags!");
 123
 124 ///////////////////////////////////////////////////////////////////////////////
 125
 126 /*
 127  * The "kind" of code being generated.
 128  *
 129  * Different contexts of code generation constrain codegen differently; e.g.,
 130  * cross-trace code has fewer available registers.
 131  */
 132 enum class CodeKind : uint8_t {
 133   /*
 134    * Normal PHP code in the TC.
 135    */
 136   Trace,
 137
 138   /*
 139    * Code at the TC boundaries, e.g., service requests, unique stubs.
 140    */
 141   CrossTrace,
 142
 143   /*
 144    * Helper code that uses scratch registers only.
 145    */
 146   Helper,
 147 };
 148
 149 /*
 150  * Enumeration representing the various areas that we emit code.
 151  *
 152  * kNumAreas must be kept up to date.
 153  */
 154 enum class AreaIndex : unsigned { Main, Cold, Frozen };
 155 constexpr size_t kNumAreas = 3;
 156
 157 inline std::string areaAsString(AreaIndex area) {
 158   switch (area) {
 159   case AreaIndex::Main:
 160     return "Main";
 161   case AreaIndex::Cold:
 162     return "Cold";
 163   case AreaIndex::Frozen:
 164     return "Frozen";
 165   }
 166   always_assert(false);
 167 }
 168
 169 ///////////////////////////////////////////////////////////////////////////////
 170
 171 /*
 172  * Some data structures are accessed often enough from translated code that we
 173  * have shortcuts for getting offsets into them.
 174  */
 175 #define TVOFF(nm) int(offsetof(TypedValue, nm))
 176 #define AROFF(nm) int(offsetof(ActRec, nm))
 177 #define AFWHOFF(nm) int(offsetof(c_AsyncFunctionWaitHandle, nm))
 178 #define GENDATAOFF(nm) int(offsetof(Generator, nm))
 179
 180 ///////////////////////////////////////////////////////////////////////////////
 181
 182 }}
 183
 184 #endif