Expose TickSample and its APIs in v8-profiler.h

src/api.cc

 // 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.
 
 #include "src/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 18 matching lines @@
 #include "src/char-predicates-inl.h"
 #include "src/code-stubs.h"
 #include "src/compiler.h"
 #include "src/context-measure.h"
 #include "src/contexts.h"
 #include "src/conversions-inl.h"
 #include "src/counters.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
+#include "src/frames-inl.h"
 #include "src/gdb-jit.h"
 #include "src/global-handles.h"
 #include "src/icu_util.h"
 #include "src/isolate-inl.h"
 #include "src/json-parser.h"
 #include "src/json-stringifier.h"
 #include "src/messages.h"
 #include "src/parsing/parser.h"
 #include "src/parsing/scanner-character-streams.h"
 #include "src/pending-compilation-error-handler.h"
 #include "src/profiler/cpu-profiler.h"
 #include "src/profiler/heap-profiler.h"
 #include "src/profiler/heap-snapshot-generator-inl.h"
 #include "src/profiler/profile-generator-inl.h"
-#include "src/profiler/tick-sample.h"
+#include "src/profiler/simulator-helper.h"
 #include "src/property-descriptor.h"
 #include "src/property-details.h"
 #include "src/property.h"
 #include "src/prototype.h"
 #include "src/runtime-profiler.h"
 #include "src/runtime/runtime.h"
 #include "src/simulator.h"
 #include "src/snapshot/natives.h"
 #include "src/snapshot/snapshot.h"
 #include "src/startup-data-util.h"
@@ skipping 7493 matching lines @@
   isolate->heap()->CollectCodeStatistics();
 
   code_statistics->code_and_metadata_size_ = isolate->code_and_metadata_size();
   code_statistics->bytecode_and_metadata_size_ =
       isolate->bytecode_and_metadata_size();
   return true;
 }
 
 void Isolate::GetStackSample(const RegisterState& state, void** frames,
                              size_t frames_limit, SampleInfo* sample_info) {
+#if defined(USE_SIMULATOR)
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
-#if defined(USE_SIMULATOR)
   RegisterState regs;
   regs.pc = state.pc;
   regs.sp = state.sp;
   regs.fp = state.fp;
   if (!i::SimulatorHelper::FillRegisters(isolate, &regs)) {
     sample_info->frames_count = 0;
     sample_info->vm_state = OTHER;
     sample_info->external_callback_entry = nullptr;
     return;
   }
 #else
   const RegisterState& regs = state;
 #endif
-  i::TickSample::GetStackSample(isolate, regs, i::TickSample::kSkipCEntryFrame,
-                                frames, frames_limit, sample_info);
+  TickSample::GetStackSample(this, regs, TickSample::kSkipCEntryFrame, frames,
+                             frames_limit, sample_info);
 }
 
 size_t Isolate::NumberOfPhantomHandleResetsSinceLastCall() {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   size_t result = isolate->global_handles()->NumberOfPhantomHandleResets();
   isolate->global_handles()->ResetNumberOfPhantomHandleResets();
   return result;
 }
 
 void Isolate::SetEventLogger(LogEventCallback that) {
@@ skipping 658 matching lines @@
                                                Local<Value> value) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   ENTER_V8(isolate);
   i::Handle<i::Object> val = Utils::OpenHandle(*value);
   i::Handle<i::JSArray> result;
   if (!i::Runtime::GetInternalProperties(isolate, val).ToHandle(&result))
     return MaybeLocal<Array>();
   return Utils::ToLocal(result);
 }
 
