如何结合异常处理与终止处理程序实现非终止式栈轨迹记录？

问题背景 #

需要为遗留代码抛出的所有异常（包括标准原生异常）记录栈轨迹，核心要求：

• 无需修改遗留代码
• 记录栈轨迹后不终止GUI程序，允许用户继续操作
• 尽可能在栈展开前捕获完整栈信息（避免栈展开导致的帧丢失）

当前仅能通过自定义异常构造函数记录栈轨迹，无法覆盖原生异常；尝试利用终止处理程序但会导致程序终止，不符合GUI场景需求。

可行替代方案 #

方案1：拦截底层异常抛出函数（GCC/Clang） #

通过替换编译器底层的__cxa_throw函数，在异常抛出的第一时间捕获栈轨迹，再将原异常包装成带栈信息的自定义异常重新抛出。此方法无需修改遗留代码，且能在栈展开前获取完整栈帧。

示例代码：

#include <cstdlib>
#include <exception>
#include <string>
#include <execinfo.h>
#include <dlfcn.h>

// 保存原始__cxa_throw函数指针
extern "C" void (*original_cxa_throw)(void*, std::type_info*, void(*)(void*)) = nullptr;

extern "C" void __cxa_throw(void* thrown_exception, std::type_info* tinfo, void(*dest)(void*)) {
    // 捕获当前栈轨迹
    void* stack_frames[64];
    int frame_count = backtrace(stack_frames, 64);
    char** frame_strings = backtrace_symbols(stack_frames, frame_count);
    
    std::string stack_desc;
    for (int i = 0; i < frame_count; ++i) {
        stack_desc += frame_strings[i];
        stack_desc += "\n";
    }
    free(frame_strings);

    // 定义带栈轨迹的包装异常
    class TracedException : public std::exception {
    public:
        std::string stack_trace;
        std::exception_ptr original_exception;

        TracedException(std::string stack, std::exception_ptr orig_ex)
            : stack_trace(std::move(stack)), original_exception(std::move(orig_ex)) {}

        const char* what() const noexcept override {
            return "Exception with captured stack trace";
        }
    };

    // 创建包装异常实例，替换原异常抛出
    auto wrapped_ex = new TracedException(std::move(stack_desc), std::current_exception());
    original_cxa_throw(wrapped_ex, typeid(TracedException), 
        [](void* p) { delete static_cast<TracedException*>(p); });
}

// 程序启动时初始化原始函数指针
__attribute__((constructor)) void init_cxa_hook() {
    original_cxa_throw = reinterpret_cast<decltype(original_cxa_throw)>(
        dlsym(RTLD_NEXT, "__cxa_throw")
    );
}

在GUI主程序的catch块中捕获TracedException即可获取栈轨迹：

int main() {
    try {
        // 运行遗留代码/GUI主循环
    } catch (const TracedException& e) {
        display_stack_trace(e.stack_trace);
        // 可选：处理原始异常
        try {
            std::rethrow_exception(e.original_exception);
        } catch (const std::exception& orig_e) {
            // 处理原异常逻辑
        }
    } catch (...) {
        // 兜底处理未被包装的异常
    }
}

优缺点：

• ✅ 无需修改遗留代码，栈展开前捕获完整栈帧
• ❌ 依赖GCC/Clang编译器，跨平台需适配MSVC的RaiseException钩子
• ❌ Linux下需链接-ldl库

方案2：MSVC平台结构化异常转换 #

在MSVC环境下，使用_set_se_translator将Windows结构化异常（SEH）转换为C异常，同时在转换过程中捕获栈轨迹。此方法可覆盖原生C异常和系统级异常。

示例代码：

#include <windows.h>
#include <exception>
#include <string>

// 自定义带栈轨迹的异常
class TracedException : public std::exception {
public:
    std::string stack_trace;
    unsigned int se_code;

    TracedException(std::string stack, unsigned int code)
        : stack_trace(std::move(stack)), se_code(code) {}

    const char* what() const noexcept override {
        return "SEH Exception with stack trace";
    }
};

// SEH转C++异常的转换函数
void se_translator(unsigned int code, EXCEPTION_POINTERS* ex_info) {
    // 捕获栈轨迹
    void* stack_frames[64];
    WORD frame_count = CaptureStackBackTrace(0, 64, stack_frames, nullptr);
    
    std::string stack_desc;
    char buffer[sizeof(SYMBOL_INFO) + 256];
    SYMBOL_INFO* symbol = reinterpret_cast<SYMBOL_INFO*>(buffer);
    symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
    symbol->MaxNameLen = 256;

    for (WORD i = 0; i < frame_count; ++i) {
        DWORD_PTR frame = reinterpret_cast<DWORD_PTR>(stack_frames[i]);
        if (SymFromAddr(GetCurrentProcess(), frame, nullptr, symbol)) {
            stack_desc += symbol->Name;
            stack_desc += "\n";
        }
    }

    throw TracedException(std::move(stack_desc), code);
}

int main() {
    // 设置SEH转换器
    _set_se_translator(se_translator);
    // 初始化符号表（用于解析栈帧）
    SymInitialize(GetCurrentProcess(), nullptr, TRUE);

    try {
        // 运行遗留代码/GUI主循环
    } catch (const TracedException& e) {
        display_stack_trace(e.stack_trace);
    }

    SymCleanup(GetCurrentProcess());
    return 0;
}

优缺点：

• ✅ 适配MSVC平台，覆盖SEH和C++异常
• ❌ 仅支持Windows平台，无法跨平台
• ❌ 发布版本需携带符号文件以解析栈帧

方案3：全局try-catch配合栈轨迹捕获（跨平台） #

用try块包裹整个GUI主循环，在catch块中使用跨平台栈轨迹库（如Boost.Stacktrace）捕获栈信息。此方法实现简单，但栈是展开后的，会丢失部分栈帧信息。

示例代码：

#include <exception>
#include <boost/stacktrace.hpp>

int main() {
    try {
        // 运行遗留代码/GUI主循环
    } catch (...) {
        // 捕获当前栈轨迹（已展开）
        boost::stacktrace::stacktrace st = boost::stacktrace::stacktrace();
        std::string stack_desc = to_string(st);
        display_stack_trace(stack_desc);
    }
    return 0;
}

优缺点：

• ✅ 跨平台，实现简单，无编译器依赖
• ❌ 栈已展开，丢失异常抛出点到catch块之间的栈帧
• ❌ 需要引入Boost.Stacktrace库

内容的提问来源于stack exchange，提问作者Dmitry Kuzminov