backtrace函数与assert断言宏封装

这篇文章是在阅读 sylar 框架时，对断言宏的封装所做的总结。

在实际开发中，我们经常会遇到一种境况：如果程序执行的不是我们想要的正确结果，需要程序立即中断执行，我们希望得到其有效的错误信息，比如其出现错误的函数、文件、代码行号、和参数文本、调用堆栈信息等。通常我们会在程序中使用断言 assert，因为如果出现了不符合条件的情况，程序将终止执行，而且会打印出一些有限的信息。

assert 函数

断言就说明是绝对不可能出现的错误，一旦出现就不能让程序继续执行下去，而且需要在 debug 阶段将 assert 检查出来的问题全部修复掉。受到以前硬件资源限制，断言太多非常影响效率，在 release 版本中断言都会去掉。断言一般出现在核心模块内部，主要作用就是在 debug 阶段清除所有bug，而这些 bug 也绝不能留到 release 阶段。

assert 如果断言其表达式为假，则终止程序，并输出有限的调试信息，这个宏定义可以帮助我们在程序中发现错误，或者通过崩溃处理异常情况。

比如我们有以下程序：

void my_assert()
{
    int a = 10;
    assert(a == 100);
}

void Func2()
{
    my_assert();
}

void Func1()
{
    Func2();
}

int main(int argc, char *argv[])
{
    Func1();
    return 0;
}

程序执行到 assert 表达式时，判断 a == 100 是否成立，因为不成立，将终止程序，程序的运行结果如下：

