hphp/runtime/vm/jit/unique-stubs.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-2014 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_JIT_UNIQUE_STUBS_H_
  17 #define incl_HPHP_JIT_UNIQUE_STUBS_H_
  18
  19 #include "hphp/runtime/base/datatype.h"
  20 #include "hphp/runtime/vm/hhbc.h"
  21 #include "hphp/runtime/vm/jit/types.h"
  22
  23 namespace HPHP { namespace jit {
  24
  25 //////////////////////////////////////////////////////////////////////
  26
  27
  28 constexpr int kNumFreeLocalsHelpers = 9;
  29
  30 /*
  31  * Addresses of various unique, long-lived JIT helper routines are
  32  * emitted when we first start up our code cache.
  33  */
  34 struct UniqueStubs {
  35   /*
  36    * Stub that returns from this level VM-nesting to the previous one,
  37    * with whatever value is on the top of the stack.
  38    */
  39   TCA callToExit;
  40
  41   /*
  42    * Returning from a function when the ActRec was pushed by the interpreter.
  43    * The return IP on the ActRec will be set to one of these stubs, so if
  44    * someone tries to execute a return instruction, we get a chance to set up
  45    * state for a POST_INTERP_RET service request.
  46    *
  47    * Generators need a different stub because the ActRec for a generator is in
  48    * the heap.
  49    */
  50   TCA retHelper;
  51   TCA genRetHelper;  // version for generators
  52
  53   /*
  54    * Returning from a function when the ActRec was called from jitted code but
  55    * had its m_savedRip smashed by the debugger. These stubs call a helper that
  56    * looks up the original catch trace from the call, executes it, then executes
  57    * a REQ_POST_DEBUGGER_RET.
  58    */
  59   TCA debuggerRetHelper;
  60   TCA debuggerGenRetHelper;
  61
  62   /*
  63    * Returning from a function where the ActRec was pushed by an
  64    * inlined call.  This is the same as retHelper but separated just
  65    * for debugability.
  66    */
  67   TCA retInlHelper;
  68
  69   /*
  70    * Helpers used for restarting execution based on the value of PC, after
  71    * things like InterpOne of an instruction that changes PC. Assumes all VM
  72    * regs are synced.
  73    */
  74   TCA resumeHelperRet;
  75   TCA resumeHelper;
  76
  77   /*
  78    * Like resumeHelper, but interpret a basic block first to ensure we make
  79    * forward progress. interpHelper expects the correct value of vmpc to be in
  80    * the first argument register, and interpHelperSyncedPC expects vmpc to
  81    * already be synced. Both stubs will sync the sp and fp registers to vmRegs
  82    * before interpreting.
  83    */
  84   TCA interpHelper;
  85   TCA interpHelperSyncedPC;
  86
  87   /*
  88    * For every bytecode with the CF flag, a stub will exist here to interpOne
  89    * that bytecode, followed by a call to resumeHelper. The stubs expect rVmFp
  90    * and rVmSp to be live, and rAsm must contain the offset to the bytecode to
  91    * interpret.
  92    */
  93   std::unordered_map<Op, TCA> interpOneCFHelpers;
  94
  95   /*
  96    * Throw a VMSwitchMode exception. Used in
  97    * bytecode.cpp:switchModeForDebugger().
  98    */
  99   TCA throwSwitchMode;
 100
 101   /*
 102    * Catch blocks jump to endCatchHelper when they've finished executing. If
 103    * the unwinder has set state indicating a return address to jump to, this
 104    * stub will load vmfp and vmsp and jump there. Otherwise, it calls
 105    * unwindResumeHelper.
 106    */
 107   TCA endCatchHelper;
 108   TCA endCatchHelperPast;
 109
 110   /*
 111    * Helper stubs for doing generic decrefs on a function return.  The
 112    * stub is a partially-unrolled loop with kNumFreeLocalsHelpers
 113    * points to call to.  The freeManyLocalsHelper entry point should
 114    * be used when there's more locals than that.
 115    */
 116   TCA freeManyLocalsHelper;
 117   TCA freeLocalsHelpers[kNumFreeLocalsHelpers];
 118
 119   /*
 120    * When we enter a func prologue based on a prediction of which
 121    * Func* we'll be calling, if the prediction was wrong we bail to
 122    * this stub to redispatch.
 123    */
 124   TCA funcPrologueRedispatch;
 125
 126   /*
 127    * Utility routine that helps implement a fast path to avoid full VM
 128    * re-entry during translations of Op::FCallArray.
 129    */
 130   TCA fcallArrayHelper;
 131
 132   /*
 133    * The stub we jump to when a stack overflow check fails.
 134    */
 135   TCA stackOverflowHelper;
 136
 137   /*
 138    * A Func's prologue table is initialized to this stub for every entry. The
 139    * stub calls fcallHelper, which looks up or generates the appropriate
 140    * prologue and returns it. The stub then dispatches to the prologue.
 141    */
 142   TCA fcallHelperThunk;
 143
 144   /*
 145    * A Func's "function body entry point" is initialized to this stub. The stub
 146    * calls funcBodyHelper, which creates a real translation. The stub then
 147    * dispatches to the translation.
 148    */
 149   TCA funcBodyHelperThunk;
 150
 151   /*
 152    * Calls EventHook::onFunctionEnter, and handles the case where it requests
 153    * that we skip the function. functionEnterHelperReturn is used by unwinder
 154    * code that needs to detect calls made from this stub.
 155    */
 156   TCA functionEnterHelper;
 157   TCA functionEnterHelperReturn;
 158
 159   /*
 160    * BindCall stubs for immutable/non-immutable calls
 161    */
 162   TCA bindCallStub;
 163   TCA immutableBindCallStub;
 164
 165   /*
 166    * Utility for logging stubs addresses during startup and registering the gdb
 167    * symbols. It's often useful to know where they were when debugging.
 168    */
 169   TCA add(const char* name, TCA start);
 170
 171   /*
 172    * If the given address is within one of the registered stubs, return a
 173    * string indicating which stub and how far in it is:
 174    * "fcallArrayHelper+0xfa". Otherwise, return a string representation of the
 175    * raw address: "0xabcdef".
 176    */
 177   std::string describe(TCA addr);
 178
 179  private:
 180   struct StubRange {
 181     std::string name;
 182     TCA start, end;
 183
 184     bool operator<(const StubRange& other) const {
 185       return start < other.start;
 186     }
 187
 188     bool contains(TCA address) const {
 189       return start <= address && address < end;
 190     }
 191   };
 192
 193   std::vector<StubRange> m_ranges;
 194 };
 195
 196 //////////////////////////////////////////////////////////////////////
 197
 198 }}
 199
 200 #endif