Dump stack trace on segfault in the VM.

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 926 matching lines @@
   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(void* context) {
+#if defined(TARGET_OS_LINUX) || defined(TARGET_OS_MACOS)
+  ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
+  mcontext_t mcontext = ucontext->uc_mcontext;
+  uword pc = SignalHandler::GetProgramCounter(mcontext);
+  uword fp = SignalHandler::GetFramePointer(mcontext);
+  uword sp = SignalHandler::GetCStackPointer(mcontext);
+  DumpStackTrace(true, sp, fp, pc);
+#else
+// TODO(fschneider): Add support for more platforms.
+// Do nothing on unsupported platforms.
+#endif
+}
+
+
 void Profiler::DumpStackTrace(bool native_stack_trace) {
+  uintptr_t sp = Thread::GetCurrentStackPointer();
+  uintptr_t fp = 0;
+  uintptr_t pc = GetProgramCounter();
+  COPY_FP_REGISTER(fp);
+  DumpStackTrace(native_stack_trace, sp, fp, pc);
+}
+
+
+void Profiler::DumpStackTrace(bool native_stack_trace,
+                              uword sp,
+                              uword fp,
+                              uword pc) {
   // Allow only one stack trace to prevent recursively printing stack traces if
   // we hit an assert while printing the stack.
   static uintptr_t started_dump = 0;
   if (AtomicOperations::FetchAndIncrement(&started_dump) != 0) {
     OS::PrintErr("Aborting re-entrant request for stack trace.\n");
     return;
   }
 
   Thread* thread = Thread::Current();
   if (thread == NULL) {
     return;
   }
   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::PrintErr("Dumping %s stack trace for thread %" Px "\n",
                native_stack_trace ? "native" : "dart-only",
                OSThread::ThreadIdToIntPtr(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::PrintErr("Stack dump aborted because InitialRegisterCheck.\n");
     return;
   }
 
   if (!GetAndValidateIsolateStackBounds(thread, fp, sp, &stack_lower,
                                         &stack_upper)) {
@@ skipping 540 matching lines @@
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer()
     : code_lookup_table_(new CodeLookupTable(Thread::Current())) {
   ASSERT(code_lookup_table_ != NULL);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart