Add --print_stacktrace_at_api_error.

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 857 matching lines @@
     ASSERT(isolate != NULL);
     Simulator* simulator = isolate->simulator();
     *stack_lower = simulator->StackBase();
     *stack_upper = simulator->StackTop();
   }
 #else
   const bool use_simulator_stack_bounds = false;
 #endif
 
   if (!use_simulator_stack_bounds &&
-      !os_thread->GetProfilerStackBounds(stack_lower, stack_upper) &&
       !(get_os_thread_bounds &&
-        OSThread::GetCurrentStackBounds(stack_lower, stack_upper))) {
+        OSThread::GetCurrentStackBounds(stack_lower, stack_upper)) &&
+      !os_thread->GetProfilerStackBounds(stack_lower, stack_upper)) {
     // Could not get stack boundary.
     return false;
   }
 
   if ((*stack_lower == 0) || (*stack_upper == 0)) {
     return false;
   }
 
   if (!use_simulator_stack_bounds && (sp > *stack_lower)) {
     // The stack pointer gives us a tighter lower bound.
@@ skipping 71 matching lines @@
 }
 
 
 void Profiler::DumpStackTrace(void* context) {
 #if defined(HOST_OS_LINUX) || defined(HOST_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(sp, fp, pc);
+  DumpStackTrace(sp, fp, pc, true /* for_crash */);
 #else
 // TODO(fschneider): Add support for more platforms.
 // Do nothing on unsupported platforms.
 #endif
 }
 
 
-void Profiler::DumpStackTrace() {
+void Profiler::DumpStackTrace(bool for_crash) {
   uintptr_t sp = Thread::GetCurrentStackPointer();
   uintptr_t fp = 0;
   uintptr_t pc = OS::GetProgramCounter();
 
   COPY_FP_REGISTER(fp);
 
-  DumpStackTrace(sp, fp, pc);
+  DumpStackTrace(sp, fp, pc, for_crash);
 }
 
 
-void Profiler::DumpStackTrace(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;
+void Profiler::DumpStackTrace(uword sp, uword fp, uword pc, bool for_crash) {
+  if (for_crash) {
+    // 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;
+    }
   }

[siva, 2017/04/13 01:50:18]

Why is this logic relevant only when for_crash is true. Shouldn't we be avoiding
recursion always.

 
   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;
@@ skipping 593 matching lines @@
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer()
     : code_lookup_table_(new CodeLookupTable(Thread::Current())) {
   ASSERT(code_lookup_table_ != NULL);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart