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
10namespace v8 {
11namespace internal {
12
13class 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  // ECMA-262 9.8
73  MUST_USE_RESULT static MaybeHandle<Object> ToString(
74      Isolate* isolate, Handle<Object> obj);
75
76  // ECMA-262 9.8
77  MUST_USE_RESULT static MaybeHandle<Object> ToDetailString(
78      Isolate* isolate, Handle<Object> obj);
79
80  // ECMA-262 9.9
81  MUST_USE_RESULT static MaybeHandle<Object> ToObject(
82      Isolate* isolate, Handle<Object> obj);
83
84  // Create a new date object from 'time'.
85  MUST_USE_RESULT static MaybeHandle<Object> NewDate(
86      Isolate* isolate, double time);
87
88  // Create a new regular expression object from 'pattern' and 'flags'.
89  MUST_USE_RESULT static MaybeHandle<JSRegExp> NewJSRegExp(
90      Handle<String> pattern, Handle<String> flags);
91
92  // Used to implement [] notation on strings (calls JS code)
93  static Handle<Object> CharAt(Handle<String> str, uint32_t index);
94
95  static Handle<Object> GetFunctionFor();
96  MUST_USE_RESULT static MaybeHandle<JSFunction> InstantiateFunction(
97      Handle<FunctionTemplateInfo> data);
98  MUST_USE_RESULT static MaybeHandle<JSObject> InstantiateObject(
99      Handle<ObjectTemplateInfo> data);
100  MUST_USE_RESULT static MaybeHandle<Object> ConfigureInstance(
101      Isolate* isolate,  Handle<Object> instance, Handle<Object> data);
102  static Handle<String> GetStackTraceLine(Handle<Object> recv,
103                                          Handle<JSFunction> fun,
104                                          Handle<Object> pos,
105                                          Handle<Object> is_global);
106
107  // Get a function delegate (or undefined) for the given non-function
108  // object. Used for support calling objects as functions.
109  static Handle<Object> GetFunctionDelegate(Isolate* isolate,
110                                            Handle<Object> object);
111  MUST_USE_RESULT static MaybeHandle<Object> TryGetFunctionDelegate(
112      Isolate* isolate,
113      Handle<Object> object);
114
115  // Get a function delegate (or undefined) for the given non-function
116  // object. Used for support calling objects as constructors.
117  static Handle<Object> GetConstructorDelegate(Isolate* isolate,
118                                               Handle<Object> object);
119  static MaybeHandle<Object> TryGetConstructorDelegate(Isolate* isolate,
120                                                       Handle<Object> object);
121};
122
123
124class ExecutionAccess;
125class PostponeInterruptsScope;
126
127
128// StackGuard contains the handling of the limits that are used to limit the
129// number of nested invocations of JavaScript and the stack size used in each
130// invocation.
131class StackGuard FINAL {
132 public:
133  // Pass the address beyond which the stack should not grow.  The stack
134  // is assumed to grow downwards.
135  void SetStackLimit(uintptr_t limit);
136
137  // Threading support.
138  char* ArchiveStackGuard(char* to);
139  char* RestoreStackGuard(char* from);
140  static int ArchiveSpacePerThread() { return sizeof(ThreadLocal); }
141  void FreeThreadResources();
142  // Sets up the default stack guard for this thread if it has not
143  // already been set up.
144  void InitThread(const ExecutionAccess& lock);
145  // Clears the stack guard for this thread so it does not look as if
146  // it has been set up.
147  void ClearThread(const ExecutionAccess& lock);
148
149#define INTERRUPT_LIST(V)                                          \
150  V(DEBUGBREAK, DebugBreak, 0)                                     \
151  V(DEBUGCOMMAND, DebugCommand, 1)                                 \
152  V(TERMINATE_EXECUTION, TerminateExecution, 2)                    \
153  V(GC_REQUEST, GC, 3)                                             \
154  V(INSTALL_CODE, InstallCode, 4)                                  \
155  V(API_INTERRUPT, ApiInterrupt, 5)                                \
156  V(DEOPT_MARKED_ALLOCATION_SITES, DeoptMarkedAllocationSites, 6)
157
158#define V(NAME, Name, id)                                          \
159  inline bool Check##Name() { return CheckInterrupt(NAME); }  \
160  inline void Request##Name() { RequestInterrupt(NAME); }     \
161  inline void Clear##Name() { ClearInterrupt(NAME); }
162  INTERRUPT_LIST(V)
163#undef V
164
165  // Flag used to set the interrupt causes.
166  enum InterruptFlag {
167  #define V(NAME, Name, id) NAME = (1 << id),
168    INTERRUPT_LIST(V)
169  #undef V
170  #define V(NAME, Name, id) NAME |
171    ALL_INTERRUPTS = INTERRUPT_LIST(V) 0
172  #undef V
173  };
174
175  // This provides an asynchronous read of the stack limits for the current
176  // thread.  There are no locks protecting this, but it is assumed that you
177  // have the global V8 lock if you are using multiple V8 threads.
178  uintptr_t climit() {
179    return thread_local_.climit_;
180  }
181  uintptr_t real_climit() {
182    return thread_local_.real_climit_;
183  }
184  uintptr_t jslimit() {
185    return thread_local_.jslimit_;
186  }
187  uintptr_t real_jslimit() {
188    return thread_local_.real_jslimit_;
189  }
190  Address address_of_jslimit() {
191    return reinterpret_cast<Address>(&thread_local_.jslimit_);
192  }
193  Address address_of_real_jslimit() {
194    return reinterpret_cast<Address>(&thread_local_.real_jslimit_);
195  }
196
197  // If the stack guard is triggered, but it is not an actual
198  // stack overflow, then handle the interruption accordingly.
199  Object* HandleInterrupts();
200
201 private:
202  StackGuard();
203
204  bool CheckInterrupt(InterruptFlag flag);
205  void RequestInterrupt(InterruptFlag flag);
206  void ClearInterrupt(InterruptFlag flag);
207  bool CheckAndClearInterrupt(InterruptFlag flag);
208
209  // You should hold the ExecutionAccess lock when calling this method.
210  bool has_pending_interrupts(const ExecutionAccess& lock) {
211    return thread_local_.interrupt_flags_ != 0;
212  }
213
214  // You should hold the ExecutionAccess lock when calling this method.
215  inline void set_interrupt_limits(const ExecutionAccess& lock);
216
217  // Reset limits to actual values. For example after handling interrupt.
218  // You should hold the ExecutionAccess lock when calling this method.
219  inline void reset_limits(const ExecutionAccess& lock);
220
221  // Enable or disable interrupts.
222  void EnableInterrupts();
223  void DisableInterrupts();
224
225#if V8_TARGET_ARCH_64_BIT
226  static const uintptr_t kInterruptLimit = V8_UINT64_C(0xfffffffffffffffe);
227  static const uintptr_t kIllegalLimit = V8_UINT64_C(0xfffffffffffffff8);
228#else
229  static const uintptr_t kInterruptLimit = 0xfffffffe;
230  static const uintptr_t kIllegalLimit = 0xfffffff8;
231#endif
232
233  void PushPostponeInterruptsScope(PostponeInterruptsScope* scope);
234  void PopPostponeInterruptsScope();
235
236  class ThreadLocal FINAL {
237   public:
238    ThreadLocal() { Clear(); }
239    // You should hold the ExecutionAccess lock when you call Initialize or
240    // Clear.
241    void Clear();
242
243    // Returns true if the heap's stack limits should be set, false if not.
244    bool Initialize(Isolate* isolate);
245
246    // The stack limit is split into a JavaScript and a C++ stack limit. These
247    // two are the same except when running on a simulator where the C++ and
248    // JavaScript stacks are separate. Each of the two stack limits have two
249    // values. The one eith the real_ prefix is the actual stack limit
250    // set for the VM. The one without the real_ prefix has the same value as
251    // the actual stack limit except when there is an interruption (e.g. debug
252    // break or preemption) in which case it is lowered to make stack checks
253    // fail. Both the generated code and the runtime system check against the
254    // one without the real_ prefix.
255    uintptr_t real_jslimit_;  // Actual JavaScript stack limit set for the VM.
256    uintptr_t jslimit_;
257    uintptr_t real_climit_;  // Actual C++ stack limit set for the VM.
258    uintptr_t climit_;
259
260    PostponeInterruptsScope* postpone_interrupts_;
261    int interrupt_flags_;
262  };
263
264  // TODO(isolates): Technically this could be calculated directly from a
265  //                 pointer to StackGuard.
266  Isolate* isolate_;
267  ThreadLocal thread_local_;
268
269  friend class Isolate;
270  friend class StackLimitCheck;
271  friend class PostponeInterruptsScope;
272
273  DISALLOW_COPY_AND_ASSIGN(StackGuard);
274};
275
276} }  // namespace v8::internal
277
278#endif  // V8_EXECUTION_H_
279