hphp/runtime/vm/act-rec-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/util/compilation-flags.h"
  18
  19 #include "hphp/runtime/vm/func.h"
  20
  21 namespace HPHP {
  22
  23 ///////////////////////////////////////////////////////////////////////////////
  24
  25 inline const Func* ActRec::func() const {
  26   return m_func;
  27 }
  28
  29 inline const Unit* ActRec::unit() const {
  30   func()->validate();
  31   return func()->unit();
  32 }
  33
  34 inline ActRec* ActRec::sfp() const {
  35   if (UNLIKELY(((uintptr_t)m_sfp - s_stackLimit) < s_stackSize)) {
  36     return nullptr;
  37   }
  38   return m_sfp;
  39 }
  40
  41 ///////////////////////////////////////////////////////////////////////////////
  42
  43 inline int32_t ActRec::numArgs() const {
  44   return m_numArgsAndFlags & kNumArgsMask;
  45 }
  46
  47 inline ActRec::Flags ActRec::flags() const {
  48   return static_cast<Flags>(m_numArgsAndFlags & kFlagsMask);
  49 }
  50
  51 inline bool ActRec::useWeakTypes() const {
  52   return flags() & UseWeakTypes;
  53 }
  54
  55 inline bool ActRec::localsDecRefd() const {
  56   return flags() & LocalsDecRefd;
  57 }
  58
  59 inline bool ActRec::resumed() const {
  60   return (flags() & kExecutionModeMask) == InResumed;
  61 }
  62
  63 inline bool ActRec::isFCallAwait() const {
  64   return (flags() & kExecutionModeMask) == IsFCallAwait;
  65 }
  66
  67 inline bool ActRec::mayNeedStaticWaitHandle() const {
  68   return !(m_numArgsAndFlags & (InResumed|IsFCallAwait));
  69 }
  70
  71 inline bool ActRec::magicDispatch() const {
  72   return (flags() & kExecutionModeMask) == MagicDispatch;
  73 }
  74
  75 inline uint32_t ActRec::encodeNumArgsAndFlags(uint32_t numArgs, Flags flags) {
  76   assert((numArgs & kFlagsMask) == 0);
  77   assert((uint32_t{flags} & kNumArgsMask) == 0);
  78   return numArgs | flags;
  79 }
  80
  81 inline void ActRec::initNumArgs(uint32_t numArgs) {
  82   m_numArgsAndFlags = encodeNumArgsAndFlags(numArgs, Flags::None);
  83 }
  84
  85 inline void ActRec::setNumArgs(uint32_t numArgs) {
  86   m_numArgsAndFlags = encodeNumArgsAndFlags(numArgs, flags());
  87 }
  88
  89 inline void ActRec::setUseWeakTypes() {
  90   m_numArgsAndFlags |= UseWeakTypes;
  91 }
  92
  93 inline void ActRec::setLocalsDecRefd() {
  94   m_numArgsAndFlags |= LocalsDecRefd;
  95 }
  96
  97 inline void ActRec::setResumed() {
  98   assert((flags() & ~IsFCallAwait) == Flags::None);
  99   m_numArgsAndFlags = encodeNumArgsAndFlags(numArgs(), InResumed);
 100 }
 101
 102 inline void ActRec::setFCallAwait() {
 103   assert(flags() == Flags::None);
 104   m_numArgsAndFlags = encodeNumArgsAndFlags(numArgs(), IsFCallAwait);
 105 }
 106
 107 inline void ActRec::setMagicDispatch(StringData* invName) {
 108   assertx(!resumed());
 109   m_numArgsAndFlags |= MagicDispatch;
 110   m_invName = invName;
 111 }
 112
 113 inline StringData* ActRec::clearMagicDispatch() {
 114   assert(magicDispatch());
 115   auto const invName = getInvName();
 116   m_numArgsAndFlags = encodeNumArgsAndFlags(
 117     numArgs(),
 118     static_cast<Flags>(flags() & ~MagicDispatch)
 119   );
 120   trashVarEnv();
 121   return invName;
 122 }
 123
 124 ///////////////////////////////////////////////////////////////////////////////
 125
 126 inline void* ActRec::encodeThis(ObjectData* obj) {
 127   return obj;
 128 }
 129
 130 inline void* ActRec::encodeClass(const Class* cls) {
 131   return cls
 132     ? (void*)(reinterpret_cast<uintptr_t>(cls) | kHasClassBit)
 133     : nullptr;
 134 }
 135
 136 inline bool ActRec::checkThis(void* p) {
 137   assertx(p);
 138   return !(reinterpret_cast<uintptr_t>(p) & kHasClassBit);
 139 }
 140
 141 inline bool ActRec::checkThisOrNull(void* p) {
 142   return !(reinterpret_cast<uintptr_t>(p) & kHasClassBit);
 143 }
 144
 145 inline ObjectData* ActRec::decodeThis(void* p) {
 146   return checkThisOrNull(p) ? (ObjectData*)p : nullptr;
 147 }
 148
 149 inline Class* ActRec::decodeClass(void* p) {
 150   return checkThisOrNull(p) ? nullptr :
 151     (Class*)(reinterpret_cast<uintptr_t>(p) - kHasClassBit);
 152 }
 153
 154 inline void ActRec::setThisOrClass(void* objOrCls) {
 155   assertx(m_func->implCls());
 156   setThisOrClassAllowNull(objOrCls);
 157 }
 158
 159 inline void ActRec::setThisOrClassAllowNull(void* objOrCls) {
 160   m_thisUnsafe = (ObjectData*)objOrCls;
 161 }
 162
 163 inline bool ActRec::hasThis() const {
 164   assertx(m_func->implCls());
 165   assertx(reinterpret_cast<uintptr_t>(m_thisUnsafe) != kTrashedThisSlot);
 166   return checkThis(m_thisUnsafe);
 167 }
 168
 169 inline bool ActRec::hasClass() const {
 170   assertx(m_func->implCls());
 171   return !checkThis(m_thisUnsafe);
 172 }
 173
 174 inline void* ActRec::getThisOrClass() const {
 175   assertx(m_func->implCls());
 176   return m_thisUnsafe;
 177 }
 178
 179 inline ObjectData* ActRec::getThisUnsafe() const {
 180   return m_thisUnsafe;
 181 }
 182
 183 inline ObjectData* ActRec::getThis() const {
 184   assert(hasThis());
 185   return m_thisUnsafe;
 186 }
 187
 188 inline Class* ActRec::getClass() const {
 189   assert(hasClass());
 190   return reinterpret_cast<Class*>(
 191     reinterpret_cast<uintptr_t>(m_clsUnsafe) - kHasClassBit);
 192 }
 193
 194 inline void ActRec::setThis(ObjectData* val) {
 195   assertx(m_func->implCls() && !m_func->isStaticInPrologue());
 196   m_thisUnsafe = val;
 197 }
 198
 199 inline void ActRec::setClass(Class* val) {
 200   assertx(val && m_func->implCls() && !(m_func->attrs() & AttrRequiresThis));
 201   m_clsUnsafe = reinterpret_cast<Class*>(
 202     reinterpret_cast<uintptr_t>(val) | kHasClassBit);
 203 }
 204
 205 inline void ActRec::trashThis() {
 206   if (debug) m_thisUnsafe = reinterpret_cast<ObjectData*>(kTrashedThisSlot);
 207 }
 208
 209 /////////////////////////////////////////////////////////////////////////////
 210
 211 inline void ActRec::trashVarEnv() {
 212   if (debug) setVarEnv(reinterpret_cast<VarEnv*>(kTrashedVarEnvSlot));
 213 }
 214
 215 inline bool ActRec::checkVarEnv() const {
 216   assert(m_varEnv != reinterpret_cast<VarEnv*>(kTrashedVarEnvSlot));
 217   return true;
 218 }
 219
 220 inline bool ActRec::hasVarEnv() const {
 221   assert(checkVarEnv());
 222   assert(!magicDispatch());
 223   return m_varEnv && !(reinterpret_cast<uintptr_t>(m_varEnv) & kExtraArgsBit);
 224 }
 225
 226 inline bool ActRec::hasExtraArgs() const {
 227   assert(checkVarEnv());
 228   return reinterpret_cast<uintptr_t>(m_extraArgs) & kExtraArgsBit;
 229 }
 230
 231 inline VarEnv* ActRec::getVarEnv() const {
 232   assert(hasVarEnv());
 233   return m_varEnv;
 234 }
 235
 236 inline ExtraArgs* ActRec::getExtraArgs() const {
 237   if (!hasExtraArgs()) return nullptr;
 238   return reinterpret_cast<ExtraArgs*>(
 239     reinterpret_cast<uintptr_t>(m_extraArgs) - kExtraArgsBit);
 240 }
 241
 242 inline StringData* ActRec::getInvName() const {
 243   assert(magicDispatch());
 244   assert(checkVarEnv());
 245   return m_invName;
 246 }
 247
 248 inline void ActRec::setVarEnv(VarEnv* val) {
 249   m_varEnv = val;
 250 }
 251
 252 inline void ActRec::setExtraArgs(ExtraArgs* val) {
 253   m_extraArgs = reinterpret_cast<ExtraArgs*>(
 254     reinterpret_cast<uintptr_t>(val) | kExtraArgsBit);
 255 }
 256
 257 ///////////////////////////////////////////////////////////////////////////////
 258
 259 }