135-1821-9792

Linux+Windows:程序崩溃时，在C++代码中，如何获取函数调用栈信息

一、前言

程序在执行过程中 crash 是非常严重的问题，一般都应该在测试阶段排除掉这些问题，但是总会有漏网之鱼被带到 release 阶段。

为南谯等地区用户提供了全套网页设计制作服务，及南谯网站建设行业解决方案。主营业务为网站设计制作、做网站、南谯网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

因此，程序的日志系统需要侦测这种情况，在代码崩溃的时候获取函数调用栈信息，为 debug 提供有效的信息。

这篇文章的理论知识很少，直接分享 2 段代码：在 Linux 和 Windows 这 2 个平台上，如何用C++ 来捕获函数调用栈里的信息。

二、Linux 平台

1. 注册异常信号的处理函数

需要处理哪些异常信号

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. #include 
    3. 
  
  
  
  
  3. #include 
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. const std::map Signals = {
    6. 
  
  
  
  
  6.     {SIGINT, "SIGINT"},    
    7. 
  
  
  
  
  7.     {SIGABRT, "SIGABRT"}, 
    8. 
  
  
  
  
  8.     {SIGFPE, "SIGFPE"},   
    9. 
  
  
  
  
  9.     {SIGILL, "SIGILL"},  
    10. 
  
  
  
  
  10.     {SIGSEGV, "SIGSEGV"}
    11. 
  
  
  
  
  11.     // 可以添加其他信号
    12. 
  
  
  
  
  12. };
    13.

注册信号处理函数

 
 
 
 
    
  
  
  
  
  1. struct sigaction action;
    2. 
  
  
  
  
  2. sigemptyset(&action.sa_mask);
    3. 
  
  
  
  
  3. action.sa_sigaction = &sigHandler;
    4. 
  
  
  
  
  4. action.sa_flags = SA_SIGINFO; 
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.  for (const auto &sigPair : Signals)
    7. 
  
  
  
  
  7.  {
    8. 
  
  
  
  
  8.     if (sigaction(sigPair.first, &action, NULL) < 0)
    9. 
  
  
  
  
  9.         fprintf(stderr, "Error: sigaction failed! \n");
    10. 
  
  
  
  
  10.  }
    11.

