[Interpreter] Add support for cpu profiler logging.

src/isolate.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_ISOLATE_H_
 #define V8_ISOLATE_H_
 
 #include <queue>
 #include <set>
 
@@ skipping 596 matching lines @@
   }
 
   // Bottom JS entry.
   Address js_entry_sp() {
     return thread_local_top_.js_entry_sp_;
   }
   inline Address* js_entry_sp_address() {
     return &thread_local_top_.js_entry_sp_;
   }
 
+  inline Address interpreter_entry_trampoline_start() {
+    return interpreter_entry_trampoline_start_;

[Yang, 2016/02/25 11:50:43]

Do we really need this cache? This requires the code object for the interpreter
entry trampoline to never move. We could also just get
builtins()->InterpreterEntryTrampoline()->instruction_start().

[rmcilroy, 2016/02/25 11:55:11]

This is not a cache, it is required for safty in the sampling thread. Originally
I was using builtins()->InterpreterEntryTrampoline(), but we can't do that in
StackFrame::ComputeType for SafeStackIterator (i.e., when
!iterator->can_access_heap_objects_) since it requires dereferencing of heap
pointers and handles which is not safe at any arbitrary point that the sampler
might interrupt the main thread. The particular situation I've seen is where
DisallowHandleDereference is on the stack when the profiler interrupts the main
thread, which causes the sampler thread to crash when dereferencing
builtins()->InterpreterEntryTrampoline()

[rmcilroy, 2016/02/25 15:06:54]

Done.

+  }
+  inline Address interpreter_entry_trampoline_end() {
+    return interpreter_entry_trampoline_end_;
+  }
+  inline Address interpreter_bytecode_dispatch_start() {
+    return interpreter_bytecode_dispatch_start_;
+  }
+  inline Address interpreter_bytecode_dispatch_end() {
+    return interpreter_bytecode_dispatch_end_;
+  }
+
   // Returns the global object of the current context. It could be
   // a builtin object, or a JS global object.
   inline Handle<JSGlobalObject> global_object();
 
   // Returns the global proxy object of the current context.
   JSObject* global_proxy() {
     return context()->global_proxy();
   }
 
   static int ArchiveSpacePerThread() { return sizeof(ThreadLocalTop); }
@@ skipping 681 matching lines @@
 
   DeferredHandles* deferred_handles_head_;
   OptimizingCompileDispatcher* optimizing_compile_dispatcher_;
 
   // Counts deopt points if deopt_every_n_times is enabled.
   unsigned int stress_deopt_count_;
 
   Address virtual_handler_register_;
   Address virtual_slot_register_;
 
+  // Addresses used in frames.cc to determine if a frame is an interpreter
+  // frame without looking at heap objects.
+  Address interpreter_entry_trampoline_start_;
+  Address interpreter_entry_trampoline_end_;
+  Address interpreter_bytecode_dispatch_start_;
+  Address interpreter_bytecode_dispatch_end_;
+
   int next_optimization_id_;
 
   // Counts javascript calls from the API. Wraps around on overflow.
   unsigned int js_calls_from_api_counter_;
 
 #if TRACE_MAPS
   int next_unique_sfi_id_;
 #endif
 
   // List of callbacks before a Call starts execution.
@@ skipping 238 matching lines @@
 
   EmbeddedVector<char, 128> filename_;
   FILE* file_;
   int scope_depth_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_ISOLATE_H_