+namespace {
+
+bool IsSamePage(i::byte* ptr1, i::byte* ptr2) {
+  const uint32_t kPageSize = 4096;
+  uintptr_t mask = ~static_cast<uintptr_t>(kPageSize - 1);
+  return (reinterpret_cast<uintptr_t>(ptr1) & mask) ==
+         (reinterpret_cast<uintptr_t>(ptr2) & mask);
+}
+
+// Check if the code at specified address could potentially be a
+// frame setup code.
+bool IsNoFrameRegion(i::Address address) {
+  struct Pattern {
+    int bytes_count;
+    i::byte bytes[8];
+    int offsets[4];
+  };
+  i::byte* pc = reinterpret_cast<i::byte*>(address);
+  static Pattern patterns[] = {
+#if V8_HOST_ARCH_IA32
+    // push %ebp
+    // mov %esp,%ebp
+    {3, {0x55, 0x89, 0xe5}, {0, 1, -1}},
+    // pop %ebp
+    // ret N
+    {2, {0x5d, 0xc2}, {0, 1, -1}},
+    // pop %ebp
+    // ret
+    {2, {0x5d, 0xc3}, {0, 1, -1}},
+#elif V8_HOST_ARCH_X64
+    // pushq %rbp
+    // movq %rsp,%rbp
+    {4, {0x55, 0x48, 0x89, 0xe5}, {0, 1, -1}},
+    // popq %rbp
+    // ret N
+    {2, {0x5d, 0xc2}, {0, 1, -1}},
+    // popq %rbp
+    // ret
+    {2, {0x5d, 0xc3}, {0, 1, -1}},
+#endif
+    {0, {}, {}}
+  };
+  for (Pattern* pattern = patterns; pattern->bytes_count; ++pattern) {
+    for (int* offset_ptr = pattern->offsets; *offset_ptr != -1; ++offset_ptr) {
+      int offset = *offset_ptr;
+      if (!offset || IsSamePage(pc, pc - offset)) {
+        MSAN_MEMORY_IS_INITIALIZED(pc - offset, pattern->bytes_count);
+        if (!memcmp(pc - offset, pattern->bytes, pattern->bytes_count))
+          return true;
+      } else {
+        // It is not safe to examine bytes on another page as it might not be
+        // allocated thus causing a SEGFAULT.
+        // Check the pattern part that's on the same page and
+        // pessimistically assume it could be the entire pattern match.
+        MSAN_MEMORY_IS_INITIALIZED(pc, pattern->bytes_count - offset);
+        if (!memcmp(pc, pattern->bytes + offset, pattern->bytes_count - offset))
+          return true;
+      }
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
+//
+// StackTracer implementation
+//
+DISABLE_ASAN void TickSample::Init(Isolate* v8_isolate,

[alph, 2016/06/28 22:09:01]

Don't move that much logic into api.cc
Keep it in a file under profiler. Also you can put SimulatorHelper there rather
than making a dedicated file for it.

[lpy, 2016/06/28 23:02:53]

Done.

+                                   const RegisterState& regs,
+                                   RecordCEntryFrame record_c_entry_frame,
+                                   bool update_stats) {
+  this->update_stats = update_stats;
+
+  SampleInfo info;
+  if (GetStackSample(v8_isolate, const_cast<RegisterState&>(regs),
+                     record_c_entry_frame, reinterpret_cast<void**>(&stack[0]),
+                     kMaxFramesCount, &info)) {
+    state = info.vm_state;
+    pc = regs.pc;
+    frames_count = static_cast<unsigned>(info.frames_count);
+    has_external_callback = info.external_callback_entry != nullptr;
+    if (has_external_callback) {
+      external_callback_entry = info.external_callback_entry;
+    } else if (frames_count) {
+      // sp register may point at an arbitrary place in memory, make
+      // sure MSAN doesn't complain about it.
+      MSAN_MEMORY_IS_INITIALIZED(regs.sp, sizeof(void*));
+      // Sample potential return address value for frameless invocation of
+      // stubs (we'll figure out later, if this value makes sense).
+      tos = i::Memory::Address_at(reinterpret_cast<i::Address>(regs.sp));
+    } else {
+      tos = nullptr;
+    }
+  } else {
+    // It is executing JS but failed to collect a stack trace.
+    // Mark the sample as spoiled.
+    pc = nullptr;
+  }
+}
+
+bool TickSample::GetStackSample(Isolate* v8_isolate, const RegisterState& regs,
+                                RecordCEntryFrame record_c_entry_frame,
+                                void** frames, size_t frames_limit,
+                                v8::SampleInfo* sample_info) {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
+  sample_info->frames_count = 0;
+  sample_info->vm_state = isolate->current_vm_state();
+  sample_info->external_callback_entry = nullptr;
+  if (sample_info->vm_state == GC) return true;
+
+  i::Address js_entry_sp = isolate->js_entry_sp();
+  if (js_entry_sp == nullptr) return true;  // Not executing JS now.
+  DCHECK(regs.sp);
+
+  if (regs.pc && IsNoFrameRegion(static_cast<i::Address>(regs.pc))) {
+    // Can't collect stack.
+    return false;
+  }
+
+  i::ExternalCallbackScope* scope = isolate->external_callback_scope();
+  i::Address handler = i::Isolate::handler(isolate->thread_local_top());
+  // If there is a handler on top of the external callback scope then
+  // we have already entrered JavaScript again and the external callback
+  // is not the top function.
+  if (scope && scope->scope_address() < handler) {
+    sample_info->external_callback_entry =
+        *scope->callback_entrypoint_address();
+  }
+
+  i::SafeStackFrameIterator it(isolate, reinterpret_cast<i::Address>(regs.fp),
+                               reinterpret_cast<i::Address>(regs.sp),
+                               js_entry_sp);
+  size_t i = 0;
+  if (record_c_entry_frame == kIncludeCEntryFrame && !it.done() &&
+      it.top_frame_type() == i::StackFrame::EXIT) {
+    frames[i++] = isolate->c_function();
+  }
+  while (!it.done() && i < frames_limit) {
+    if (it.frame()->is_interpreted()) {
+      // For interpreted frames use the bytecode array pointer as the pc.
+      i::InterpretedFrame* frame =
+          static_cast<i::InterpretedFrame*>(it.frame());
+      // Since the sampler can interrupt execution at any point the
+      // bytecode_array might be garbage, so don't dereference it.
+      i::Address bytecode_array =
+          reinterpret_cast<i::Address>(frame->GetBytecodeArray()) -
+          i::kHeapObjectTag;
+      frames[i++] = bytecode_array + i::BytecodeArray::kHeaderSize +
+                    frame->GetBytecodeOffset();
+    } else {
+      frames[i++] = it.frame()->pc();
+    }
+    it.Advance();
+  }
+  sample_info->frames_count = i;
+  return true;
+}
 
 Local<String> CpuProfileNode::GetFunctionName() const {
   const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
   i::Isolate* isolate = node->isolate();
   const i::CodeEntry* entry = node->entry();
   i::Handle<i::String> name =
       isolate->factory()->InternalizeUtf8String(entry->name());
   if (!entry->has_name_prefix()) {
     return ToApiHandle<String>(name);
   } else {
@@ skipping 652 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8