hphp/runtime/vm/act-rec.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 #ifndef incl_HPHP_ACT_REC_H_
  18 #define incl_HPHP_ACT_REC_H_
  19
  20 #include "hphp/runtime/base/types.h"
  21 #include "hphp/runtime/base/typed-value.h"
  22 #include "hphp/runtime/vm/rx.h"
  23 #include "hphp/util/compact-tagged-ptrs.h"
  24
  25 /*
  26  * These header dependencies need to stay as minimal as possible.
  27  */
  28
  29 namespace HPHP {
  30
  31 ///////////////////////////////////////////////////////////////////////////////
  32
  33 struct ActRec;
  34 struct Class;
  35 struct ExtraArgs;
  36 struct Func;
  37 struct ObjectData;
  38 struct StringData;
  39 struct Unit;
  40 struct VarEnv;
  41
  42 using ReifiedGenericsPtr = CompactTaggedPtr<ArrayData,uint16_t>;
  43
  44 ///////////////////////////////////////////////////////////////////////////////
  45
  46 /*
  47  * An "ActRec" is a call activation record.  The ordering of the fields assumes
  48  * that stacks grow toward lower addresses.
  49  *
  50  * For most purposes, an ActRec can be considered to be in one of three
  51  * possible states:
  52  *   Pre-live:
  53  *     After the FPush* instruction which materialized the ActRec on the stack
  54  *     but before the corresponding FCall instruction.
  55  *   Live:
  56  *     After the corresponding FCall instruction but before the ActRec fields
  57  *     and locals/iters have been decref'd (either by return or unwinding).
  58  *   Post-live:
  59  *     After the ActRec fields and locals/iters have been decref'd.
  60  *
  61  * Note that when a function is invoked by the runtime via invokeFunc(), the
  62  * "pre-live" state is skipped and the ActRec is materialized in the "live"
  63  * state.
  64  */
  65 struct ActRec {
  66 #if defined(__powerpc64__)
  67   ActRec* m_sfp;         // Previous hardware frame pointer/ActRec.
  68   uint32_t m_savedCR;    // PPC64's sign flags (CR)
  69   uint32_t m_reserved;   // Reserved word as on ABI
  70   uint64_t m_savedRip;   // In-TC address to return to.
  71   uint64_t m_savedToc;   // TOC save doubleword
  72 #else // X64 style
  73   // This pair of uint64_t's must be the first two elements in the structure
  74   // so that the pointer to the ActRec can also be used for RBP chaining.
  75   // Note that ActRecs are also native frames, so this is an implicit machine
  76   // dependency.
  77   ActRec* m_sfp;       // Previous hardware frame pointer/ActRec
  78   uint64_t m_savedRip; // native (in-TC) return address
  79 #endif
  80   const Func* m_func;  // Function.
  81   uint32_t m_callOff;  // bc offset of call opcode from caller func entry.
  82   uint32_t m_numArgsAndFlags; // arg_count:26, flags:6
  83   union {
  84     ObjectData* m_thisUnsafe; // This.
  85     Class* m_clsUnsafe;       // Late bound class.
  86   };
  87   union {
  88     VarEnv* m_varEnv;       // Variable environment when live
  89     ExtraArgs* m_extraArgs; // Lightweight extra args, when live
  90     StringData* m_invName;  // Invoked name, used for __call(), when pre-live
  91     // Used to store a pointer to reified generics and a bit map of
  92     // which generics are reified
  93     ReifiedGenericsPtr m_reifiedGenerics{};
  94   };
  95
  96   TYPE_SCAN_CUSTOM_FIELD(m_thisUnsafe) {
  97     // skip if "this" is a class
  98     if (checkThisOrNull(m_thisUnsafe)) scanner.scan(m_thisUnsafe);
  99   }
 100   TYPE_SCAN_CUSTOM_FIELD(m_varEnv) {
 101     // All three union members could be heap pointers, but we don't care
 102     // which kind; PtrMap will resolve things.
 103     scanner.scan(m_varEnv);
 104   }
 105
 106   /////////////////////////////////////////////////////////////////////////////
 107
 108   enum Flags : uint32_t {
 109     None          = 0,
 110
 111     // Set if the function was called using FCall instruction with more
 112     // than one return values and must return a value via RetM.
 113     MultiReturn = (1u << 26),
 114
 115     // Set if this corresponds to a dynamic call
 116     DynamicCall = (1u << 27),
 117
 118     // Set if m_reifiedGenerics contains valid data
 119     HasReifiedGenerics = (1u << 28),
 120
 121     // This bit can be independently set on ActRecs with any other flag state.
 122     // It's used by the unwinder to know that an ActRec has been partially torn
 123     // down (locals freed).
 124     LocalsDecRefd = (1u << 29),
 125
 126     // Four mutually exclusive execution mode states in these 2 bits.
 127     InResumed     = (1u << 30),
 128     AsyncEagerRet = (1u << 31),
 129     MagicDispatch = InResumed|AsyncEagerRet,
 130   };
 131
 132   static constexpr int kNumArgsBits = 26;
 133   static constexpr int kNumArgsMask = (1 << kNumArgsBits) - 1;
 134   static constexpr int kFlagsMask = ~kNumArgsMask;
 135   static constexpr int kExecutionModeMask =
 136     ~(LocalsDecRefd | DynamicCall | MultiReturn);
 137
 138   /*
 139    * To conserve space, we use unions for pairs of mutually exclusive fields
 140    * (fields that are not used at the same time).
 141    *
 142    * The least significant bit is used as a marker for each pair of fields so
 143    * that we can distinguish at runtime which field is valid.  We define
 144    * accessors (below) to encapsulate this logic.
 145    */
 146   static auto constexpr      kHasClassBit  = 0x1;  // unset for m_this
 147   static auto constexpr      kExtraArgsBit = 0x1;  // unset for m_varEnv
 148
 149   static constexpr uintptr_t kTrashedVarEnvSlot = 0xfeeefeee000f000f;
 150   static constexpr uintptr_t kTrashedThisSlot = 0xfeeefeeef00fe00e;
 151   static constexpr uintptr_t kTrashedFuncSlot = 0xfeeefeeef00fe00d;
 152   static constexpr uintptr_t kTrashedReifiedGenericsSlot = 0xfeeefeeef00fe00c;
 153
 154   /////////////////////////////////////////////////////////////////////////////
 155
 156   /*
 157    * The next outermost VM frame, or nullptr if this is a reentry frame.
 158    */
 159   ActRec* sfp() const;
 160
 161   /*
 162    * The Func and Unit for this frame.
 163    */
 164   const Func* func() const;
 165   const Unit* unit() const;
 166
 167   /*
 168    * Set up frame linkage with the caller ActRec.
 169    */
 170   void setReturn(ActRec* fp, PC callPC, void* retAddr);
 171   void setJitReturn(void* retAddr);
 172
 173   /*
 174    * Hijack the frame such that a PHP return will cause us to leave the current
 175    * VM nesting layer.
 176    */
 177   void setReturnVMExit();
 178
 179   /*
 180    * Whether this frame should be skipped when searching for context.
 181    *
 182    * @returns: func() && func()->isSkipFrame().
 183    */
 184   bool skipFrame() const;
 185
 186   /////////////////////////////////////////////////////////////////////////////
 187   // NumArgs / Flags.
 188
 189   /*
 190    * Number of arguments passed for this invocation.
 191    */
 192   int32_t numArgs() const;
 193
 194   /*
 195    * Raw flags accessors.
 196    */
 197   Flags flags() const;
 198   bool localsDecRefd() const;
 199   bool resumed() const;
 200   bool isAsyncEagerReturn() const;
 201   bool magicDispatch() const;
 202   bool isDynamicCall() const;
 203   bool isFCallM() const;
 204   bool hasReifiedGenerics() const;
 205
 206   /*
 207    * Pack `numArgs' and `flags' into the format expected by m_numArgsAndFlags.
 208    */
 209   static uint32_t encodeNumArgsAndFlags(uint32_t numArgs, Flags flags);
 210
 211   /*
 212    * Set the numArgs component of m_numArgsAndFlags to `numArgs'.
 213    *
 214    * The init* flavor zeroes the flags component, whereas the set* flavor
 215    * preserves flags.
 216    */
 217   void initNumArgs(uint32_t numArgs);
 218   void setNumArgs(uint32_t numArgs);
 219
 220   /*
 221    * Flags setters.
 222    */
 223   void setLocalsDecRefd();
 224   void setResumed();
 225   void setAsyncEagerReturn();
 226   void setDynamicCall();
 227   void setFCallM();
 228   void setHasReifiedGenerics();
 229
 230   /*
 231    * Set or clear both m_invName and the MagicDispatch flag.
 232    */
 233   void setMagicDispatch(StringData* invName);
 234   StringData* clearMagicDispatch();
 235
 236   /////////////////////////////////////////////////////////////////////////////
 237   // This / Class.
 238
 239   /*
 240    * Encode `obj' or `cls' for the m_this/m_cls union.
 241    */
 242   static void* encodeThis(ObjectData* obj);
 243   static void* encodeClass(const Class* cls);
 244
 245   /*
 246    * Determine whether p is a Class* or an ObjectData* based
 247    * on kHasClassBit.
 248    *
 249    * @requires: p != nullptr
 250    */
 251   static bool checkThis(void* p);
 252
 253   /*
 254    * Determine whether p is a Class* based on kHasClassBit.
 255    *
 256    * @requires: p is a Cctx, an ObjectData* or a nullptr
 257    */
 258   static bool checkThisOrNull(void* p);
 259
 260   /*
 261    * Decode `p', encoded in the format of m_this/m_cls.
 262    *
 263    * If `p' has the other encoding (or is nullptr), return nullptr.
 264    */
 265   static ObjectData* decodeThis(void* p);
 266   static Class* decodeClass(void* p);
 267
 268   /*
 269    * Set m_this/m_cls to the pre-encoded `objOrCls'.
 270    *
 271    * One of these asserts if `objOrCls' is null, but it is a mystery which one.
 272    */
 273   void setThisOrClass(void* objOrCls);
 274   void setThisOrClassAllowNull(void* objOrCls);
 275
 276   /*
 277    * Whether the m_this/m_cls union is discriminated in the desired way.
 278    *
 279    * @requires: m_func->implCls() != nullptr
 280    */
 281   bool hasThis() const;
 282   bool hasClass() const;
 283
 284   /*
 285    * Get the (encoded) value of the m_this/m_cls union.
 286    *
 287    * @requires: hasThis() || hasClass()
 288    */
 289   void* getThisOrClass() const;
 290
 291   /*
 292    * Get m_thisUnsafe. Caller takes responsibility for its meaning.
 293    */
 294   ObjectData* getThisUnsafe() const;
 295   /*
 296    * Get and decode the value of m_this/m_cls.
 297    *
 298    * @requires: hasThis() or hasClass(), respectively
 299    */
 300   ObjectData* getThis() const;
 301   Class* getClass() const;
 302
 303   /*
 304    * Encode and set `val' to m_this/m_cls
 305    *
 306    * @requires: m_func->implClass() and
 307    *            !m_func->isStaticInPrologue()
 308    */
 309   void setThis(ObjectData* val);
 310   /*
 311    * Encode and set `val' to m_this/m_cls
 312    *
 313    * @requires: m_func->implClass() and
 314    *            !(m_func->attrs() & AttrRequiresThis)
 315    */
 316   void setClass(Class* val);
 317
 318   /*
 319    * Write garbage to the m_this/m_cls union (in debug mode only).
 320    */
 321   void trashThis();
 322
 323   /////////////////////////////////////////////////////////////////////////////
 324   // Reified Generics.
 325
 326   /*
 327    * Sets to reified generics slot
 328    * It also sets HasReifiedGenerics on the m_numArgsAndFlags
 329    */
 330    void setReifiedGenerics(ArrayData* rg);
 331
 332   /*
 333    * Gets reified generics
 334    */
 335    ArrayData* getReifiedGenerics() const;
 336
 337   /*
 338    * Trashes the reified generics
 339    */
 340    void trashReifiedGenerics();
 341
 342   /////////////////////////////////////////////////////////////////////////////
 343   // VarEnv / ExtraArgs.
 344
 345   /*
 346    * Write garbage to the m_varEnv/m_extraArgs union (in debug mode only).
 347    */
 348   void trashVarEnv();
 349
 350   /*
 351    * Check that the m_varEnv/m_extraArgs union is not the special garbage
 352    * value.
 353    */
 354   bool checkVarEnv() const;
 355
 356   /*
 357    * Whether the m_varEnv/m_extraArgs union is discriminated in the desired
 358    * way.
 359    */
 360   bool hasVarEnv() const;
 361   bool hasExtraArgs() const;
 362
 363   /*
 364    * Get and decode the VarEnv.
 365    *
 366    * @requires: hasVarEnv()
 367    */
 368   VarEnv* getVarEnv() const;
 369
 370   /*
 371    * Get and decode the ExtraArgs.
 372    *
 373    * If !hasExtraArgs(), returns nullptr.
 374    */
 375   ExtraArgs* getExtraArgs() const;
 376
 377   /*
 378    * Get and decode the magic invocation name.
 379    *
 380    * @requires: magicDispatch()
 381    */
 382   StringData* getInvName() const;
 383
 384   /*
 385    * Encode and set `val' to the m_varEnv/m_extraArgs union.
 386    */
 387   void setVarEnv(VarEnv* val);
 388   void setExtraArgs(ExtraArgs* val);
 389   void resetExtraArgs();
 390
 391   /*
 392    * Get the extra argument with index `ind', from either the VarEnv or the
 393    * ExtraArgs, whichever is set.
 394    *
 395    * Returns nullptr if there are no extra arguments.
 396    */
 397   TypedValue* getExtraArg(unsigned ind) const;
 398
 399   /*
 400    * Get the minimum possible effective level of reactivity.
 401    *
 402    * Doesn't return precise level as conditional reactivity is not tracked yet.
 403    */
 404   RxLevel rxMinLevel() const;
 405
 406   /*
 407    * address to teleport the return value after destroying this actrec.
 408    */
 409   TypedValue* retSlot() {
 410     return reinterpret_cast<TypedValue*>(this + 1) - 1;
 411   }
 412 };
 413
 414 static_assert(offsetof(ActRec, m_sfp) == 0,
 415               "m_sfp should be at offset 0 of ActRec");
 416
 417 /*
 418  * Size in bytes of the target architecture's call frame.
 419  */
 420 constexpr auto kNativeFrameSize = offsetof(ActRec, m_func);
 421
 422 /*
 423  * offset from frame ptr to return value slot after teardown
 424  */
 425 constexpr auto kArRetOff = sizeof(ActRec) - sizeof(TypedValue);
 426 static_assert(kArRetOff % sizeof(TypedValue) == 0, "");
 427
 428 /*
 429  * Whether `address' is a helper stub that we're permitted to set
 430  * ActRec::m_savedRip to.
 431  */
 432 bool isReturnHelper(void* address);
 433 bool isDebuggerReturnHelper(void* address);
 434
 435 /* Offset of the m_func and m_thisUnsafe fields in cells */
 436
 437 static_assert(offsetof(ActRec, m_func) % sizeof(Cell) == 0, "");
 438 static_assert(offsetof(ActRec, m_thisUnsafe) % sizeof(Cell) == 0, "");
 439
 440 constexpr auto kActRecFuncCellOff = offsetof(ActRec, m_func) /
 441                                     sizeof(Cell);
 442 constexpr auto kActRecCtxCellOff  = offsetof(ActRec, m_thisUnsafe) /
 443                                     sizeof(Cell);
 444
 445 ///////////////////////////////////////////////////////////////////////////////
 446
 447 }
 448
 449 #include "hphp/runtime/vm/act-rec-inl.h"
 450
 451 #endif