hphp/runtime/vm/srckey.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present 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 #ifndef incl_HPHP_SRCKEY_H_
  17 #define incl_HPHP_SRCKEY_H_
  18
  19 #include "hphp/runtime/vm/hhbc.h"
  20 #include "hphp/runtime/vm/resumable.h"
  21
  22 #include <boost/operators.hpp>
  23
  24 namespace HPHP {
  25
  26 ///////////////////////////////////////////////////////////////////////////////
  27
  28 namespace arrprov { struct Tag; }
  29
  30 struct Func;
  31 struct Unit;
  32
  33 ///////////////////////////////////////////////////////////////////////////////
  34
  35 /*
  36  * A SrcKey is a logical source instruction---it's enough to identify
  37  * these using a (Func id, hhbc instruction) pair.
  38  */
  39 struct SrcKey : private boost::totally_ordered<SrcKey> {
  40   static_assert(sizeof(FuncId) == sizeof(uint32_t), "");
  41   static_assert(sizeof(Offset) == sizeof(uint32_t), "");
  42
  43   /////////////////////////////////////////////////////////////////////////////
  44   // Types.
  45
  46   using AtomicInt = uint64_t;
  47
  48   struct Hasher;
  49   struct TbbHashCompare;
  50
  51   /*
  52    * Used for SrcKeys corresponding to the prologue which precedes a function
  53    * entry source location.
  54    *
  55    * Used disjointly from the `resumeMode'.
  56    */
  57   enum class PrologueTag {};
  58
  59   /////////////////////////////////////////////////////////////////////////////
  60
  61   /*
  62    * Invalid SrcKey constructor.
  63    */
  64   SrcKey();
  65
  66   SrcKey(const Func* f, Offset off, ResumeMode resumeMode);
  67   SrcKey(const Func* f, PC pc, ResumeMode resumeMode);
  68   SrcKey(FuncId funcId, Offset off, ResumeMode resumeMode);
  69
  70   SrcKey(const Func* f, Offset off, PrologueTag);
  71   SrcKey(const Func* f, PC pc, PrologueTag);
  72   SrcKey(FuncId funcId, Offset off, PrologueTag);
  73
  74   SrcKey(SrcKey other, Offset off);
  75
  76   explicit SrcKey(AtomicInt in);
  77   static SrcKey fromAtomicInt(AtomicInt in);
  78
  79   /////////////////////////////////////////////////////////////////////////////
  80
  81   /*
  82    * Whether the SrcKey has a valid FuncId.
  83    *
  84    * Does not check for validity of any other fields.
  85    */
  86   bool valid() const;
  87
  88   /*
  89    * Packed representation of SrcKeys for use in contexts (e.g. the SrcDB)
  90    * where we want atomicity.
  91    */
  92   AtomicInt toAtomicInt() const;
  93
  94   /*
  95    * Direct accessors.
  96    */
  97   FuncId funcID() const;
  98   int offset() const;
  99   bool prologue() const;
 100   ResumeMode resumeMode() const;
 101   bool hasThis() const;
 102
 103   /*
 104    * Derived accessors.
 105    */
 106   const Func* func() const;
 107   const Unit* unit() const;
 108   Op op() const;
 109   PC pc() const;
 110
 111   /////////////////////////////////////////////////////////////////////////////
 112
 113   /*
 114    * Set this SrcKey's offset.
 115    *
 116    * Does not perform any bounds or consistency checks.
 117    */
 118   void setOffset(Offset o);
 119
 120   /*
 121    * Get all possible Offsets for the next bytecode.
 122    */
 123   OffsetSet succOffsets() const;
 124
 125   /*
 126    * Advance the SrcKey to the next instruction.
 127    *
 128    * If the SrcKey points to the last instruction in a function, this will
 129    * advance past the end of the function, and potentially contain an invalid
 130    * bytecode offset.
 131    */
 132   void advance(const Unit* u = nullptr);
 133
 134   /*
 135    * Return a SrcKey representing the next instruction, without mutating this
 136    * SrcKey.
 137    */
 138   SrcKey advanced(const Unit* u = nullptr) const;
 139
 140   /////////////////////////////////////////////////////////////////////////////
 141
 142   /*
 143    * Comparisons.
 144    *
 145    * SrcKeys are ordered by their AtomicInt values.
 146    */
 147   bool operator==(const SrcKey& r) const;
 148   bool operator<(const SrcKey& r) const;
 149
 150   /*
 151    * Stringification.
 152    */
 153   std::string showInst() const;
 154   std::string getSymbol() const;
 155
 156   /////////////////////////////////////////////////////////////////////////////
 157
 158 private:
 159   uint32_t encodeResumeMode(ResumeMode resumeMode);
 160   uint32_t encodePrologue();
 161
 162   /////////////////////////////////////////////////////////////////////////////
 163
 164   union {
 165     AtomicInt m_atomicInt;
 166     struct {
 167       FuncId m_funcID;
 168       uint32_t m_offset : 30;
 169       uint32_t m_resumeModeAndPrologue : 2;
 170     };
 171   };
 172 };
 173
 174 ///////////////////////////////////////////////////////////////////////////////
 175
 176 struct SrcKey::Hasher {
 177   size_t operator()(SrcKey sk) const {
 178     return hash_int64(sk.toAtomicInt());
 179   }
 180 };
 181
 182 using SrcKeySet = hphp_hash_set<SrcKey,SrcKey::Hasher>;
 183
 184 ///////////////////////////////////////////////////////////////////////////////
 185
 186 struct SrcKey::TbbHashCompare {
 187   static size_t hash(const SrcKey& sk) { return hash_int64(sk.toAtomicInt()); }
 188   static bool equal(const SrcKey& a, const SrcKey& b) { return a == b; }
 189 };
 190
 191 ///////////////////////////////////////////////////////////////////////////////
 192
 193 std::string show(SrcKey sk);
 194 std::string showShort(SrcKey sk);
 195
 196 void sktrace(SrcKey sk, ATTRIBUTE_PRINTF_STRING const char *fmt, ...)
 197   ATTRIBUTE_PRINTF(2,3);
 198 #define SKTRACE(level, sk, ...) \
 199   ONTRACE(level, sktrace(sk, __VA_ARGS__))
 200
 201 ///////////////////////////////////////////////////////////////////////////////
 202
 203 }
 204
 205 #include "hphp/runtime/vm/srckey-inl.h"
 206
 207 #endif