hphp/runtime/vm/srckey-inl.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
  17 #include "hphp/runtime/vm/func.h"
  18
  19 namespace HPHP {
  20
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 inline SrcKey::SrcKey()
  24   : m_s{FuncId::Invalid, 0, encodeResumeMode(ResumeMode::None)}
  25 {}
  26
  27 inline SrcKey::SrcKey(const Func* f, Offset off, ResumeMode resumeMode)
  28   : m_s{f->getFuncId(), (uint32_t)off, encodeResumeMode(resumeMode)}
  29 {
  30   assertx((uint32_t)off >> kNumOffsetBits == 0);
  31 }
  32
  33 inline SrcKey::SrcKey(const Func* f, PC pc, ResumeMode resumeMode)
  34   : m_s{f->getFuncId(), (uint32_t)f->offsetOf(pc), encodeResumeMode(resumeMode)}
  35 {
  36   assertx((uint32_t)f->offsetOf(pc) >> kNumOffsetBits == 0);
  37 }
  38
  39 inline SrcKey::SrcKey(FuncId funcId, Offset off, ResumeMode resumeMode)
  40   : m_s{funcId, (uint32_t)off, encodeResumeMode(resumeMode)}
  41 {
  42   assertx((uint32_t)off >> kNumOffsetBits == 0);
  43 }
  44
  45 inline SrcKey::SrcKey(const Func* f, uint32_t numArgs, PrologueTag)
  46   : m_s{f->getFuncId(), numArgs, encodePrologue()}
  47 {
  48   assertx(numArgs >> kNumOffsetBits == 0);
  49 }
  50
  51 inline SrcKey::SrcKey(const Func* f, uint32_t numArgs, FuncEntryTag)
  52   : m_s{f->getFuncId(), numArgs, encodeFuncEntry()}
  53 {
  54   assertx(numArgs >> kNumOffsetBits == 0);
  55 }
  56
  57 inline SrcKey::SrcKey(SrcKey other, Offset off)
  58   : m_s{other.funcID(), (uint32_t)off, other.m_s.m_resumeModeAndTags}
  59 {
  60   assertx((uint32_t)off >> kNumOffsetBits == 0);
  61 }
  62
  63 inline SrcKey::SrcKey(AtomicInt in)
  64   : m_atomicInt{in}
  65 {}
  66
  67 inline SrcKey SrcKey::fromAtomicInt(AtomicInt in) {
  68   return SrcKey {in};
  69 }
  70
  71 ///////////////////////////////////////////////////////////////////////////////
  72
  73 inline bool SrcKey::valid() const {
  74   auto const funcID = m_s.m_funcID;
  75   assertx(
  76     funcID.isInvalid() || funcID.isDummy() ||
  77     (prologue() && numEntryArgs() <= func()->numNonVariadicParams() + 1) ||
  78     (funcEntry() && numEntryArgs() <= func()->numNonVariadicParams()) ||
  79     (!prologue() && !funcEntry() && offset() < func()->bclen())
  80   );
  81   return !funcID.isInvalid();
  82 }
  83
  84 inline SrcKey::AtomicInt SrcKey::toAtomicInt() const {
  85   return m_atomicInt;
  86 }
  87
  88 inline size_t SrcKey::stableHash() const {
  89   return folly::hash::hash_combine(
  90     func()->stableHash(),
  91     m_s.m_offsetOrNumArgs,
  92     m_s.m_resumeModeAndTags
  93   );
  94 }
  95
  96 inline FuncId SrcKey::funcID() const {
  97   assertx(!m_s.m_funcID.isInvalid());
  98   return m_s.m_funcID;
  99 }
 100
 101 inline Offset SrcKey::offset() const {
 102   assertx(!prologue() && !funcEntry());
 103   return m_s.m_offsetOrNumArgs;
 104 }
 105
 106 inline Offset SrcKey::entryOffset() const {
 107   assertx(prologue() || funcEntry());
 108   return func()->getEntryForNumArgs(numEntryArgs());
 109 }
 110
 111 inline uint32_t SrcKey::numEntryArgs() const {
 112   assertx(prologue() || funcEntry());
 113   return m_s.m_offsetOrNumArgs;
 114 }
 115
 116 inline std::string SrcKey::printableOffset() const {
 117   auto const off = !prologue() && !funcEntry() ? offset() : entryOffset();
 118   return std::to_string(off);
 119 }
 120
 121 inline bool SrcKey::hasThis() const {
 122   if (!func()->cls()) return false;
 123   return prologue() ? !func()->isStaticInPrologue() : !func()->isStatic();
 124 }
 125
 126 inline ResumeMode SrcKey::resumeMode() const {
 127   return m_s.m_resumeModeAndTags < 3
 128     ? (ResumeMode)m_s.m_resumeModeAndTags : ResumeMode::None;
 129 }
 130
 131 inline bool SrcKey::prologue() const {
 132   return m_s.m_resumeModeAndTags == 3;
 133 }
 134
 135 inline bool SrcKey::funcEntry() const {
 136   return m_s.m_resumeModeAndTags == 4;
 137 }
 138
 139 inline uint32_t SrcKey::encodeResumeMode(ResumeMode resumeMode) {
 140   assertx((uint8_t)resumeMode >> kNumModeBits == 0);
 141   assertx((uint8_t)resumeMode < 3);
 142   return (uint8_t)resumeMode;
 143 }
 144
 145 inline uint32_t SrcKey::encodePrologue() {
 146   assertx(3 >> kNumModeBits == 0);
 147   return 3;
 148 }
 149
 150 inline uint32_t SrcKey::encodeFuncEntry() {
 151   assertx(4 >> kNumModeBits == 0);
 152   return 4;
 153 }
 154
 155 inline const Func* SrcKey::func() const {
 156   return Func::fromFuncId(m_s.m_funcID);
 157 }
 158
 159 inline const Unit* SrcKey::unit() const {
 160   return func()->unit();
 161 }
 162
 163 inline Op SrcKey::op() const {
 164   assertx(!prologue() && !funcEntry());
 165   return func()->getOp(offset());
 166 }
 167
 168 inline PC SrcKey::pc() const {
 169   assertx(!prologue() && !funcEntry());
 170   return func()->at(offset());
 171 }
 172
 173 inline int SrcKey::lineNumber() const {
 174   if (prologue() || funcEntry()) return func()->line1();
 175   return func()->getLineNumber(offset());
 176 }
 177
 178 ///////////////////////////////////////////////////////////////////////////////
 179
 180 inline void SrcKey::setOffset(Offset o) {
 181   assertx((uint32_t)o >> kNumOffsetBits == 0);
 182   assertx(!prologue() && !funcEntry());
 183   m_s.m_offsetOrNumArgs = (uint32_t)o;
 184 }
 185
 186 inline OffsetSet SrcKey::succOffsets() const {
 187   assertx(!prologue());
 188   if (funcEntry()) return {entryOffset()};
 189   return instrSuccOffsets(pc(), func());
 190 }
 191
 192 inline void SrcKey::advance(const Func* f) {
 193   assertx(!prologue());
 194   if (funcEntry()) {
 195     m_s.m_offsetOrNumArgs = entryOffset();
 196     m_s.m_resumeModeAndTags = encodeResumeMode(ResumeMode::None);
 197   } else {
 198     m_s.m_offsetOrNumArgs += instrLen((f ? f : func())->at(offset()));
 199   }
 200 }
 201
 202 inline SrcKey SrcKey::advanced(const Func* f) const {
 203   auto tmp = *this;
 204   tmp.advance(f);
 205   return tmp;
 206 }
 207
 208 inline SrcKey SrcKey::withFuncID(FuncId funcId) const {
 209   auto tmp = *this;
 210   tmp.m_s.m_funcID = funcId;
 211   return tmp;
 212 }
 213
 214 inline bool SrcKey::operator==(const SrcKey& r) const {
 215   return m_atomicInt == r.m_atomicInt;
 216 }
 217
 218 inline bool SrcKey::operator!=(const SrcKey& r) const {
 219   return m_atomicInt != r.m_atomicInt;
 220 }
 221
 222 ///////////////////////////////////////////////////////////////////////////////
 223
 224 }