Expose TickSample and its APIs in v8-profiler.h

src/profiler/profile-generator.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/profiler/profile-generator.h"
 
 #include "src/ast/scopeinfo.h"
 #include "src/base/adapters.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/global-handles.h"
 #include "src/profiler/cpu-profiler.h"
 #include "src/profiler/profile-generator-inl.h"
-#include "src/profiler/tick-sample.h"
 #include "src/unicode.h"
 
 namespace v8 {
 namespace internal {
 
 
 JITLineInfoTable::JITLineInfoTable() {}
 
 
 JITLineInfoTable::~JITLineInfoTable() {}
@@ skipping 546 matching lines @@
   // for a JS function. Then, the detected source line is passed to
   // ProfileNode to increase the tick count for this source line.
   int src_line = v8::CpuProfileNode::kNoLineNumberInfo;
   bool src_line_not_found = true;
 
   if (sample.pc != nullptr) {
     if (sample.has_external_callback && sample.state == EXTERNAL) {
       // Don't use PC when in external callback code, as it can point
       // inside callback's code, and we will erroneously report
       // that a callback calls itself.
-      entries.push_back(code_map_.FindEntry(sample.external_callback_entry));
+      entries.push_back(code_map_.FindEntry(
+          reinterpret_cast<Address>(sample.external_callback_entry)));
     } else {
-      CodeEntry* pc_entry = code_map_.FindEntry(sample.pc);
+      CodeEntry* pc_entry =
+          code_map_.FindEntry(reinterpret_cast<Address>(sample.pc));
       // If there is no pc_entry we're likely in native code.
       // Find out, if top of stack was pointing inside a JS function
       // meaning that we have encountered a frameless invocation.
       if (!pc_entry && !sample.has_external_callback) {
-        pc_entry = code_map_.FindEntry(sample.tos);
+        pc_entry = code_map_.FindEntry(reinterpret_cast<Address>(sample.tos));
       }
       // If pc is in the function code before it set up stack frame or after the
       // frame was destroyed SafeStackFrameIterator incorrectly thinks that
       // ebp contains return address of the current function and skips caller's
       // frame. Check for this case and just skip such samples.
       if (pc_entry) {
-        int pc_offset =
-            static_cast<int>(sample.pc - pc_entry->instruction_start());
+        int pc_offset = static_cast<int>(reinterpret_cast<Address>(sample.pc) -
+                                         pc_entry->instruction_start());
         src_line = pc_entry->GetSourceLine(pc_offset);
         if (src_line == v8::CpuProfileNode::kNoLineNumberInfo) {
           src_line = pc_entry->line_number();
         }
         src_line_not_found = false;
         entries.push_back(pc_entry);
 
         if (pc_entry->builtin_id() == Builtins::kFunctionPrototypeApply ||
             pc_entry->builtin_id() == Builtins::kFunctionPrototypeCall) {
           // When current function is either the Function.prototype.apply or the
           // Function.prototype.call builtin the top frame is either frame of
           // the calling JS function or internal frame.
           // In the latter case we know the caller for sure but in the
           // former case we don't so we simply replace the frame with
           // 'unresolved' entry.
           if (!sample.has_external_callback) {
             entries.push_back(CodeEntry::unresolved_entry());
           }
         }
       }
     }
 
-    for (const Address *stack_pos = sample.stack,
-                       *stack_end = stack_pos + sample.frames_count;
-         stack_pos != stack_end; ++stack_pos) {
-      CodeEntry* entry = code_map_.FindEntry(*stack_pos);
+    for (unsigned i = 0; i < sample.frames_count; ++i) {
+      Address stack_pos = reinterpret_cast<Address>(sample.stack[i]);
+      CodeEntry* entry = code_map_.FindEntry(stack_pos);
 
       if (entry) {
         // Find out if the entry has an inlining stack associated.
         int pc_offset =
-            static_cast<int>(*stack_pos - entry->instruction_start());
+            static_cast<int>(stack_pos - entry->instruction_start());
         const std::vector<CodeEntry*>* inline_stack =
             entry->GetInlineStack(pc_offset);
         if (inline_stack) {
           entries.insert(entries.end(), inline_stack->rbegin(),
                          inline_stack->rend());
         }
         // Skip unresolved frames (e.g. internal frame) and get source line of
         // the first JS caller.
         if (src_line_not_found) {
           src_line = entry->GetSourceLine(pc_offset);
@@ skipping 39 matching lines @@
     case EXTERNAL:
       return CodeEntry::program_entry();
     case IDLE:
       return CodeEntry::idle_entry();
     default: return NULL;
   }
 }
 
 }  // namespace internal
 }  // namespace v8