Print stack trace on exception in unit tests on Windows....

base/debug_util_win.cc

 // Copyright (c) 2006-2009 The Chromium 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 "base/debug_util.h"
 
 #include <windows.h>
 #include <dbghelp.h>
 
 #include <iostream>
@@ skipping 87 matching lines @@
   }
 
   // For the given trace, attempts to resolve the symbols, and output a trace
   // to the ostream os.  The format for each line of the backtrace is:
   //
   //    <tab>SymbolName[0xAddress+Offset] (FileName:LineNo)
   //
   // This function should only be called if Init() has been called.  We do not
   // LOG(FATAL) here because this code is called might be triggered by a
   // LOG(FATAL) itself.
-  void OutputTraceToStream(const std::vector<void*>& trace, std::ostream* os) {
+  void OutputTraceToStream(const void* const* trace,
+                           int count,
+                           std::ostream* os) {
     AutoLock lock(lock_);
 
-    for (size_t i = 0; (i < trace.size()) && os->good(); ++i) {
+    for (size_t i = 0; (i < count) && os->good(); ++i) {

[awong, 2009/09/08 20:44:03]

size_t -> int

       const int kMaxNameLength = 256;
       DWORD_PTR frame = reinterpret_cast<DWORD_PTR>(trace[i]);
 
       // Code adapted from MSDN example:
       // http://msdn.microsoft.com/en-us/library/ms680578(VS.85).aspx
       ULONG64 buffer[
         (sizeof(SYMBOL_INFO) +
           kMaxNameLength * sizeof(wchar_t) +
           sizeof(ULONG64) - 1) /
         sizeof(ULONG64)];
@@ skipping 91 matching lines @@
 bool DebugUtil::BeingDebugged() {
   return ::IsDebuggerPresent() != 0;
 }
 
 // static
 void DebugUtil::BreakDebugger() {
   __debugbreak();
 }
 
 StackTrace::StackTrace() {
-  // From http://msdn.microsoft.com/en-us/library/bb204633(VS.85).aspx,
-  // the sum of FramesToSkip and FramesToCapture must be less than 63,
-  // so set it to 62.
-  const int kMaxCallers = 62;
+  // When walking our own stack, use CaptureStackBackTrace().
+  count_ = CaptureStackBackTrace(0, arraysize(trace_), trace_, NULL);
+}
 
-  void* callers[kMaxCallers];
-  // TODO(ajwong): Migrate this to StackWalk64.
-  int count = CaptureStackBackTrace(0, kMaxCallers, callers, NULL);
-  if (count > 0) {
-    trace_.resize(count);
-    memcpy(&trace_[0], callers, sizeof(callers[0]) * count);
-  } else {
-    trace_.resize(0);
+StackTrace::StackTrace(EXCEPTION_POINTERS* exception_pointers) {
+  // When walking an exception stack, we need to use StackWalk64().
+  count_ = 0;
+  // Initialize stack walking.
+  STACKFRAME64 stack_frame;
+  memset(&stack_frame, 0, sizeof(stack_frame));
+#if defined(_WIN64)
+  int machine_type = IMAGE_FILE_MACHINE_AMD64;
+  stack_frame.AddrPC.Offset = exception_pointers->ContextRecord->Rip;
+  stack_frame.AddrFrame.Offset = exception_pointers->ContextRecord->Rbp;
+  stack_frame.AddrStack.Offset = exception_pointers->ContextRecord->Rsp;
+#else
+  int machine_type = IMAGE_FILE_MACHINE_I386;
+  stack_frame.AddrPC.Offset = exception_pointers->ContextRecord->Eip;
+  stack_frame.AddrFrame.Offset = exception_pointers->ContextRecord->Ebp;
+  stack_frame.AddrStack.Offset = exception_pointers->ContextRecord->Esp;
+#endif
+  stack_frame.AddrPC.Mode = AddrModeFlat;
+  stack_frame.AddrFrame.Mode = AddrModeFlat;
+  stack_frame.AddrStack.Mode = AddrModeFlat;
+  while (StackWalk64(machine_type,
+                     GetCurrentProcess(),
+                     GetCurrentThread(),
+                     &stack_frame,
+                     exception_pointers->ContextRecord,
+                     NULL,
+                     &SymFunctionTableAccess64,
+                     &SymGetModuleBase64,
+                     NULL) &&
+         count_ < arraysize(trace_)) {
+    trace_[count_++] = reinterpret_cast<void*>(stack_frame.AddrPC.Offset);
   }
 }
 
 void StackTrace::PrintBacktrace() {
   OutputToStream(&std::cerr);
 }
 
 void StackTrace::OutputToStream(std::ostream* os) {
   SymbolContext* context = SymbolContext::Get();
   DWORD error = context->init_error();
   if (error != ERROR_SUCCESS) {
     (*os) << "Error initializing symbols (" << error
           << ").  Dumping unresolved backtrace:\n";
-    for (size_t i = 0; (i < trace_.size()) && os->good(); ++i) {
+    for (size_t i = 0; (i < count_) && os->good(); ++i) {
       (*os) << "\t" << trace_[i] << "\n";
     }
   } else {
     (*os) << "Backtrace:\n";
-    context->OutputTraceToStream(trace_, os);
+    context->OutputTraceToStream(trace_, count_, os);
   }
 }