2. 捕获异常，获取函数调用栈信息

 
 
 
 
    
  
  
  
  
  1. void sigHandler(int signum, siginfo_t *info, void *ctx)
    2. 
  
  
  
  
  2. {
    3. 
  
  
  
  
  3.     const size_t dump_size = 50;
    4. 
  
  
  
  
  4.     void *array[dump_size];
    5. 
  
  
  
  
  5.     int size = backtrace(array, dump_size);
    6. 
  
  
  
  
  6.     char **symbols = backtrace_symbols(array, size);
    7. 
  
  
  
  
  7.     std::ostringstream oss;
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.     for (int i = 0; i < size; ++i)
    10. 
  
  
  
  
  10.     {
    11. 
  
  
  
  
  11.         char *mangleName = 0;
    12. 
  
  
  
  
  12.         char *offsetBegin = 0;
    13. 
  
  
  
  
  13.         char *offsetEnd = 0;
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.         for (char *p = symbols[i]; *p; ++p)
    16. 
  
  
  
  
  16.         {
    17. 
  
  
  
  
  17.             if ('(' == *p)
    18. 
  
  
  
  
  18.             {   
    19. 
  
  
  
  
  19.                  mangleName = p;
    20. 
  
  
  
  
  20.             }   
    21. 
  
  
  
  
  21.             else if ('+' == *p)
    22. 
  
  
  
  
  22.             {
    23. 
  
  
  
  
  23.                 offsetBegin = p;
    24. 
  
  
  
  
  24.             }
    25. 
  
  
  
  
  25.             else if (')' == *p)
    26. 
  
  
  
  
  26.             {
    27. 
  
  
  
  
  27.                 offsetEnd = p;
    28. 
  
  
  
  
  28.                 break;
    29. 
  
  
  
  
  29.             }
    30. 
  
  
  
  
  30.         }
    31. 
  
  
  
  
  31. 
  
  
  
  
  32.         if (mangleName && offsetBegin && offsetEnd && mangleName < offsetBegin)
    33. 
  
  
  
  
  33.         {
    34. 
  
  
  
  
  34.             *mangleName++ = '\0';
    35. 
  
  
  
  
  35.             *offsetBegin++ = '\0';
    36. 
  
  
  
  
  36.             *offsetEnd++ = '\0';
    37. 
  
  
  
  
  37.             
    38. 
  
  
  
  
  38.             int status;
    39. 
  
  
  
  
  39.             char *realName = abi::__cxa_demangle(mangleName, 0, 0, &status);
    40. 
  
  
  
  
  40.             if (0 == status)
    41. 
  
  
  
  
  41.                 oss << "\tstack dump [" << i << "]  " << symbols[i] << " : " << realName << "+";
    42. 
  
  
  
  
  42.             else
    43. 
  
  
  
  
  43.                 oss << "\tstack dump [" << i << "]  " << symbols[i] << mangleName << "+";
    44. 
  
  
  
  
  44.             oss << offsetBegin << offsetEnd << std::endl;
    45. 
  
  
  
  
  45.             free(realName);
    46. 
  
  
  
  
  46.         }
    47. 
  
  
  
  
  47.         else
    48. 
  
  
  
  
  48.         {
    49. 
  
  
  
  
  49.             oss << "\tstack dump [" << i << "]  " << symbols[i] << std::endl;
    50. 
  
  
  
  
  50.         }
    51. 
  
  
  
  
  51.     }
    52. 
  
  
  
  
  52.     free(symbols);
    53. 
  
  
  
  
  53.     oss << std::endl;
    54. 
  
  
  
  
  54.     std::cout << oss.str(); // 打印函数调用栈信息
    55. 
  
  
  
  
  55. }
    56.

三、Windwos 平台

在 Windows 平台下的代码实现，参考了国外某个老兄的代码，如下：

1. 设置异常处理函数

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. #include 
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. SetUnhandledExceptionFilter(exceptionHandler);
    5.

