[Isolates] Merge crankshaft (r5922 from bleeding_edge).

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 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // 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 "../include/v8-debug.h"
 #include "allocation.h"
 #include "apiutils.h"
+#include "atomicops.h"
 #include "builtins.h"
 #include "contexts.h"
 #include "execution.h"
 #include "frames.h"
 #include "global-handles.h"
 #include "handles.h"
 #include "heap.h"
 #include "regexp-stack.h"
+#include "runtime-profiler.h"
 #include "runtime.h"
 #include "zone.h"
-#include "../include/v8-debug.h"
 
 
 #if !defined(__arm__) && defined(V8_TARGET_ARCH_ARM)
 namespace assembler {
 namespace arm {
 class Redirection;
 class Simulator;
 }
 }
 #endif
 
 
 namespace v8 {
 namespace internal {
 
 class AstSentinels;
 class Bootstrapper;
 class CodeGenerator;
+class CodeRange;
 class CompilationCache;
 class ContextSlotCache;
 class ContextSwitcher;
-class CodeRange;
 class Counters;
 class CpuFeatures;
 class CpuProfiler;
+class DeoptimizerData;
 class Deserializer;
 class EmptyStatement;
 class ExternalReferenceTable;
 class Factory;
 class FunctionInfoListener;
 class HandleScopeImplementer;
 class HeapProfiler;
 class InlineRuntimeFunctionsTable;
 class NoAllocationStringAllocator;
+class PcToCodeCache;
 class PreallocatedMemoryThread;
 class ProducerHeapProfile;
 class RegExpStack;
 class SaveContext;
-class StubCache;
+class ScannerConstants;
 class StringInputBuffer;
 class StringTracker;
-class ScannerConstants;
-class ThreadVisitor;  // Defined in v8threads.h
+class StubCache;
 class ThreadManager;
 class ThreadState;
+class ThreadVisitor;  // Defined in v8threads.h
 class VMState;
 
 typedef void* ExternalReferenceRedirector(void* original, bool fp_return);
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 class Debug;
 class Debugger;
 class DebuggerAgent;
 #endif
@@ skipping 89 matching lines @@
 #ifdef USE_SIMULATOR
 #ifdef V8_TARGET_ARCH_ARM
   assembler::arm::Simulator* simulator_;
 #elif V8_TARGET_ARCH_MIPS
   assembler::mips::Simulator* simulator_;
 #endif
 #endif  // USE_SIMULATOR
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
   Address js_entry_sp_;  // the stack pointer of the bottom js entry frame
+  Address external_callback_;  // the external callback we're currently in
 #endif
 
 #ifdef ENABLE_VMSTATE_TRACKING
-  VMState* current_vm_state_;
+  StateTag current_vm_state_;
 #endif
 
   // Generated code scratch locations.
   int32_t formal_count_;
 
   // Call back function to report unsafe JS accesses.
   v8::FailedAccessCheckCallback failed_access_check_callback_;
 
  private:
   Address try_catch_handler_address_;
 };
 
 #if defined(V8_TARGET_ARCH_ARM)
 
 #define ISOLATE_PLATFORM_INIT_LIST(V)                                          \
   /* VirtualFrame::SpilledScope state */                                       \
-  V(bool, is_virtual_frame_in_spilled_scope, false)
+  V(bool, is_virtual_frame_in_spilled_scope, false)                            \
+  /* CodeGenerator::EmitNamedStore state */                                    \
+  V(int, inlined_write_barrier_size, -1)
 
 #if !defined(__arm__)
 class HashMap;
 #endif
 
 #else
 
 #define ISOLATE_PLATFORM_INIT_LIST(V)
 
 #endif
@@ skipping 66 matching lines @@
   V(Relocatable*, relocatable_top, NULL)                                       \
   /* State for CodeEntry in profile-generator. */                              \
   V(CodeGenerator*, current_code_generator, NULL)                              \
   V(bool, jump_target_compiling_deferred_code, false)                          \
   V(DebugObjectCache*, string_stream_debug_object_cache, NULL)                 \
   V(Object*, string_stream_current_security_token, NULL)                       \
   /* TODO(isolates): Release this on destruction? */                           \
   V(int*, irregexp_interpreter_backtrack_stack_cache, NULL)                    \
   /* Serializer state. */                                                      \
   V(ExternalReferenceTable*, external_reference_table, NULL)                   \
+  /* AstNode state. */                                                         \
+  V(unsigned, ast_node_id, 0)                                                  \
+  V(unsigned, ast_node_count, 0)                                               \
   ISOLATE_PLATFORM_INIT_LIST(V)                                                \
   ISOLATE_LOGGING_INIT_LIST(V)                                                 \
   ISOLATE_DEBUGGER_INIT_LIST(V)
 
 class Isolate {
   // These forward declarations are required to make the friend declarations in
   // PerIsolateThreadData work on some older versions of gcc.
   class ThreadDataTable;
   class EntryStackItem;
  public:
@@ skipping 215 matching lines @@
 #ifdef ENABLE_LOGGING_AND_PROFILING
   // Bottom JS entry (see StackTracer::Trace in log.cc).
   static Address js_entry_sp(ThreadLocalTop* thread) {
     return thread->js_entry_sp_;
   }
   inline Address* js_entry_sp_address() {
     return &thread_local_top_.js_entry_sp_;
   }
 #endif
 
-#ifdef ENABLE_VMSTATE_TRACKING
-  VMState* current_vm_state() {
-    return thread_local_top_.current_vm_state_;
-  }
-
-  void set_current_vm_state(VMState* state) {
-    thread_local_top_.current_vm_state_ = state;
-  }
-#endif
-
   // Generated code scratch locations.
   void* formal_count_address() { return &thread_local_top_.formal_count_; }
 
   // Returns the global object of the current context. It could be
   // a builtin object, or a js global object.
   Handle<GlobalObject> global() {
     return Handle<GlobalObject>(context()->global());
   }
 
   // Returns the global proxy object of the current context.
@@ skipping 115 matching lines @@
 
 #define GLOBAL_CONTEXT_FIELD_ACCESSOR(index, type, name)      \
   Handle<type> name() {                                       \
     return Handle<type>(context()->global_context()->name()); \
   }
   GLOBAL_CONTEXT_FIELDS(GLOBAL_CONTEXT_FIELD_ACCESSOR)
 #undef GLOBAL_CONTEXT_FIELD_ACCESSOR
 
   Bootstrapper* bootstrapper() { return bootstrapper_; }
   Counters* counters() { return counters_; }
+  // TODO(isolates): Having CPU features per isolate is probably too
+  // flexible. We only really need to have the set of currently
+  // enabled features for asserts in DEBUG builds.
   CpuFeatures* cpu_features() { return cpu_features_; }
   CodeRange* code_range() { return code_range_; }
+  RuntimeProfiler* runtime_profiler() { return runtime_profiler_; }
   CompilationCache* compilation_cache() { return compilation_cache_; }
   Logger* logger() { return logger_; }
   StackGuard* stack_guard() { return &stack_guard_; }
   Heap* heap() { return &heap_; }
   StatsTable* stats_table() { return stats_table_; }
   StubCache* stub_cache() { return stub_cache_; }
+  DeoptimizerData* deoptimizer_data() { return deoptimizer_data_; }
   ThreadLocalTop* thread_local_top() { return &thread_local_top_; }
 
   TranscendentalCache* transcendental_cache() const {
     return transcendental_cache_;
   }
 
   MemoryAllocator* memory_allocator() {
     return memory_allocator_;
   }
 
@@ skipping 140 matching lines @@
   }
 #endif
 
   Factory* factory() { return reinterpret_cast<Factory*>(this); }
 
   // SerializerDeserializer state.
   static const int kPartialSnapshotCacheCapacity = 1400;
 
   static const int kJSRegexpStaticOffsetsVectorSize = 50;
 
+#ifdef ENABLE_LOGGING_AND_PROFILING
+  Address external_callback() {
+    return thread_local_top_.external_callback_;
+  }
+  void set_external_callback(Address callback) {
+    thread_local_top_.external_callback_ = callback;
+  }
+#endif
+
+#ifdef ENABLE_VMSTATE_TRACKING
+  StateTag current_vm_state() {
+    return thread_local_top_.current_vm_state_;
+  }
+
+  void SetCurrentVMState(StateTag state) {
+    if (RuntimeProfiler::IsEnabled()) {
+      if (state == JS) {
+        // JS or non-JS -> JS transition.
+        RuntimeProfiler::IsolateEnteredJS(this);
+      } else if (thread_local_top_.current_vm_state_ == JS) {
+        // JS -> non-JS transition.
+        ASSERT(RuntimeProfiler::IsSomeIsolateInJS());
+        RuntimeProfiler::IsolateExitedJS(this);
+      }
+    }
+    thread_local_top_.current_vm_state_ = state;
+  }
+#endif
+
+  void ResetEagerOptimizingData();
 
  private:
   Isolate();
 
   // The per-process lock should be acquired before the ThreadDataTable is
   // modified.
   class ThreadDataTable {
    public:
     ThreadDataTable();
     ~ThreadDataTable();
@@ skipping 94 matching lines @@
   void FillCache();
 
   int stack_trace_nesting_level_;
   StringStream* incomplete_message_;
   // The preallocated memory thread singleton.
   PreallocatedMemoryThread* preallocated_memory_thread_;
   Address isolate_addresses_[k_isolate_address_count + 1];  // NOLINT
   NoAllocationStringAllocator* preallocated_message_space_;
 
   Bootstrapper* bootstrapper_;
+  RuntimeProfiler* runtime_profiler_;
   CompilationCache* compilation_cache_;
   Counters* counters_;
   CpuFeatures* cpu_features_;
   CodeRange* code_range_;
   Mutex* break_access_;
   Heap heap_;
   Logger* logger_;
   StackGuard stack_guard_;
   StatsTable* stats_table_;
   StubCache* stub_cache_;
+  DeoptimizerData* deoptimizer_data_;
   ThreadLocalTop thread_local_top_;
   bool capture_stack_trace_for_uncaught_exceptions_;
   int stack_trace_for_uncaught_exceptions_frame_limit_;
   StackTrace::StackTraceOptions stack_trace_for_uncaught_exceptions_options_;
   TranscendentalCache* transcendental_cache_;
   MemoryAllocator* memory_allocator_;
   KeyedLookupCache* keyed_lookup_cache_;
   ContextSlotCache* context_slot_cache_;
   DescriptorLookupCache* descriptor_lookup_cache_;
   v8::ImplementationUtilities::HandleScopeData handle_scope_data_;
@@ skipping 52 matching lines @@
 #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 ExecutionAccess;
   friend class IsolateInitializer;
   friend class v8::Isolate;
   friend class v8::Locker;
 
   DISALLOW_COPY_AND_ASSIGN(Isolate);
 };
 
 
 // If the GCC version is 4.1.x or 4.2.x an additional field is added to the
 // class as a work around for a bug in the generated code found with these
@@ skipping 60 matching lines @@
   Handle<Context> context_;
 #else
  public:
   AssertNoContextChange() { }
 #endif
 };
 
 
 class ExecutionAccess BASE_EMBEDDED {
  public:
-  ExecutionAccess();
-  ~ExecutionAccess();
+  explicit ExecutionAccess(Isolate* isolate) : isolate_(isolate) {
+    Lock(isolate);
+  }
+  ~ExecutionAccess() { Unlock(isolate_); }
+
+  static void Lock(Isolate* isolate) { isolate->break_access_->Lock(); }
+  static void Unlock(Isolate* isolate) { isolate->break_access_->Unlock(); }
+
+  static bool TryLock(Isolate* isolate) {
+    return isolate->break_access_->TryLock();
+  }
+
+ private:
+  Isolate* isolate_;
 };
 
 
 // Support for checking for stack-overflows in C++ code.
 class StackLimitCheck BASE_EMBEDDED {
  public:
   explicit StackLimitCheck(Isolate* isolate) : isolate_(isolate) { }
 
   bool HasOverflowed() const {
     StackGuard* stack_guard = isolate_->stack_guard();
@@ skipping 68 matching lines @@
 
 } }  // namespace v8::internal
 
 // TODO(isolates): Get rid of these -inl.h includes and place them only where
 //                 they're needed.
 #include "allocation-inl.h"
 #include "zone-inl.h"
 #include "frames-inl.h"
 
 #endif  // V8_ISOLATE_H_