[Interpreter] Add support for cpu profiler logging.

src/frames.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/frames.h"
 
 #include <sstream>
 
 #include "src/ast/ast.h"
 #include "src/ast/scopeinfo.h"
@@ skipping 385 matching lines @@
   }
 }
 
 
 void StackFrame::SetReturnAddressLocationResolver(
     ReturnAddressLocationResolver resolver) {
   DCHECK(return_address_location_resolver_ == NULL);
   return_address_location_resolver_ = resolver;
 }
 
+static bool IsInterpreterFramePc(Isolate* isolate, Address pc) {
+  return (pc >= isolate->interpreter_entry_trampoline_start() &&
+          pc < isolate->interpreter_entry_trampoline_end()) ||
+         (pc >= isolate->interpreter_bytecode_dispatch_start() &&
+          pc < isolate->interpreter_bytecode_dispatch_end());
+}
 
 StackFrame::Type StackFrame::ComputeType(const StackFrameIteratorBase* iterator,
                                          State* state) {
   DCHECK(state->fp != NULL);
 
   if (!iterator->can_access_heap_objects_) {
     // TODO(titzer): "can_access_heap_objects" is kind of bogus. It really
     // means that we are being called from the profiler, which can interrupt
     // the VM with a signal at any arbitrary instruction, with essentially
     // anything on the stack. So basically none of these checks are 100%
     // reliable.
 #if defined(USE_SIMULATOR)
     MSAN_MEMORY_IS_INITIALIZED(
         state->fp + StandardFrameConstants::kContextOffset, kPointerSize);
     MSAN_MEMORY_IS_INITIALIZED(
         state->fp + StandardFrameConstants::kMarkerOffset, kPointerSize);
 #endif
     if (StandardFrame::IsArgumentsAdaptorFrame(state->fp)) {
       // An adapter frame has a special SMI constant for the context and
       // is not distinguished through the marker.
       return ARGUMENTS_ADAPTOR;
     }
     Object* marker =
         Memory::Object_at(state->fp + StandardFrameConstants::kMarkerOffset);
     if (marker->IsSmi()) {
       return static_cast<StackFrame::Type>(Smi::cast(marker)->value());
+    } else if (FLAG_ignition && IsInterpreterFramePc(iterator->isolate(),
+                                                     *(state->pc_address))) {
+      return INTERPRETED;
     } else {
       return JAVA_SCRIPT;
     }
   }
 
   // Look up the code object to figure out the type of the stack frame.
   Code* code_obj = GetContainingCode(iterator->isolate(), *(state->pc_address));
 
   Object* marker =
       Memory::Object_at(state->fp + StandardFrameConstants::kMarkerOffset);
@@ skipping 1204 matching lines @@
   for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
     list.Add(frame, zone);
   }
   return list.ToVector();
 }
 
 
 }  // namespace internal
 }  // namespace v8