c++ - 使用 MinGW 在 C++ 中生成异常堆栈跟踪

Question

帖子“How to generate a stacktrace when my gcc C++ app crashes”解释了应用程序崩溃时如何生成堆栈跟踪。但 gcc 版本不适用于 windows MinGW。事实上，由于缺少 header execinfo.h，它甚至无法编译。

在 windows xp 及更高版本上是否已经有适用于 MinGW 的东西？

编辑

Stackwalking 可以通过下面提到的步骤实现。但是当我在异常发生后尝试遍历 catch block 中的堆栈时，我没有得到想要的结果。我只能得到抛出异常的函数的名称，然后它显示列表-->main-->等等

步骤:

1. 为帖子提供的第一个答案Win32 API stack walk with MinGW/MSYS?作者:José Luis Cebrián 导致了一个可以找到 Mr.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 和 -liberty 也与 -ldbghelp 一起用于链接

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

代码 View

1. “尝试”实现如下。这部分注册异常处理器

   { 
   __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. 然后是从 Mr.Edd 的 stackwalker 中遍历堆栈的代码。

   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"));
   

问候，Shreyas

Answer 1

LibSEH 在链接 http://www.programmingunlimited.net/siteexec/content.cgi?page=libseh 中可用解决了这个问题。

根据我得到的响应，我可以得出结论，在我的实现中，异常处理代码是在与引发异常的代码相同的上下文中调用的。这导致覆盖堆栈中现在不相关的部分。

然而，异常处理过滤器函数是在不同的上下文中执行的，通过将堆栈跟踪器放入过滤器函数中，可以实现预期的结果。

因此我使用了 libseh，它提供了类似于 MSVC 中的异常处理功能，并在过滤器函数中编写了堆栈跟踪器。