$ ./bin/test_util 
test_util:tests/test_util.cpp:71: void my_assert(): Assertion `a == 100' failed.
Aborted (core dumped)

可以看到输出的信息中包含了调用的文件、函数、代码行号和参数文本信息。

虽然可以得到基本的信息，但是得到的信息还是不够充分，比如我们想知道该函数的调用堆栈信息，这时候就需要另一个强大的函数 backtrack了。

backtrace 系列函数

Linux 下提供了 backtrace，backtrace_symbols，backtrace_symbols_fd 函数来支持对应用程序的调试。

其函数签名如下：

#include <execinfo.h>
int backtrace(void **buffer, int size);
char **backtrace_symbols(void *const *buffer, int size);
void backtrace_symbols_fd(void *const *buffer, int size, int fd);

backtrace 函数

该函数获取当前线程的调用堆栈，获取的信息将会被存放在 buffer 中，它是一个指针数组，参数 size 用来指定buffer 中可以保存多少个 void* 元素。函数的返回值是实际返回的 void* 元素个数。buffer 中的 void* 元素实际是从堆栈中获取的返回地址。

backtrace_symbols 函数

该函数将 backtrace 函数获取的信息转化为一个字符串数组，参数 buffer 是 backtrace 获取的堆栈指针，size 是backtrace 返回值。函数返回值是一个指向字符串数组的指针，它包含 char* 元素个数为 size 。每个字符串包含了一个相对于 buffer 中对应元素的可打印信息，包括函数名、函数偏移地址和实际返回地址。

backtrace_symbols 生成的字符串占用的内存是 malloc 出来的，但是是该一次性 malloc 出来的，释放是只需要一次性释放返回的二级指针即可。

backtrace_symbols_fd 函数

该函数与 backtrace_symbols 函数功能相同，只是它不会 malloc 内存，而是将结果写入文件描述符为 fd 的文件中，每个函数对应一行。该函数可重入。

backtrace函数注意事项

• backtrace 的实现依赖于栈指针（fp 寄存器），在 gcc 编译过程中任何非零的优化等级（-On参数）或加入了栈指针优化参数 -fomit-frame-pointer 后多将不能正确得到程序栈信息，在 debug 模式中，我们只需要指定 -O0 即可。
• backtrace_symbols 的实现需要符号名称的支持，在 gcc 编译过程中需要加入 -rdynamic 参数；
• 内联函数没有栈帧，它在编译过程中被展开在调用的位置；
• 尾调用优化（Tail-call Optimization）将复用当前函数栈，而不再生成新的函数栈，这将导致栈信息不能正确被获取。

捕获异常信号并打印堆栈

当程序出现崩溃等异常时，会接收到内核发送给进程的异常信号，进程接收到异常信号后，可以在处理信号的时候将程序的堆栈信息打印出来，以便于程序调试。

backtrace函数实例

这是 backtrack 函数的示例程序，可以先参考一下：

#include <stdio.h>
#include <execinfo.h>
#include <unistd.h>
#include <stdlib.h>
#define BACKTRACE_SIZE 100

void print_backtrace()
{
    void *buffer[BACKTRACE_SIZE] = {0};
    int pointer_num = backtrace(buffer, BACKTRACE_SIZE);
    char **string_buffer = backtrace_symbols(buffer, pointer_num);
    if (string_buffer == NULL)
    {
        printf("backtrace_symbols error");
        exit(-1);
    }

    printf("print backtrace begin\n");
    for (int i = 0; i < pointer_num; i++)
    {
        printf("%s\n", string_buffer[i]);
    }
    printf("print backtrace end\n");

    free(string_buffer); //需要手动释放空间

    return;
}

void my_assert()
{
    print_backtrace();
}

void Func2()
{
    my_assert();
}

void Func1()
{
    Func2();
}

int main(int argc, char *argv[])
{
    Func1();
    return 0;
}

执行结果如下，注意在编译时带 -rdynamic 参数：

$ ./bin/test_util 
print backtrace begin
./bin/test_util(_Z15print_backtracev+0x45) [0x7f7af6000b0f]
./bin/test_util(_Z9my_assertv+0x9) [0x7f7af6000be5]
./bin/test_util(_Z5Func2v+0x9) [0x7f7af6000bf1]
./bin/test_util(_Z5Func1v+0x9) [0x7f7af6000bfd]
./bin/test_util(main+0x14) [0x7f7af6000c14]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xe7) [0x7f7af5821b97]
./bin/test_util(_start+0x2a) [0x7f7af60009ea]
print backtrace end

在上面说过，我们不能对其使用 -On优化，否则打印出的结果是不确定的。

从结果中可以看出函数的调用堆栈信息，但是不够直观，因为其中还有一些地址信息相关的，我们需要对其结果进行过滤得到一个格式良好的堆栈信息。

封装backtrace系列函数

通过上面的示例可以看出 backtrace 函数的运行结果了，但是如果我们想要一个完整清晰的格式，还需要自己对其进行封装，这里参照 sylar 框架中的封装方法，简单的对其封装如下：

static std::string demangle(const char *str)
{
    size_t size = 0;
    int status = 0;
    std::string rt;
    rt.resize(256);
    if (1 == sscanf(str, "%*[^(]%*[^_]%255[^)+]", &rt[0]))
    {
        char *v = abi::__cxa_demangle(&rt[0], nullptr, &size, &status);
        if (v)
        {
            std::string result(v);
            free(v);
            return result;
        }
    }
    if (1 == sscanf(str, "%255s", &rt[0]))
    {
        return rt;
    }
    return str;
}

/**
 * @brief 获取当前的调用栈
 * @param[out] bt 保存调用栈
 * @param[in] size 最多返回层数
 * @param[in] skip 跳过栈顶的层数
 */
void Backtrace(std::vector<std::string> &bt, int size = 64, int skip = 1)
{
    void **array = (void **)malloc((sizeof(void *) * size));
    size_t s = ::backtrace(array, size);
    char **strings = backtrace_symbols(array, s);
    if (strings == NULL)
    {
        std::cout << "backtrace_synbols error." << std::endl;
        return;
    }
    for (size_t i = skip; i < s; ++i)
    {
        bt.push_back(demangle(strings[i]));
    }
    free(strings);
    free(array);
}

/**
 * @brief 获取当前栈信息的字符串
 * @param[in] size 栈的最大层数
 * @param[in] skip 跳过栈顶的层数
 * @param[in] prefix 栈信息前输出的内容
 */
std::string BacktraceToString(int size = 64, int skip = 2, const std::string &prifix = "")
{
    std::vector<std::string> bt;
    Backtrace(bt, size, skip);
    std::stringstream ss;
    for (size_t i = 0; i < bt.size(); ++i)
    {
        ss << prifix << bt[i] << std::endl;
    }
    return ss.str();
}

测试程序如下：

#include <iostream>
#include <assert.h>
#include <stdio.h>
#include <execinfo.h>
#include <unistd.h>
#include <stdlib.h>
#include <vector>
#include <execinfo.h>
#include <cxxabi.h>
#include <sstream>

//...

void my_assert()
{
    std::cout << BacktraceToString(10, 0, " --- ") << std::endl;
}

void Func2()
{
    my_assert();
}

void Func1()
{
    Func2();
}

int main(int argc, char *argv[])
{
    Func1();
    return 0;
}

运行结果如下：

$ ./bin/test_util 
 --- Backtrace(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >&, int, int)
 --- BacktraceToString(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)
 --- my_assert()
 --- Func2()
 --- Func1()
 --- ./bin/test_util(main+0x14)
 --- /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xe7)
 --- ./bin/test_util(_start+0x2a)

可以看到，经过封装后的函数打印出的堆栈信息非常清晰明了，我们可以为其指定调用栈的层数和跳过栈顶的层数，同时还可以指定其栈信息前输出的内容。

在 demangle 函数中，我们调用了一个 abi::__cxa_demangle 的函数，虽然 C++ 中有一个 typeid 操作可以获取一个类型的名称，但是在 gcc 中并不能得到想要的结果，如下程序：

typedef int (*pFun)(int, int);
std::cout << typeid(pFun).name() << std::endl;

msvc 编译器中打印出来的信息非常清晰，但是我们上面已经见识过 gcc 默认打印出来的栈函数信息，gcc 打出来将是如下：

PFiiiE

如果我们想要在 gcc 中打印出类似于 msvc 的信息比较详细的效果，就需要使用 abi::__cxa_demangle ，我们使用这个函数打印一个上面的程序：

char *name = abi::__cxa_demangle(typeid(pFun).name(), nullptr, nullptr, nullptr);
std::cout << name << std::endl;
free(name);

效果将会是：

int (*)(int, int)

同时我们再进行字符串的处理，就能清晰明了的函数调用堆栈信息了。

封装断言宏

上面已经将 backtrace 函数进行封装，也能得到清晰明了的函数调用堆栈信息。现在可以进行自己的函数的断言宏的封装。

#if defined __GNUC__ || defined __llvm__
#   define LIKELY(x)       __builtin_expect(!!(x), 1)
#   define UNLIKELY(x)     __builtin_expect(!!(x), 0)
#else
#   define LIKELY(x)      (x)
#   define UNLIKELY(x)    (x)
#endif

#define MY_ASSERT(x) \
    if (UNLIKELY(!(x))) \
    { \
        std::cout << "ASSERTION:" #x \
            << "\nbacktrace:\n" \
            << BacktraceToString(100, 2, " --- "); \
    }

上面定义了 LIKELY 和 UNLIKELY 宏定义，使用到了 __builtin_expect 分支预测优化，在另一篇文章中有详细说明，点击查看。

测试代码直接将上面的函数 my_assert 修改一下：

void my_assert()
{
    int a = 10;
    MY_ASSERT(a == 100)
}

在代码中，如果想要使用断言，就可以换成自己封装的 MY_ASSERT 宏，这个宏打印出来的格式如下：

$ ./bin/test
ASSERTION:a == 100
backtrace:
 --- my_assert()
 --- Func2()
 --- Func1()
 --- ./bin/test_log(main+0x14)
 --- /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xe7)
 --- ./bin/test_log(_start+0x2a)

相比最开始的的 assert 函数是不是清晰明了太多了呢。

参考：
如何在C++中获得完整的类型名称
https://github.com/sylar-yin/sylar