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

#include <execinfo.h>
#include <cxxabi.h>
#include <signal.h>

const std::map<int, std::string> Signals = {
    {SIGINT, "SIGINT"},    
    {SIGABRT, "SIGABRT"}, 
    {SIGFPE, "SIGFPE"},   
    {SIGILL, "SIGILL"},  
    {SIGSEGV, "SIGSEGV"}
    // 可以添加其他信号
};

struct sigaction action;
sigemptyset(&action.sa_mask);
action.sa_sigaction = &sigHandler;
action.sa_flags = SA_SIGINFO; 

 for (const auto &sigPair : Signals)
 {
    if (sigaction(sigPair.first, &action, NULL) < 0)
        fprintf(stderr, "Error: sigaction failed! \n");
 }

void sigHandler(int signum, siginfo_t *info, void *ctx)
{
    const size_t dump_size = 50;
    void *array[dump_size];
    int size = backtrace(array, dump_size);
    char **symbols = backtrace_symbols(array, size);
    std::ostringstream oss;

    for (int i = 0; i < size; ++i)
    {
        char *mangleName = 0;
        char *offsetBegin = 0;
        char *offsetEnd = 0;

        for (char *p = symbols[i]; *p; ++p)
        {
            if ('(' == *p)
            {   
                 mangleName = p;
            }   
            else if ('+' == *p)
            {
                offsetBegin = p;
            }
            else if (')' == *p)
            {
                offsetEnd = p;
                break;
            }
        }

        if (mangleName && offsetBegin && offsetEnd && mangleName < offsetBegin)
        {
            *mangleName++ = '\0';
            *offsetBegin++ = '\0';
            *offsetEnd++ = '\0';
            
            int status;
            char *realName = abi::__cxa_demangle(mangleName, 0, 0, &status);
            if (0 == status)
                oss << "\tstack dump [" << i << "]  " << symbols[i] << " : " << realName << "+";
            else
                oss << "\tstack dump [" << i << "]  " << symbols[i] << mangleName << "+";
            oss << offsetBegin << offsetEnd << std::endl;
            free(realName);
        }
        else
        {
            oss << "\tstack dump [" << i << "]  " << symbols[i] << std::endl;
        }
    }
    free(symbols);
    oss << std::endl;
    std::cout << oss.str(); // 打印函数调用栈信息
}

#include <windows.h>
#include <dbghelp.h>

SetUnhandledExceptionFilter(exceptionHandler);

void exceptionHandler(LPEXCEPTION_POINTERS info)
{
    CONTEXT *context = info->ContextRecord;
    std::shared_ptr<void> RaiiSysCleaner(nullptr, [&](void *) {
      SymCleanup(GetCurrentProcess());
    });

  const size_t dumpSize = 64;
  std::vector<uint64_t> frameVector(dumpSize);

  DWORD machine_type = 0;
  STACKFRAME64 frame = {};
  frame.AddrPC.Mode = AddrModeFlat;
  frame.AddrFrame.Mode = AddrModeFlat;
  frame.AddrStack.Mode = AddrModeFlat;

#ifdef _M_IX86
  frame.AddrPC.Offset = context->Eip;
  frame.AddrFrame.Offset = context->Ebp;
  frame.AddrStack.Offset = context->Esp;
  machine_type = IMAGE_FILE_MACHINE_I386;
#elif _M_X64
  frame.AddrPC.Offset = context->Rip;
  frame.AddrFrame.Offset = context->Rbp;
  frame.AddrStack.Offset = context->Rsp;
  machine_type = IMAGE_FILE_MACHINE_AMD64;
#elif _M_IA64
  frame.AddrPC.Offset = context->StIIP;
  frame.AddrFrame.Offset = context->IntSp;
  frame.AddrStack.Offset = context->IntSp;
  machine_type = IMAGE_FILE_MACHINE_IA64;
  frame.AddrBStore.Offset = context.RsBSP;
  frame.AddrBStore.Mode = AddrModeFlat;
#else
  frame.AddrPC.Offset = context->Eip;
  frame.AddrFrame.Offset = context->Ebp;
  frame.AddrStack.Offset = context->Esp;
  machine_type = IMAGE_FILE_MACHINE_I386;
#endif

  for (size_t index = 0; index < frameVector.size(); ++index)
  {
    if (StackWalk64(machine_type,
           GetCurrentProcess(),
           GetCurrentThread(),
           &frame,
           context,
           NULL,
           SymFunctionTableAccess64,
           SymGetModuleBase64,
           NULL)) {
      frameVector[index] = frame.AddrPC.Offset;
    } else {
      break;
    }
  }

  std::string dump;
  const size_t kSize = frameVector.size();
  for (size_t index = 0; index < kSize && frameVector[index]; ++index) {
    dump += getSymbolInfo(index, frameVector);
    dump += "\n";
  }

std::cout << dump; 
}