[Isolates]...

src/isolate.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_ISOLATE_H_
 #define V8_ISOLATE_H_
 
 #include "apiutils.h"
 #include "heap.h"
+#include "execution.h"
 #include "zone.h"
 
 namespace v8 {
 namespace internal {
 
 class Bootstrapper;
 class Deserializer;
 class HandleScopeImplementer;
 class StubCache;
 
@@ skipping 14 matching lines @@
   // Returns the single global isolate.
   static Isolate* Current() {
     ASSERT(global_isolate != NULL);
     return global_isolate;
   }
 
   // Creates a new isolate (perhaps using a deserializer). Returns null
   // on failure.
   static Isolate* Create(Deserializer* des);
 
-  // Initialize process-wide state.
-  static void InitOnce();
-
 #define GLOBAL_ACCESSOR(type, name, initialvalue)                              \
   type name() const { return name##_; }                                        \
   void set_##name(type value) { name##_ = value; }
   ISOLATE_INIT_LIST(GLOBAL_ACCESSOR)
 #undef GLOBAL_ACCESSOR
 
 #define GLOBAL_ARRAY_ACCESSOR(type, name, length)                              \
   type* name() { return &(name##_[0]); }
   ISOLATE_INIT_ARRAY_LIST(GLOBAL_ARRAY_ACCESSOR)
 #undef GLOBAL_ARRAY_ACCESSOR
 
+  // Debug.
+  // Mutex for serializing access to break control structures.
+  Mutex* break_access() { return break_access_; }
+
   // Accessors.
   Bootstrapper* bootstrapper() { return bootstrapper_; }
+  StackGuard* stack_guard() { return &stack_guard_; }
   Heap* heap() { return &heap_; }
   StubCache* stub_cache() { return stub_cache_; }
   v8::ImplementationUtilities::HandleScopeData* handle_scope_data() {
     return &handle_scope_data_;
   }
   HandleScopeImplementer* handle_scope_implementer() {
     ASSERT(handle_scope_implementer_);
     return handle_scope_implementer_;
   }
   Zone* zone() { return &zone_; }
 
   // SerializerDeserializer state.
   static const int kPartialSnapshotCacheCapacity = 1300;
 
   static int number_of_isolates() { return number_of_isolates_; }
 
  private:
   Isolate();
 
   static Isolate* global_isolate;
   // TODO(isolates): Access to this global counter should be serialized.
   static int number_of_isolates_;
 
+  // Initialize process-wide state.
+  static void InitOnce();
+
+  bool PreInit();
+
   bool Init(Deserializer* des);
 
-  bool initialized_;
+  enum State {
+    UNINITIALIZED,    // Some components may not have been allocated.
+    PREINITIALIZED,   // Components have been allocated but not initialized.
+    INITIALIZED       // All components are fully initialized.
+  };
+
+  State state_;
 
   Bootstrapper* bootstrapper_;
+  Mutex* break_access_;
   Heap heap_;
+  StackGuard stack_guard_;
   StubCache* stub_cache_;
   v8::ImplementationUtilities::HandleScopeData handle_scope_data_;
   HandleScopeImplementer* handle_scope_implementer_;
   Zone zone_;
 
 #define GLOBAL_BACKING_STORE(type, name, initialvalue)                         \
   type name##_;
   ISOLATE_INIT_LIST(GLOBAL_BACKING_STORE)
 #undef GLOBAL_BACKING_STORE
 
 #define GLOBAL_ARRAY_BACKING_STORE(type, name, length)                         \
   type name##_[length];
   ISOLATE_INIT_ARRAY_LIST(GLOBAL_ARRAY_BACKING_STORE)
 #undef GLOBAL_ARRAY_BACKING_STORE
 
+  friend class IsolateInitializer;
+
   DISALLOW_COPY_AND_ASSIGN(Isolate);
 };
 
+
+// Support for checking for stack-overflows in C++ code.
+class StackLimitCheck BASE_EMBEDDED {
+ public:
+  bool HasOverflowed() const {
+    StackGuard* stack_guard = Isolate::Current()->stack_guard();
+    // Stack has overflowed in C++ code only if stack pointer exceeds the C++
+    // stack guard and the limits are not set to interrupt values.
+    // TODO(214): Stack overflows are ignored if a interrupt is pending. This
+    // code should probably always use the initial C++ limit.
+    return (reinterpret_cast<uintptr_t>(this) < stack_guard->climit()) &&
+           stack_guard->IsStackOverflow();
+  }
+};
+
+
+// Support for temporarily postponing interrupts. When the outermost
+// postpone scope is left the interrupts will be re-enabled and any
+// interrupts that occurred while in the scope will be taken into
+// account.
+class PostponeInterruptsScope BASE_EMBEDDED {
+ public:
+  PostponeInterruptsScope() {
+    StackGuard* stack_guard = Isolate::Current()->stack_guard();
+    stack_guard->thread_local_.postpone_interrupts_nesting_++;
+    stack_guard->DisableInterrupts();
+  }
+
+  ~PostponeInterruptsScope() {
+    StackGuard* stack_guard = Isolate::Current()->stack_guard();
+    if (--stack_guard->thread_local_.postpone_interrupts_nesting_ == 0) {
+      stack_guard->EnableInterrupts();
+    }
+  }
+};
+
+
 // Temporary macros for accessing fields off the global isolate. Define these
 // when reformatting code would become burdensome.
 #define HEAP (v8::internal::Isolate::Current()->heap())
 #define ZONE (v8::internal::Isolate::Current()->zone())
 
 
 // Temporary macro to be used to flag definitions that are indeed static
 // and not per-isolate. (It would be great to be able to grep for [static]!)
 #define RLYSTC static
 
 
 // Temporary macro to be used to flag classes that should be static.
 #define STATIC_CLASS class
 
 
 // Temporary macro to be used to flag classes that are completely converted
 // to be isolate-friendly. Their mix of static/nonstatic methods/fields is
 // correct.
 #define ISOLATED_CLASS class
 
 } }  // namespace v8::internal
 
 #endif  // V8_ISOLATE_H_