使用MinGW在C++中生成异常时的Stacktrace

文章"如何在我的gcc C++应用程序崩溃时生成堆栈跟踪"解释了如何在应用程序崩溃后生成堆栈跟踪。但是gcc版本不适用于windows MinGW。事实上，由于缺少头execinfo.h，它甚至没有编译。

在windowsxp和更高版本上，有什么东西可以用于MinGW吗？

编辑

通过下面提到的步骤，堆叠行走是可能的。但是，当我尝试在发生异常后在catch块中遍历堆栈时，并没有得到所需的结果。我只能得到抛出异常的函数的名称，然后它会显示列表-->main-->等

步骤：

1. 为使用MinGW/MSYS的后Win32 API堆栈行走提供的第一个答案？通过JoséLuis Cebrián的链接，可以找到Edd的堆栈跟踪库http://www.mr-edd.co.uk/code/stack_trace

2. 上面链接中可用的stackwalker依赖于dbghelp.dll。由于MinGW没有为此提供导入库，因此它是使用MinGW的dlltool生成的。其命令为

   dlltool-k-d dbghelp.def-l dbghelp.a

   注1:.def文件在Wine项目中找到

   注2：库生成不适用于所有版本的MinGW。我在使用4.4.1版本生成它时遇到了问题，但它在4.6.1 中运行良好

3. 图书馆-lbfd、-lintl和-reliberty也与-ldbghelp 一起用于链接

4. 已从链接使用结构化异常处理http://www.programmingunlimited.net/siteexec/content.cgi?page=mingw-seh

代码视图

1. "Try"实现如下。此部分注册异常处理程序

   { 
   __SEH_EXCEPTION_REGISTRATION _lseh_er;
   __SEH_HANDLER _lseh_handler;
   _lseh_er.handler =
   reinterpret_cast<PEXCEPTION_HANDLER>(__SEH_HANDLER::ExceptionRouter);
   _lseh_er.exthandler = &_lseh_handler;
   asm volatile ("movl %%fs:0, %0" : "=r" (_lseh_er.prev));
   asm volatile ("movl %0, %%fs:0" : : "r" (&_lseh_er));
   int _lseh_setjmp_res = setjmp(_lseh_handler.context);
   while(true) {
    if(_lseh_setjmp_res != 0) {
      break;
    }
   

2. ExceptionRounter函数调用另一个复制上下文和记录的函数ExceptionHandler。具体实施情况如下。

   EXCEPTION_DISPOSITION __SEH_HANDLER::ExceptionHandler(PEXCEPTION_RECORD pRecord, 
   __SEH_EXCEPTION_REGISTRATION* pReg,
   PCONTEXT pContext,
   PEXCEPTION_RECORD pRecord2)
   {
   CopyMemory(&excContext, pContext, sizeof(_CONTEXT));
   CopyMemory(&excRecord, pRecord, sizeof(_EXCEPTION_RECORD));
   // Jump back to the function where the exception actually occurred.  The 1 is the
   // return code that will be returned by set_jmp.
   longjmp(context, 1);
   }
   

3. 之后是我抛出异常的代码

4. 然后实现"catch"或seh_excep。

   break;
   }
   PEXCEPTION_RECORD rec = &_lseh_handler.excRecord;
   PCONTEXT ctx = &_lseh_handler.excContext;
   asm volatile ("movl %0, %%fs:0" : : "r" (_lseh_er.prev));
   if(_lseh_setjmp_res != 0)
   

5. 然后是从Edd先生的堆栈生成器中遍历堆栈的代码。

   lock lk(g_fill_frames_mtx);
   symbol_context sc;
   bfd_context bfdc;
   
   STACKFRAME frame = empty_pod;
   CONTEXT context = empty_pod;
   context.ContextFlags = CONTEXT_FULL;
   /*Below part is commented as the context of the exception causing code has to be  used and not the current context*/
   /*
   windows_dll kernel32("kernel32.dll");
   void (WINAPI *RtlCaptureContext_)(CONTEXT*) =  kernel32.function("RtlCaptureContext");
   RtlCaptureContext_(&context);
   */
   context = _lseh_handler.excContex;
   frame.AddrPC.Offset = context.Eip;
   frame.AddrPC.Mode = AddrModeFlat;
   frame.AddrStack.Offset = context.Esp;
   frame.AddrStack.Mode = AddrModeFlat;
   frame.AddrFrame.Offset = context.Ebp;
   frame.AddrFrame.Mode = AddrModeFlat;
   
   HANDLE process = GetCurrentProcess();
   HANDLE thread = GetCurrentThread();
   bool skip = true;
   bool has_limit = limit != 0;
   char symbol_buffer[sizeof(IMAGEHLP_SYMBOL) + 255];
   char module_name_raw[MAX_PATH];
   const DWORD machine = IMAGE_FILE_MACHINE_I386;
   while(StackWalk(machine, process, thread, &frame, &context, 0, SymFunctionTableAccess, SymGetModuleBase, 0))
   {
       if (skip)
       {
           skip = false;
           continue;
       }
       if (has_limit && limit-- == 0) break;
       IMAGEHLP_SYMBOL *symbol = reinterpret_cast<IMAGEHLP_SYMBOL *>(symbol_buffer);
       symbol->SizeOfStruct = (sizeof *symbol) + 255;
       symbol->MaxNameLength = 254;
       DWORD module_base = SymGetModuleBase(process, frame.AddrPC.Offset);
       std::string module_name = unknown_module;
       if (module_base && GetModuleFileNameA(reinterpret_cast<HINSTANCE>(module_base), module_name_raw, MAX_PATH))
           module_name = module_name_raw;
           std::string func = bfdc.get_function_name(frame.AddrPC.Offset);
           if (func.empty())
           {
               DWORD dummy = 0;
               BOOL got_symbol = SymGetSymFromAddr(process, frame.AddrPC.Offset, &dummy, symbol);
               func = got_symbol ? symbol->Name : unknown_function;
           }
       dbg::stack_frame f(reinterpret_cast<const void *>(frame.AddrPC.Offset), func, module_name);
       frames.push_back(f);
       }
     }
   }
   std::copy(frames.begin(), frames.end(), std::ostream_iterator<dbg::stack_frame>(std::cout, "n"));
   

此致，Shryas