Revert of Move stack trace extraction code out of TickSample::Init

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"
@@ skipping 590 matching lines @@
   entries.reserve(sample.frames_count + 3);
 
   // The ProfileNode knows nothing about all versions of generated code for
   // the same JS function. The line number information associated with
   // the latest version of generated code is used to find a source line number
   // 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) {
+  if (sample.pc != NULL) {
+    if (sample.has_external_callback && sample.state == EXTERNAL &&
+        sample.top_frame_type == StackFrame::EXIT) {
       // 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));
     } else {
       CodeEntry* pc_entry = code_map_.FindEntry(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) {
+      if (!pc_entry && (sample.top_frame_type == StackFrame::JAVA_SCRIPT ||
+                        sample.top_frame_type == StackFrame::INTERPRETED ||
+                        sample.top_frame_type == StackFrame::OPTIMIZED)) {
         pc_entry = code_map_.FindEntry(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());
         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) {
+          if (sample.top_frame_type == StackFrame::JAVA_SCRIPT) {
             entries.push_back(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);
@@ skipping 54 matching lines @@
     case EXTERNAL:
       return program_entry_;
     case IDLE:
       return idle_entry_;
     default: return NULL;
   }
 }
 
 }  // namespace internal
 }  // namespace v8