1 // Copyright 2006-2008 the V8 project authors. All rights reserved. 2 // Redistribution and use in source and binary forms, with or without 3 // modification, are permitted provided that the following conditions are 4 // met: 5 // 6 // * Redistributions of source code must retain the above copyright 7 // notice, this list of conditions and the following disclaimer. 8 // * Redistributions in binary form must reproduce the above 9 // copyright notice, this list of conditions and the following 10 // disclaimer in the documentation and/or other materials provided 11 // with the distribution. 12 // * Neither the name of Google Inc. nor the names of its 13 // contributors may be used to endorse or promote products derived 14 // from this software without specific prior written permission. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 28 #ifndef V8_EXECUTION_H_ 29 #define V8_EXECUTION_H_ 30 31 namespace v8 { 32 namespace internal { 33 34 35 // Flag used to set the interrupt causes. 36 enum InterruptFlag { 37 INTERRUPT = 1 << 0, 38 DEBUGBREAK = 1 << 1, 39 DEBUGCOMMAND = 1 << 2, 40 PREEMPT = 1 << 3, 41 TERMINATE = 1 << 4 42 }; 43 44 class Execution : public AllStatic { 45 public: 46 // Call a function, the caller supplies a receiver and an array 47 // of arguments. Arguments are Object* type. After function returns, 48 // pointers in 'args' might be invalid. 49 // 50 // *pending_exception tells whether the invoke resulted in 51 // a pending exception. 52 // 53 static Handle<Object> Call(Handle<JSFunction> func, 54 Handle<Object> receiver, 55 int argc, 56 Object*** args, 57 bool* pending_exception); 58 59 // Construct object from function, the caller supplies an array of 60 // arguments. Arguments are Object* type. After function returns, 61 // pointers in 'args' might be invalid. 62 // 63 // *pending_exception tells whether the invoke resulted in 64 // a pending exception. 65 // 66 static Handle<Object> New(Handle<JSFunction> func, 67 int argc, 68 Object*** args, 69 bool* pending_exception); 70 71 // Call a function, just like Call(), but make sure to silently catch 72 // any thrown exceptions. The return value is either the result of 73 // calling the function (if caught exception is false) or the exception 74 // that occurred (if caught exception is true). 75 static Handle<Object> TryCall(Handle<JSFunction> func, 76 Handle<Object> receiver, 77 int argc, 78 Object*** args, 79 bool* caught_exception); 80 81 // ECMA-262 9.2 82 static Handle<Object> ToBoolean(Handle<Object> obj); 83 84 // ECMA-262 9.3 85 static Handle<Object> ToNumber(Handle<Object> obj, bool* exc); 86 87 // ECMA-262 9.4 88 static Handle<Object> ToInteger(Handle<Object> obj, bool* exc); 89 90 // ECMA-262 9.5 91 static Handle<Object> ToInt32(Handle<Object> obj, bool* exc); 92 93 // ECMA-262 9.6 94 static Handle<Object> ToUint32(Handle<Object> obj, bool* exc); 95 96 // ECMA-262 9.8 97 static Handle<Object> ToString(Handle<Object> obj, bool* exc); 98 99 // ECMA-262 9.8 100 static Handle<Object> ToDetailString(Handle<Object> obj, bool* exc); 101 102 // ECMA-262 9.9 103 static Handle<Object> ToObject(Handle<Object> obj, bool* exc); 104 105 // Create a new date object from 'time'. 106 static Handle<Object> NewDate(double time, bool* exc); 107 108 // Used to implement [] notation on strings (calls JS code) 109 static Handle<Object> CharAt(Handle<String> str, uint32_t index); 110 111 static Handle<Object> GetFunctionFor(); 112 static Handle<JSFunction> InstantiateFunction( 113 Handle<FunctionTemplateInfo> data, bool* exc); 114 static Handle<JSObject> InstantiateObject(Handle<ObjectTemplateInfo> data, 115 bool* exc); 116 static void ConfigureInstance(Handle<Object> instance, 117 Handle<Object> data, 118 bool* exc); 119 static Handle<String> GetStackTraceLine(Handle<Object> recv, 120 Handle<JSFunction> fun, 121 Handle<Object> pos, 122 Handle<Object> is_global); 123 #ifdef ENABLE_DEBUGGER_SUPPORT 124 static Object* DebugBreakHelper(); 125 static void ProcessDebugMesssages(bool debug_command_only); 126 #endif 127 128 // If the stack guard is triggered, but it is not an actual 129 // stack overflow, then handle the interruption accordingly. 130 static Object* HandleStackGuardInterrupt(); 131 132 // Get a function delegate (or undefined) for the given non-function 133 // object. Used for support calling objects as functions. 134 static Handle<Object> GetFunctionDelegate(Handle<Object> object); 135 136 // Get a function delegate (or undefined) for the given non-function 137 // object. Used for support calling objects as constructors. 138 static Handle<Object> GetConstructorDelegate(Handle<Object> object); 139 }; 140 141 142 class ExecutionAccess; 143 144 145 // StackGuard contains the handling of the limits that are used to limit the 146 // number of nested invocations of JavaScript and the stack size used in each 147 // invocation. 148 class StackGuard : public AllStatic { 149 public: 150 // Pass the address beyond which the stack should not grow. The stack 151 // is assumed to grow downwards. 152 static void SetStackLimit(uintptr_t limit); 153 154 // Threading support. 155 static char* ArchiveStackGuard(char* to); 156 static char* RestoreStackGuard(char* from); 157 static int ArchiveSpacePerThread(); 158 static void FreeThreadResources(); 159 // Sets up the default stack guard for this thread if it has not 160 // already been set up. 161 static void InitThread(const ExecutionAccess& lock); 162 // Clears the stack guard for this thread so it does not look as if 163 // it has been set up. 164 static void ClearThread(const ExecutionAccess& lock); 165 166 static bool IsStackOverflow(); 167 static bool IsPreempted(); 168 static void Preempt(); 169 static bool IsInterrupted(); 170 static void Interrupt(); 171 static bool IsTerminateExecution(); 172 static void TerminateExecution(); 173 #ifdef ENABLE_DEBUGGER_SUPPORT 174 static bool IsDebugBreak(); 175 static void DebugBreak(); 176 static bool IsDebugCommand(); 177 static void DebugCommand(); 178 #endif 179 static void Continue(InterruptFlag after_what); 180 181 // This provides an asynchronous read of the stack limits for the current 182 // thread. There are no locks protecting this, but it is assumed that you 183 // have the global V8 lock if you are using multiple V8 threads. climit()184 static uintptr_t climit() { 185 return thread_local_.climit_; 186 } jslimit()187 static uintptr_t jslimit() { 188 return thread_local_.jslimit_; 189 } real_jslimit()190 static uintptr_t real_jslimit() { 191 return thread_local_.real_jslimit_; 192 } address_of_jslimit()193 static Address address_of_jslimit() { 194 return reinterpret_cast<Address>(&thread_local_.jslimit_); 195 } address_of_real_jslimit()196 static Address address_of_real_jslimit() { 197 return reinterpret_cast<Address>(&thread_local_.real_jslimit_); 198 } 199 200 private: 201 // You should hold the ExecutionAccess lock when calling this method. 202 static bool IsSet(const ExecutionAccess& lock); 203 204 // You should hold the ExecutionAccess lock when calling this method. set_limits(uintptr_t value,const ExecutionAccess & lock)205 static void set_limits(uintptr_t value, const ExecutionAccess& lock) { 206 thread_local_.jslimit_ = value; 207 thread_local_.climit_ = value; 208 Heap::SetStackLimits(); 209 } 210 211 // Reset limits to actual values. For example after handling interrupt. 212 // You should hold the ExecutionAccess lock when calling this method. reset_limits(const ExecutionAccess & lock)213 static void reset_limits(const ExecutionAccess& lock) { 214 thread_local_.jslimit_ = thread_local_.real_jslimit_; 215 thread_local_.climit_ = thread_local_.real_climit_; 216 Heap::SetStackLimits(); 217 } 218 219 // Enable or disable interrupts. 220 static void EnableInterrupts(); 221 static void DisableInterrupts(); 222 223 static const uintptr_t kLimitSize = kPointerSize * 128 * KB; 224 225 #ifdef V8_TARGET_ARCH_X64 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 class ThreadLocal { 234 public: ThreadLocal()235 ThreadLocal() { Clear(); } 236 // You should hold the ExecutionAccess lock when you call Initialize or 237 // Clear. 238 void Initialize(); 239 void Clear(); 240 241 // The stack limit is split into a JavaScript and a C++ stack limit. These 242 // two are the same except when running on a simulator where the C++ and 243 // JavaScript stacks are separate. Each of the two stack limits have two 244 // values. The one eith the real_ prefix is the actual stack limit 245 // set for the VM. The one without the real_ prefix has the same value as 246 // the actual stack limit except when there is an interruption (e.g. debug 247 // break or preemption) in which case it is lowered to make stack checks 248 // fail. Both the generated code and the runtime system check against the 249 // one without the real_ prefix. 250 uintptr_t real_jslimit_; // Actual JavaScript stack limit set for the VM. 251 uintptr_t jslimit_; 252 uintptr_t real_climit_; // Actual C++ stack limit set for the VM. 253 uintptr_t climit_; 254 255 int nesting_; 256 int postpone_interrupts_nesting_; 257 int interrupt_flags_; 258 }; 259 260 static ThreadLocal thread_local_; 261 262 friend class StackLimitCheck; 263 friend class PostponeInterruptsScope; 264 }; 265 266 267 // Support for checking for stack-overflows in C++ code. 268 class StackLimitCheck BASE_EMBEDDED { 269 public: HasOverflowed()270 bool HasOverflowed() const { 271 // Stack has overflowed in C++ code only if stack pointer exceeds the C++ 272 // stack guard and the limits are not set to interrupt values. 273 // TODO(214): Stack overflows are ignored if a interrupt is pending. This 274 // code should probably always use the initial C++ limit. 275 return (reinterpret_cast<uintptr_t>(this) < StackGuard::climit()) && 276 StackGuard::IsStackOverflow(); 277 } 278 }; 279 280 281 // Support for temporarily postponing interrupts. When the outermost 282 // postpone scope is left the interrupts will be re-enabled and any 283 // interrupts that occurred while in the scope will be taken into 284 // account. 285 class PostponeInterruptsScope BASE_EMBEDDED { 286 public: PostponeInterruptsScope()287 PostponeInterruptsScope() { 288 StackGuard::thread_local_.postpone_interrupts_nesting_++; 289 StackGuard::DisableInterrupts(); 290 } 291 ~PostponeInterruptsScope()292 ~PostponeInterruptsScope() { 293 if (--StackGuard::thread_local_.postpone_interrupts_nesting_ == 0) { 294 StackGuard::EnableInterrupts(); 295 } 296 } 297 }; 298 299 300 class GCExtension : public v8::Extension { 301 public: GCExtension()302 GCExtension() : v8::Extension("v8/gc", kSource) {} 303 virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction( 304 v8::Handle<v8::String> name); 305 static v8::Handle<v8::Value> GC(const v8::Arguments& args); 306 private: 307 static const char* kSource; 308 }; 309 310 311 } } // namespace v8::internal 312 313 #endif // V8_EXECUTION_H_ 314