execution.h revision 6ded16be15dd865a9b21ea304d5273c8be299c87
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 31namespace v8 { 32namespace internal { 33 34 35// Flag used to set the interrupt causes. 36enum InterruptFlag { 37 INTERRUPT = 1 << 0, 38 DEBUGBREAK = 1 << 1, 39 DEBUGCOMMAND = 1 << 2, 40 PREEMPT = 1 << 3, 41 TERMINATE = 1 << 4 42}; 43 44class 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 142class 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. 148class 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. 184 static uintptr_t climit() { 185 return thread_local_.climit_; 186 } 187 static uintptr_t jslimit() { 188 return thread_local_.jslimit_; 189 } 190 static uintptr_t real_jslimit() { 191 return thread_local_.real_jslimit_; 192 } 193 static Address address_of_jslimit() { 194 return reinterpret_cast<Address>(&thread_local_.jslimit_); 195 } 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 has_pending_interrupts(const ExecutionAccess& lock) { 203 // Sanity check: We shouldn't be asking about pending interrupts 204 // unless we're not postponing them anymore. 205 ASSERT(!should_postpone_interrupts(lock)); 206 return thread_local_.interrupt_flags_ != 0; 207 } 208 209 // You should hold the ExecutionAccess lock when calling this method. 210 static bool should_postpone_interrupts(const ExecutionAccess& lock) { 211 return thread_local_.postpone_interrupts_nesting_ > 0; 212 } 213 214 // You should hold the ExecutionAccess lock when calling this method. 215 static void set_interrupt_limits(const ExecutionAccess& lock) { 216 // Ignore attempts to interrupt when interrupts are postponed. 217 if (should_postpone_interrupts(lock)) return; 218 thread_local_.jslimit_ = kInterruptLimit; 219 thread_local_.climit_ = kInterruptLimit; 220 Heap::SetStackLimits(); 221 } 222 223 // Reset limits to actual values. For example after handling interrupt. 224 // You should hold the ExecutionAccess lock when calling this method. 225 static void reset_limits(const ExecutionAccess& lock) { 226 thread_local_.jslimit_ = thread_local_.real_jslimit_; 227 thread_local_.climit_ = thread_local_.real_climit_; 228 Heap::SetStackLimits(); 229 } 230 231 // Enable or disable interrupts. 232 static void EnableInterrupts(); 233 static void DisableInterrupts(); 234 235 static const uintptr_t kLimitSize = kPointerSize * 128 * KB; 236 237#ifdef V8_TARGET_ARCH_X64 238 static const uintptr_t kInterruptLimit = V8_UINT64_C(0xfffffffffffffffe); 239 static const uintptr_t kIllegalLimit = V8_UINT64_C(0xfffffffffffffff8); 240#else 241 static const uintptr_t kInterruptLimit = 0xfffffffe; 242 static const uintptr_t kIllegalLimit = 0xfffffff8; 243#endif 244 245 class ThreadLocal { 246 public: 247 ThreadLocal() { Clear(); } 248 // You should hold the ExecutionAccess lock when you call Initialize or 249 // Clear. 250 void Initialize(); 251 void Clear(); 252 253 // The stack limit is split into a JavaScript and a C++ stack limit. These 254 // two are the same except when running on a simulator where the C++ and 255 // JavaScript stacks are separate. Each of the two stack limits have two 256 // values. The one eith the real_ prefix is the actual stack limit 257 // set for the VM. The one without the real_ prefix has the same value as 258 // the actual stack limit except when there is an interruption (e.g. debug 259 // break or preemption) in which case it is lowered to make stack checks 260 // fail. Both the generated code and the runtime system check against the 261 // one without the real_ prefix. 262 uintptr_t real_jslimit_; // Actual JavaScript stack limit set for the VM. 263 uintptr_t jslimit_; 264 uintptr_t real_climit_; // Actual C++ stack limit set for the VM. 265 uintptr_t climit_; 266 267 int nesting_; 268 int postpone_interrupts_nesting_; 269 int interrupt_flags_; 270 }; 271 272 static ThreadLocal thread_local_; 273 274 friend class StackLimitCheck; 275 friend class PostponeInterruptsScope; 276}; 277 278 279// Support for checking for stack-overflows in C++ code. 280class StackLimitCheck BASE_EMBEDDED { 281 public: 282 bool HasOverflowed() const { 283 // Stack has overflowed in C++ code only if stack pointer exceeds the C++ 284 // stack guard and the limits are not set to interrupt values. 285 // TODO(214): Stack overflows are ignored if a interrupt is pending. This 286 // code should probably always use the initial C++ limit. 287 return (reinterpret_cast<uintptr_t>(this) < StackGuard::climit()) && 288 StackGuard::IsStackOverflow(); 289 } 290}; 291 292 293// Support for temporarily postponing interrupts. When the outermost 294// postpone scope is left the interrupts will be re-enabled and any 295// interrupts that occurred while in the scope will be taken into 296// account. 297class PostponeInterruptsScope BASE_EMBEDDED { 298 public: 299 PostponeInterruptsScope() { 300 StackGuard::thread_local_.postpone_interrupts_nesting_++; 301 StackGuard::DisableInterrupts(); 302 } 303 304 ~PostponeInterruptsScope() { 305 if (--StackGuard::thread_local_.postpone_interrupts_nesting_ == 0) { 306 StackGuard::EnableInterrupts(); 307 } 308 } 309}; 310 311 312class GCExtension : public v8::Extension { 313 public: 314 GCExtension() : v8::Extension("v8/gc", kSource) {} 315 virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction( 316 v8::Handle<v8::String> name); 317 static v8::Handle<v8::Value> GC(const v8::Arguments& args); 318 private: 319 static const char* kSource; 320}; 321 322 323} } // namespace v8::internal 324 325#endif // V8_EXECUTION_H_ 326