2. 捕获异常，获取函数调用栈信息

 
 
 
 
    
  
  
  
  
  1. void exceptionHandler(LPEXCEPTION_POINTERS info)
    2. 
  
  
  
  
  2. {
    3. 
  
  
  
  
  3.     CONTEXT *context = info->ContextRecord;
    4. 
  
  
  
  
  4.     std::shared_ptr RaiiSysCleaner(nullptr, [&](void *) {
    5. 
  
  
  
  
  5.       SymCleanup(GetCurrentProcess());
    6. 
  
  
  
  
  6.     });
    7. 
  
  
  
  
  7. 
  
  
  
  
  8.   const size_t dumpSize = 64;
    9. 
  
  
  
  
  9.   std::vector frameVector(dumpSize);
    10. 
  
  
  
  
  10. 
  
  
  
  
  11.   DWORD machine_type = 0;
    12. 
  
  
  
  
  12.   STACKFRAME64 frame = {};
    13. 
  
  
  
  
  13.   frame.AddrPC.Mode = AddrModeFlat;
    14. 
  
  
  
  
  14.   frame.AddrFrame.Mode = AddrModeFlat;
    15. 
  
  
  
  
  15.   frame.AddrStack.Mode = AddrModeFlat;
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. #ifdef _M_IX86
    18. 
  
  
  
  
  18.   frame.AddrPC.Offset = context->Eip;
    19. 
  
  
  
  
  19.   frame.AddrFrame.Offset = context->Ebp;
    20. 
  
  
  
  
  20.   frame.AddrStack.Offset = context->Esp;
    21. 
  
  
  
  
  21.   machine_type = IMAGE_FILE_MACHINE_I386;
    22. 
  
  
  
  
  22. #elif _M_X64
    23. 
  
  
  
  
  23.   frame.AddrPC.Offset = context->Rip;
    24. 
  
  
  
  
  24.   frame.AddrFrame.Offset = context->Rbp;
    25. 
  
  
  
  
  25.   frame.AddrStack.Offset = context->Rsp;
    26. 
  
  
  
  
  26.   machine_type = IMAGE_FILE_MACHINE_AMD64;
    27. 
  
  
  
  
  27. #elif _M_IA64
    28. 
  
  
  
  
  28.   frame.AddrPC.Offset = context->StIIP;
    29. 
  
  
  
  
  29.   frame.AddrFrame.Offset = context->IntSp;
    30. 
  
  
  
  
  30.   frame.AddrStack.Offset = context->IntSp;
    31. 
  
  
  
  
  31.   machine_type = IMAGE_FILE_MACHINE_IA64;
    32. 
  
  
  
  
  32.   frame.AddrBStore.Offset = context.RsBSP;
    33. 
  
  
  
  
  33.   frame.AddrBStore.Mode = AddrModeFlat;
    34. 
  
  
  
  
  34. #else
    35. 
  
  
  
  
  35.   frame.AddrPC.Offset = context->Eip;
    36. 
  
  
  
  
  36.   frame.AddrFrame.Offset = context->Ebp;
    37. 
  
  
  
  
  37.   frame.AddrStack.Offset = context->Esp;
    38. 
  
  
  
  
  38.   machine_type = IMAGE_FILE_MACHINE_I386;
    39. 
  
  
  
  
  39. #endif
    40. 
  
  
  
  
  40. 
  
  
  
  
  41.   for (size_t index = 0; index < frameVector.size(); ++index)
    42. 
  
  
  
  
  42.   {
    43. 
  
  
  
  
  43.     if (StackWalk64(machine_type,
    44. 
  
  
  
  
  44.            GetCurrentProcess(),
    45. 
  
  
  
  
  45.            GetCurrentThread(),
    46. 
  
  
  
  
  46.            &frame,
    47. 
  
  
  
  
  47.            context,
    48. 
  
  
  
  
  48.            NULL,
    49. 
  
  
  
  
  49.            SymFunctionTableAccess64,
    50. 
  
  
  
  
  50.            SymGetModuleBase64,
    51. 
  
  
  
  
  51.            NULL)) {
    52. 
  
  
  
  
  52.       frameVector[index] = frame.AddrPC.Offset;
    53. 
  
  
  
  
  53.     } else {
    54. 
  
  
  
  
  54.       break;
    55. 
  
  
  
  
  55.     }
    56. 
  
  
  
  
  56.   }
    57. 
  
  
  
  
  57. 
  
  
  
  
  58.   std::string dump;
    59. 
  
  
  
  
  59.   const size_t kSize = frameVector.size();
    60. 
  
  
  
  
  60.   for (size_t index = 0; index < kSize && frameVector[index]; ++index) {
    61. 
  
  
  
  
  61.     dump += getSymbolInfo(index, frameVector);
    62. 
  
  
  
  
  62.     dump += "\n";
    63. 
  
  
  
  
  63.   }
    64. 
  
  
  
  
  64. 
  
  
  
  
  65. std::cout << dump; 
    66. 
  
  
  
  
  66. }
    67.

主要是利用了 StackWalk64 这个函数，从地址转换为函数名称。

利用以上几个神器，基本上可以获取到程序崩溃时的函数调用栈信息，定位问题，有如神助!


当前题目：Linux+Windows:程序崩溃时，在C++代码中，如何获取函数调用栈信息
转载注明：http://www.wtcwzsj.com/article/ccddigc.html

其他资讯


关于我们
我们的服务
网站建设案例
新闻动态
联系我们

135-1821-9792

公司服务热线
友情链接： 汶川发电机维修   网站优化排名推广   眉山网站建设   网站改版设计   四川康明斯发电机   香港云虚拟主机   泸州网站建设   网络推广外包   新型地坪材料   营销型网站建设   

Copyright © 2009-2022 www.wtcwzsj.com 青羊区广皓图文设计工作室（个体工商户） 版权所有　蜀ICP备19037934号