Add Profiler::DumpStackTrace

runtime/vm/profiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
@@ skipping 310 matching lines @@
 ClearProfileVisitor::ClearProfileVisitor(Isolate* isolate)
     : SampleVisitor(isolate) {
 }
 
 
 void ClearProfileVisitor::VisitSample(Sample* sample) {
   sample->Clear();
 }
 
 
+static void DumpStackFrame(intptr_t frame_index, uword pc) {
+  uintptr_t start = 0;
+  char* native_symbol_name =
+      NativeSymbolResolver::LookupSymbolName(pc, &start);
+  if (native_symbol_name == NULL) {
+    OS::Print("Frame[%" Pd "] = `unknown symbol` [0x%" Px "]\n",
+              frame_index, pc);
+  } else {
+    OS::Print("Frame[%" Pd "] = `%s` [0x%" Px "]\n",
+              frame_index, native_symbol_name, pc);
+    free(native_symbol_name);
+  }
+}
+
+
+static void DumpStackFrame(intptr_t frame_index,
+                           uword pc,
+                           const Code& code) {
+  if (code.IsNull()) {
+    DumpStackFrame(frame_index, pc);
+  } else {
+    OS::Print("Frame[%" Pd "] = Dart:`%s` [0x%" Px "]\n",
+              frame_index, code.ToCString(), pc);
+  }
+}
+
+
 class ProfilerStackWalker : public ValueObject {
  public:
   ProfilerStackWalker(Isolate* isolate,
                       Sample* head_sample,
                       SampleBuffer* sample_buffer)
     : isolate_(isolate),
       sample_(head_sample),
       sample_buffer_(sample_buffer),
       frame_index_(0),
       total_frames_(0) {
     ASSERT(isolate_ != NULL);
-    ASSERT(sample_ != NULL);
-    ASSERT(sample_buffer_ != NULL);
-    ASSERT(sample_->head_sample());
+    if (sample_ == NULL) {
+      ASSERT(sample_buffer_ == NULL);
+    } else {
+      ASSERT(sample_buffer_ != NULL);
+      ASSERT(sample_->head_sample());
+    }
+  }
+
+  bool Append(uword pc, const Code& code) {
+    if (sample_ == NULL) {
+      DumpStackFrame(frame_index_, pc, code);
+      frame_index_++;
+      total_frames_++;
+      return true;
+    }
+    return Append(pc);
   }
 
   bool Append(uword pc) {
+    if (sample_ == NULL) {
+      DumpStackFrame(frame_index_, pc);
+      frame_index_++;
+      total_frames_++;
+      return true;
+    }
     if (total_frames_ >= FLAG_max_profile_depth) {
       sample_->set_truncated_trace(true);
       return false;
     }
     ASSERT(sample_ != NULL);
     if (frame_index_ == kSampleSize) {
       Sample* new_sample = sample_buffer_->ReserveSampleAndLink(sample_);
       if (new_sample == NULL) {
         // Could not reserve new sample- mark this as truncated.
         sample_->set_truncated_trace(true);
@@ skipping 27 matching lines @@
                               SampleBuffer* sample_buffer)
       : ProfilerStackWalker(isolate, sample, sample_buffer),
         frame_iterator_(thread) {
   }
 
   void walk() {
     // Mark that this sample was collected from an exit frame.
     sample_->set_exit_frame_sample(true);
 
     StackFrame* frame = frame_iterator_.NextFrame();
-    while (frame != NULL) {
-      if (!Append(frame->pc())) {
-        return;
+    if (sample_ == NULL) {
+      // Only when we are dumping the stack trace for debug purposes.
+      Code& code = Code::Handle();
+      while (frame != NULL) {
+        code ^= frame->LookupDartCode();
+        if (!Append(frame->pc(), code)) {
+          return;
+        }
+        frame = frame_iterator_.NextFrame();
       }
-      frame = frame_iterator_.NextFrame();
+    } else {
+      while (frame != NULL) {
+        if (!Append(frame->pc())) {
+          return;
+        }
+        frame = frame_iterator_.NextFrame();
+      }
     }
   }
 
  private:
   DartFrameIterator frame_iterator_;
 };
 
 
 // Executing Dart code, walk the stack.
 class ProfilerDartStackWalker : public ProfilerStackWalker {
@@ skipping 164 matching lines @@
       : ProfilerStackWalker(isolate, sample, sample_buffer),
         stack_upper_(stack_upper),
         original_pc_(pc),
         original_fp_(fp),
         original_sp_(sp),
         lower_bound_(stack_lower) {
   }
 
   void walk() {
     const uword kMaxStep = VirtualMemory::PageSize();
-
     Append(original_pc_);
 
     uword* pc = reinterpret_cast<uword*>(original_pc_);
     uword* fp = reinterpret_cast<uword*>(original_fp_);
     uword* previous_fp = fp;
 
     uword gap = original_fp_ - original_sp_;
     if (gap >= kMaxStep) {
       // Gap between frame pointer and stack pointer is
       // too large.
@@ skipping 279 matching lines @@
 static uintptr_t GetProgramCounter() {
   return reinterpret_cast<uintptr_t>(_ReturnAddress());
 }
 #else
 static uintptr_t __attribute__((noinline)) GetProgramCounter() {
   return reinterpret_cast<uintptr_t>(
       __builtin_extract_return_addr(__builtin_return_address(0)));
 }
 #endif
 
+
+void Profiler::DumpStackTrace(bool native_stack_trace) {
+  Thread* thread = Thread::Current();
+  ASSERT(thread != NULL);
+  OSThread* os_thread = thread->os_thread();
+  ASSERT(os_thread != NULL);
+  Isolate* isolate = thread->isolate();
+  if (!CheckIsolate(isolate)) {
+    return;
+  }
+
+  const bool exited_dart_code = thread->HasExitedDartCode();
+
+  OS::Print("Dumping %s stack trace for thread %" Px "\n",
+            native_stack_trace ? "native" : "dart-only",
+            static_cast<uintptr_t>(os_thread->trace_id()));
+
+  uintptr_t sp = Thread::GetCurrentStackPointer();
+  uintptr_t fp = 0;
+  uintptr_t pc = GetProgramCounter();
+
+  COPY_FP_REGISTER(fp);
+
+  uword stack_lower = 0;
+  uword stack_upper = 0;
+
+  if (!InitialRegisterCheck(pc, fp, sp)) {
+    OS::Print(
+        "Stack dump aborted because InitialRegisterCheck.\n");
+    return;
+  }
+
+  if (!GetAndValidateIsolateStackBounds(thread,
+                                        fp,
+                                        sp,
+                                        &stack_lower,
+                                        &stack_upper)) {
+    OS::Print(
+        "Stack dump aborted because GetAndValidateIsolateStackBounds.\n");
+    return;
+  }
+
+  if (native_stack_trace) {
+    ProfilerNativeStackWalker native_stack_walker(isolate,
+                                                  NULL,
+                                                  NULL,
+                                                  stack_lower,
+                                                  stack_upper,
+                                                  pc,
+                                                  fp,
+                                                  sp);
+    native_stack_walker.walk();
+  } else if (exited_dart_code) {
+    ProfilerDartExitStackWalker dart_exit_stack_walker(thread,
+                                                       isolate,
+                                                       NULL,
+                                                       NULL);
+    dart_exit_stack_walker.walk();
+  } else {
+    ProfilerDartStackWalker dart_stack_walker(isolate,
+                                              NULL,
+                                              NULL,
+                                              stack_lower,
+                                              stack_upper,
+                                              pc,
+                                              fp,
+                                              sp);
+  }
+}
+
+
 void Profiler::SampleAllocation(Thread* thread, intptr_t cid) {
   ASSERT(thread != NULL);
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   Isolate* isolate = thread->isolate();
   if (!CheckIsolate(isolate)) {
     return;
   }
 
   const bool exited_dart_code = thread->HasExitedDartCode();
@@ skipping 541 matching lines @@
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer()
     : code_lookup_table_(new CodeLookupTable(Thread::Current())) {
   ASSERT(code_lookup_table_ != NULL);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart