deps/v8/src/execution.h

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_EXECUTION_H_
   6 #define V8_EXECUTION_H_
   7
   8 #include "src/handles.h"
   9
  10 namespace v8 {
  11 namespace internal {
  12
  13 class Execution FINAL : public AllStatic {
  14  public:
  15   // Call a function, the caller supplies a receiver and an array
  16   // of arguments. Arguments are Object* type. After function returns,
  17   // pointers in 'args' might be invalid.
  18   //
  19   // *pending_exception tells whether the invoke resulted in
  20   // a pending exception.
  21   //
  22   // When convert_receiver is set, and the receiver is not an object,
  23   // and the function called is not in strict mode, receiver is converted to
  24   // an object.
  25   //
  26   MUST_USE_RESULT static MaybeHandle<Object> Call(
  27       Isolate* isolate,
  28       Handle<Object> callable,
  29       Handle<Object> receiver,
  30       int argc,
  31       Handle<Object> argv[],
  32       bool convert_receiver = false);
  33
  34   // Construct object from function, the caller supplies an array of
  35   // arguments. Arguments are Object* type. After function returns,
  36   // pointers in 'args' might be invalid.
  37   //
  38   // *pending_exception tells whether the invoke resulted in
  39   // a pending exception.
  40   //
  41   MUST_USE_RESULT static MaybeHandle<Object> New(Handle<JSFunction> func,
  42                                                  int argc,
  43                                                  Handle<Object> argv[]);
  44
  45   // Call a function, just like Call(), but make sure to silently catch
  46   // any thrown exceptions. The return value is either the result of
  47   // calling the function (if caught exception is false) or the exception
  48   // that occurred (if caught exception is true).
  49   // In the exception case, exception_out holds the caught exceptions, unless
  50   // it is a termination exception.
  51   static MaybeHandle<Object> TryCall(Handle<JSFunction> func,
  52                                      Handle<Object> receiver, int argc,
  53                                      Handle<Object> argv[],
  54                                      MaybeHandle<Object>* exception_out = NULL);
  55
  56   // ECMA-262 9.3
  57   MUST_USE_RESULT static MaybeHandle<Object> ToNumber(
  58       Isolate* isolate, Handle<Object> obj);
  59
  60   // ECMA-262 9.4
  61   MUST_USE_RESULT static MaybeHandle<Object> ToInteger(
  62       Isolate* isolate, Handle<Object> obj);
  63
  64   // ECMA-262 9.5
  65   MUST_USE_RESULT static MaybeHandle<Object> ToInt32(
  66       Isolate* isolate, Handle<Object> obj);
  67
  68   // ECMA-262 9.6
  69   MUST_USE_RESULT static MaybeHandle<Object> ToUint32(
  70       Isolate* isolate, Handle<Object> obj);
  71
  72
  73   // ES6, draft 10-14-14, section 7.1.15
  74   MUST_USE_RESULT static MaybeHandle<Object> ToLength(
  75       Isolate* isolate, Handle<Object> obj);
  76
  77   // ECMA-262 9.8
  78   MUST_USE_RESULT static MaybeHandle<Object> ToString(
  79       Isolate* isolate, Handle<Object> obj);
  80
  81   // ECMA-262 9.8
  82   MUST_USE_RESULT static MaybeHandle<Object> ToDetailString(
  83       Isolate* isolate, Handle<Object> obj);
  84
  85   // ECMA-262 9.9
  86   MUST_USE_RESULT static MaybeHandle<Object> ToObject(
  87       Isolate* isolate, Handle<Object> obj);
  88
  89   // Create a new date object from 'time'.
  90   MUST_USE_RESULT static MaybeHandle<Object> NewDate(
  91       Isolate* isolate, double time);
  92
  93   // Create a new regular expression object from 'pattern' and 'flags'.
  94   MUST_USE_RESULT static MaybeHandle<JSRegExp> NewJSRegExp(
  95       Handle<String> pattern, Handle<String> flags);
  96
  97   // Used to implement [] notation on strings (calls JS code)
  98   static Handle<Object> CharAt(Handle<String> str, uint32_t index);
  99
 100   static Handle<Object> GetFunctionFor();
 101   static Handle<String> GetStackTraceLine(Handle<Object> recv,
 102                                           Handle<JSFunction> fun,
 103                                           Handle<Object> pos,
 104                                           Handle<Object> is_global);
 105
 106   // Get a function delegate (or undefined) for the given non-function
 107   // object. Used for support calling objects as functions.
 108   static Handle<Object> GetFunctionDelegate(Isolate* isolate,
 109                                             Handle<Object> object);
 110   MUST_USE_RESULT static MaybeHandle<Object> TryGetFunctionDelegate(
 111       Isolate* isolate,
 112       Handle<Object> object);
 113
 114   // Get a function delegate (or undefined) for the given non-function
 115   // object. Used for support calling objects as constructors.
 116   static Handle<Object> GetConstructorDelegate(Isolate* isolate,
 117                                                Handle<Object> object);
 118   static MaybeHandle<Object> TryGetConstructorDelegate(Isolate* isolate,
 119                                                        Handle<Object> object);
 120 };
 121
 122
 123 class ExecutionAccess;
 124 class PostponeInterruptsScope;
 125
 126
 127 // StackGuard contains the handling of the limits that are used to limit the
 128 // number of nested invocations of JavaScript and the stack size used in each
 129 // invocation.
 130 class StackGuard FINAL {
 131  public:
 132   // Pass the address beyond which the stack should not grow.  The stack
 133   // is assumed to grow downwards.
 134   void SetStackLimit(uintptr_t limit);
 135
 136   // Threading support.
 137   char* ArchiveStackGuard(char* to);
 138   char* RestoreStackGuard(char* from);
 139   static int ArchiveSpacePerThread() { return sizeof(ThreadLocal); }
 140   void FreeThreadResources();
 141   // Sets up the default stack guard for this thread if it has not
 142   // already been set up.
 143   void InitThread(const ExecutionAccess& lock);
 144   // Clears the stack guard for this thread so it does not look as if
 145   // it has been set up.
 146   void ClearThread(const ExecutionAccess& lock);
 147
 148 #define INTERRUPT_LIST(V)                                          \
 149   V(DEBUGBREAK, DebugBreak, 0)                                     \
 150   V(DEBUGCOMMAND, DebugCommand, 1)                                 \
 151   V(TERMINATE_EXECUTION, TerminateExecution, 2)                    \
 152   V(GC_REQUEST, GC, 3)                                             \
 153   V(INSTALL_CODE, InstallCode, 4)                                  \
 154   V(API_INTERRUPT, ApiInterrupt, 5)                                \
 155   V(DEOPT_MARKED_ALLOCATION_SITES, DeoptMarkedAllocationSites, 6)
 156
 157 #define V(NAME, Name, id)                                          \
 158   inline bool Check##Name() { return CheckInterrupt(NAME); }  \
 159   inline void Request##Name() { RequestInterrupt(NAME); }     \
 160   inline void Clear##Name() { ClearInterrupt(NAME); }
 161   INTERRUPT_LIST(V)
 162 #undef V
 163
 164   // Flag used to set the interrupt causes.
 165   enum InterruptFlag {
 166   #define V(NAME, Name, id) NAME = (1 << id),
 167     INTERRUPT_LIST(V)
 168   #undef V
 169   #define V(NAME, Name, id) NAME |
 170     ALL_INTERRUPTS = INTERRUPT_LIST(V) 0
 171   #undef V
 172   };
 173
 174   // This provides an asynchronous read of the stack limits for the current
 175   // thread.  There are no locks protecting this, but it is assumed that you
 176   // have the global V8 lock if you are using multiple V8 threads.
 177   uintptr_t climit() {
 178     return thread_local_.climit_;
 179   }
 180   uintptr_t real_climit() {
 181     return thread_local_.real_climit_;
 182   }
 183   uintptr_t jslimit() {
 184     return thread_local_.jslimit_;
 185   }
 186   uintptr_t real_jslimit() {
 187     return thread_local_.real_jslimit_;
 188   }
 189   Address address_of_jslimit() {
 190     return reinterpret_cast<Address>(&thread_local_.jslimit_);
 191   }
 192   Address address_of_real_jslimit() {
 193     return reinterpret_cast<Address>(&thread_local_.real_jslimit_);
 194   }
 195
 196   // If the stack guard is triggered, but it is not an actual
 197   // stack overflow, then handle the interruption accordingly.
 198   Object* HandleInterrupts();
 199
 200  private:
 201   StackGuard();
 202
 203   bool CheckInterrupt(InterruptFlag flag);
 204   void RequestInterrupt(InterruptFlag flag);
 205   void ClearInterrupt(InterruptFlag flag);
 206   bool CheckAndClearInterrupt(InterruptFlag flag);
 207
 208   // You should hold the ExecutionAccess lock when calling this method.
 209   bool has_pending_interrupts(const ExecutionAccess& lock) {
 210     return thread_local_.interrupt_flags_ != 0;
 211   }
 212
 213   // You should hold the ExecutionAccess lock when calling this method.
 214   inline void set_interrupt_limits(const ExecutionAccess& lock);
 215
 216   // Reset limits to actual values. For example after handling interrupt.
 217   // You should hold the ExecutionAccess lock when calling this method.
 218   inline void reset_limits(const ExecutionAccess& lock);
 219
 220   // Enable or disable interrupts.
 221   void EnableInterrupts();
 222   void DisableInterrupts();
 223
 224 #if V8_TARGET_ARCH_64_BIT
 225   static const uintptr_t kInterruptLimit = V8_UINT64_C(0xfffffffffffffffe);
 226   static const uintptr_t kIllegalLimit = V8_UINT64_C(0xfffffffffffffff8);
 227 #else
 228   static const uintptr_t kInterruptLimit = 0xfffffffe;
 229   static const uintptr_t kIllegalLimit = 0xfffffff8;
 230 #endif
 231
 232   void PushPostponeInterruptsScope(PostponeInterruptsScope* scope);
 233   void PopPostponeInterruptsScope();
 234
 235   class ThreadLocal FINAL {
 236    public:
 237     ThreadLocal() { Clear(); }
 238     // You should hold the ExecutionAccess lock when you call Initialize or
 239     // Clear.
 240     void Clear();
 241
 242     // Returns true if the heap's stack limits should be set, false if not.
 243     bool Initialize(Isolate* isolate);
 244
 245     // The stack limit is split into a JavaScript and a C++ stack limit. These
 246     // two are the same except when running on a simulator where the C++ and
 247     // JavaScript stacks are separate. Each of the two stack limits have two
 248     // values. The one eith the real_ prefix is the actual stack limit
 249     // set for the VM. The one without the real_ prefix has the same value as
 250     // the actual stack limit except when there is an interruption (e.g. debug
 251     // break or preemption) in which case it is lowered to make stack checks
 252     // fail. Both the generated code and the runtime system check against the
 253     // one without the real_ prefix.
 254     uintptr_t real_jslimit_;  // Actual JavaScript stack limit set for the VM.
 255     uintptr_t jslimit_;
 256     uintptr_t real_climit_;  // Actual C++ stack limit set for the VM.
 257     uintptr_t climit_;
 258
 259     PostponeInterruptsScope* postpone_interrupts_;
 260     int interrupt_flags_;
 261   };
 262
 263   // TODO(isolates): Technically this could be calculated directly from a
 264   //                 pointer to StackGuard.
 265   Isolate* isolate_;
 266   ThreadLocal thread_local_;
 267
 268   friend class Isolate;
 269   friend class StackLimitCheck;
 270   friend class PostponeInterruptsScope;
 271
 272   DISALLOW_COPY_AND_ASSIGN(StackGuard);
 273 };
 274
 275 } }  // namespace v8::internal
 276
 277 #endif  // V8_EXECUTION_H_