用C或C ++打印调用堆栈

有没有办法在每次调用某个函数时在C或C ++中正在运行的进程中转储调用堆栈? 我的想法是这样的:

void foo()
{
   print_stack_trace();

   // foo's body

   return
}

其中register_stack_trace_function与Perl中的register_stack_trace_function类似。

或类似的东西:

int main (void)
{
    // will print out debug info every time foo() is called
    register_stack_trace_function(foo); 

    // etc...
}

其中register_stack_trace_function放置某种内部断点,只要调用foo,就会打印堆栈跟踪。

在某些标准C库中是否存在类似的内容?

我正在使用GCC在Linux上工作。


背景

我有一个测试运行,根据一些不应该影响这种行为的命令行开关,行为不同。 我的代码有一个伪随机数生成器,我假设它是基于这些开关被不同地调用的。 我希望能够使用每组开关运行测试,并查看随机数生成器是否针对每个开关进行不同的调用。

Nathan Fellman asked 2019-08-12T10:28:59Z
12个解决方案
68 votes

对于仅支持linux的解决方案,您可以使用backtrace(3),它只返回一个void *的数组(实际上每个都指向相应堆栈帧的返回地址)。 要将这些翻译成某种用途,可以使用backtrace_symbols(3)。

注意回溯(3)中的注释部分:

符号名称可能不可用   不使用特殊的链接器  选项。          对于使用GNU链接器的系统,有必要使用   - 动态链接器          选项。 请注意"静态"的名称 功能没有暴露,   并且不会成为          在回溯中可用。

Idan K answered 2019-08-12T10:29:26Z
5 votes

没有标准化的方法可以做到这一点。 对于Windows,功能在DbgHelp库中提供

Paul Michalik answered 2019-08-12T10:29:52Z
5 votes

有没有办法在每次调用某个函数时在C或C ++中正在运行的进程中转储调用堆栈?

您可以在特定函数中使用宏函数而不是return语句。

例如,而不是使用返回,

int foo(...)
{
    if (error happened)
        return -1;

    ... do something ...

    return 0
}

您可以使用宏功能。

#include "c-callstack.h"

int foo(...)
{
    if (error happened)
        NL_RETURN(-1);

    ... do something ...

    NL_RETURN(0);
}

每当函数中发生错误时,您将看到Java样式的调用堆栈,如下所示。

Error(code:-1) at : so_topless_ranking_server (sample.c:23)
Error(code:-1) at : nanolat_database (sample.c:31)
Error(code:-1) at : nanolat_message_queue (sample.c:39)
Error(code:-1) at : main (sample.c:47)

完整源代码可在此处获得。

c-callstack在[https://github.com/Nanolat]

NullPointerException answered 2019-08-12T10:30:58Z
4 votes

旧线程的另一个答案。

当我需要这样做时,我通常只使用system()pstack

所以像这样:

#include <sys/types.h>
#include <unistd.h>
#include <string>
#include <sstream>
#include <cstdlib>

void f()
{
    pid_t myPid = getpid();
    std::string pstackCommand = "pstack ";
    std::stringstream ss;
    ss << myPid;
    pstackCommand += ss.str();
    system(pstackCommand.c_str());
}

void g()
{
   f();
}


void h()
{
   g();
}

int main()
{
   h();
}

这输出

#0  0x00002aaaab62d61e in waitpid () from /lib64/libc.so.6
#1  0x00002aaaab5bf609 in do_system () from /lib64/libc.so.6
#2  0x0000000000400c3c in f() ()
#3  0x0000000000400cc5 in g() ()
#4  0x0000000000400cd1 in h() ()
#5  0x0000000000400cdd in main ()

这应该适用于Linux,FreeBSD和Solaris。 我不认为macOS有pstack或简单的等价物,但这个线程似乎有另一种选择。

Paul Floyd answered 2019-08-12T10:31:41Z
3 votes

提升堆栈跟踪

记录于:[https://www.boost.org/doc/libs/1_66_0/doc/html/stacktrace/getting_started.html#stacktrace.getting_started.how_to_print_current_call_stack]

这是我到目前为止看到的最方便的选项,因为它:

  • 实际上可以打印出行号。

    它只是调用abi::__cxa_demangle然而,这很难看,如果你的痕迹很多,可能会很慢。

  • demangles默认情况下

  • Boost只是标题,因此最不需要修改构建系统

main.cpp中

#include <iostream>

#define BOOST_STACKTRACE_USE_ADDR2LINE
#include <boost/stacktrace.hpp>

void my_func_2(void) {
    std::cout << boost::stacktrace::stacktrace() << std::endl;
}

void my_func_1(double f) {
    my_func_2();
}

void my_func_1(int i) {
    my_func_2();
}

int main() {
    my_func_1(1);   /* line 19 */
    my_func_1(2.0); /* line 20 */
}

不幸的是,它似乎是一个更新的添加,并且包abi::__cxa_demangle在Ubuntu 16.04中不存在,只有18.04:

sudo apt-get install libboost-stacktrace-dev
g++ -fno-pie -ggdb3 -O0 -no-pie -o main.out -std=c++11 \
  -Wall -Wextra -pedantic-errors main.cpp -ldl

我们必须在最后添加abi::__cxa_demangle,否则编译失败。

然后:

./main.out

得到:

 0# my_func_2() at /root/lkmc/main.cpp:7
 1# my_func_1(int) at /root/lkmc/main.cpp:16
 2# main at /root/lkmc/main.cpp:20
 3# __libc_start_main in /lib/x86_64-linux-gnu/libc.so.6
 4# _start in ./main.out

 0# my_func_2() at /root/lkmc/main.cpp:7
 1# my_func_1(double) at /root/lkmc/main.cpp:12
 2# main at /root/lkmc/main.cpp:21
 3# __libc_start_main in /lib/x86_64-linux-gnu/libc.so.6
 4# _start in ./main.out

并与abi::__cxa_demangle

 0# my_func_2() at /usr/include/boost/stacktrace/stacktrace.hpp:217
 1# my_func_1(double) at /root/lkmc/main.cpp:11
 2# __libc_start_main in /lib/x86_64-linux-gnu/libc.so.6
 3# _start in ./main.out

 0# my_func_2() at /usr/include/boost/stacktrace/stacktrace.hpp:217
 1# main at /root/lkmc/main.cpp:21
 2# __libc_start_main in /lib/x86_64-linux-gnu/libc.so.6
 3# _start in ./main.out

请记住,回溯通常会被优化无可挽回地毁掉。 尾调用优化是一个值得注意的例子:什么是尾调用优化?

输出在&#34; glibc backtrace&#34;上进一步说明。 以下部分,类似。

在Ubuntu 18.04,GCC 7.3.0上测试,提升1.65.1。

glibc回溯

记录于:[https://www.gnu.org/software/libc/manual/html_node/Backtraces.html]

main.c中

#include <stdio.h>
#include <stdlib.h>

/* Paste this on the file you want to debug. */
#include <stdio.h>
#include <execinfo.h>
void print_trace(void) {
    char **strings;
    size_t i, size;
    enum Constexpr { MAX_SIZE = 1024 };
    void *array[MAX_SIZE];
    size = backtrace(array, MAX_SIZE);
    strings = backtrace_symbols(array, size);
    for (i = 0; i < size; i++)
        printf("%s\n", strings[i]);
    puts("");
    free(strings);
}

void my_func_3(void) {
    print_trace();
}

void my_func_2(void) {
    my_func_3();
}

void my_func_1(void) {
    my_func_3();
}

int main(void) {
    my_func_1(); /* line 33 */
    my_func_2(); /* line 34 */
    return 0;
}

编译:

gcc -fno-pie -ggdb3 -O3 -no-pie -o main.out -rdynamic -std=c99 \
  -Wall -Wextra -pedantic-errors main.c

abi::__cxa_demangle是必需的关键选项。

跑:

./main.out

输出:

./main.out(print_trace+0x2d) [0x400a3d]
./main.out(main+0x9) [0x4008f9]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0) [0x7f35a5aad830]
./main.out(_start+0x29) [0x400939]

./main.out(print_trace+0x2d) [0x400a3d]
./main.out(main+0xe) [0x4008fe]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0) [0x7f35a5aad830]
./main.out(_start+0x29) [0x400939]

因此我们立即看到内联优化发生了,并且一些函数从跟踪中丢失了。

如果我们试图获取地址:

addr2line -e main.out 0x4008f9 0x4008fe

我们获得:

/home/ciro/main.c:21
/home/ciro/main.c:36

完全没了。

如果我们对abi::__cxa_demangle执行相同操作,则backtrace会给出正确的完整跟踪:

./main.out(print_trace+0x2e) [0x4009a4]
./main.out(my_func_3+0x9) [0x400a50]
./main.out(my_func_1+0x9) [0x400a68]
./main.out(main+0x9) [0x400a74]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0) [0x7f4711677830]
./main.out(_start+0x29) [0x4008a9]

./main.out(print_trace+0x2e) [0x4009a4]
./main.out(my_func_3+0x9) [0x400a50]
./main.out(my_func_2+0x9) [0x400a5c]
./main.out(main+0xe) [0x400a79]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0) [0x7f4711677830]
./main.out(_start+0x29) [0x4008a9]

然后:

addr2line -e main.out 0x400a74 0x400a79

得到:

/home/cirsan01/test/main.c:34
/home/cirsan01/test/main.c:35

所以线条只有一个,TODO为什么? 但这可能仍然有用。

结论:此方法仅适用于abi::__cxa_demangle,这种方式使我更有可能只想使用GDB,因为backtrace失去了很多性能并且可能使调试速度太慢。

在Ubuntu 16.04,GCC 6.4.0,libc 2.23上测试。

glibc abi::__cxa_demangle

这个帮助比abi::__cxa_demangle更方便,并产生基本相同的输出:

/* Paste this on the file you want to debug. */
#include <execinfo.h>
#include <stdio.h>
#include <unistd.h>
void print_trace(void) {
    size_t i, size;
    enum Constexpr { MAX_SIZE = 1024 };
    void *array[MAX_SIZE];
    size = backtrace(array, MAX_SIZE);
    backtrace_symbols_fd(array, size, STDOUT_FILENO);
    puts("");
}

在Ubuntu 16.04,GCC 6.4.0,libc 2.23上测试。

libunwind

TODO这比glibc回溯有什么优势吗? 非常相似的输出,也需要修改构建命令,但不太广泛可用。

代码改编自:[https://eli.thegreenplace.net/2015/programmatic-access-to-the-call-stack-in-c/]

main.c中

/* This must be on top. */
#define _XOPEN_SOURCE 700

#include <stdio.h>
#include <stdlib.h>

/* Paste this on the file you want to debug. */
#define UNW_LOCAL_ONLY
#include <libunwind.h>
#include <stdio.h>
void print_trace() {
    char sym[256];
    unw_context_t context;
    unw_cursor_t cursor;
    unw_getcontext(&context);
    unw_init_local(&cursor, &context);
    while (unw_step(&cursor) > 0) {
        unw_word_t offset, pc;
        unw_get_reg(&cursor, UNW_REG_IP, &pc);
        if (pc == 0) {
            break;
        }
        printf("0x%lx:", pc);
        if (unw_get_proc_name(&cursor, sym, sizeof(sym), &offset) == 0) {
            printf(" (%s+0x%lx)\n", sym, offset);
        } else {
            printf(" -- error: unable to obtain symbol name for this frame\n");
        }
    }
    puts("");
}

void my_func_3(void) {
    print_trace();
}

void my_func_2(void) {
    my_func_3();
}

void my_func_1(void) {
    my_func_3();
}

int main(void) {
    my_func_1(); /* line 46 */
    my_func_2(); /* line 47 */
    return 0;
}

编译并运行:

sudo apt-get install libunwind-dev
gcc -fno-pie -ggdb3 -O3 -no-pie -o main.out -std=c99 \
  -Wall -Wextra -pedantic-errors main.c -lunwind

abi::__cxa_demangle必须位于顶部,否则我们必须使用backtrace

  • 是不是在linux上定义了`stack_t`类型?
  • Glibc - ucontext.h中的错误,但仅限于-std = c11

跑:

./main.out

输出:

0x4007db: (main+0xb)
0x7f4ff50aa830: (__libc_start_main+0xf0)
0x400819: (_start+0x29)

0x4007e2: (main+0x12)
0x7f4ff50aa830: (__libc_start_main+0xf0)
0x400819: (_start+0x29)

和:

addr2line -e main.out 0x4007db 0x4007e2

得到:

/home/ciro/main.c:34
/home/ciro/main.c:49

随着abi::__cxa_demangle

0x4009cf: (my_func_3+0xe)
0x4009e7: (my_func_1+0x9)
0x4009f3: (main+0x9)
0x7f7b84ad7830: (__libc_start_main+0xf0)
0x4007d9: (_start+0x29)

0x4009cf: (my_func_3+0xe)
0x4009db: (my_func_2+0x9)
0x4009f8: (main+0xe)
0x7f7b84ad7830: (__libc_start_main+0xf0)
0x4007d9: (_start+0x29)

和:

addr2line -e main.out 0x4009f3 0x4009f8

得到:

/home/ciro/main.c:47
/home/ciro/main.c:48

在Ubuntu 16.04,GCC 6.4.0,libunwind 1.1上测试。

C ++ demangling

对于glibc backtrace和libunwind,可以使用abi::__cxa_demangle完成,请参阅以下示例:[https://eli.thegreenplace.net/2015/programmatic-access-to-the-call-stack-in-c/]

Linux内核

如何在Linux内核中打印当前的线程堆栈跟踪?

也可以看看

  • 如何在C中获取堆栈跟踪?
  • 如何使backtrace()/ backtrace_symbols()打印函数名称?
  • 是否有可移植/符合标准的方法来获取堆栈跟踪中的文件名和行号?
2 votes

当然接下来的问题是:这还够吗?

堆栈跟踪的主要缺点是,为什么你要调用精确的函数,你没有其他任何东西,比如它的参数值,这对调试非常有用。

如果您有权访问gcc和gdb,我建议使用assert来检查特定条件,如果不满足则生成内存转储。 当然,这意味着该过程将停止,但您将拥有完整的成熟报告,而不仅仅是堆栈跟踪。

如果您希望采用不那么突兀的方式,则可以始终使用日志记录。 那里有非常高效的伐木设施,例如Pantheios。 这再次可以让您更准确地了解正在发生的事情。

Matthieu M. answered 2019-08-12T10:38:02Z
2 votes

你可以使用Poppy。 它通常用于在崩溃期间收集堆栈跟踪,但它也可以为正在运行的程序输出它。

现在这里是好的部分:它可以输出堆栈上每个函数的实际参数值,甚至是局部变量,循环计数器等。

Orlin Georgiev answered 2019-08-12T10:38:36Z
1 votes

您可以自己实现这些功能:

使用全局(字符串)堆栈,并在每个函数的开头将函数名称和其他值(例如参数)推送到此堆栈; 在函数退出时再次弹出它。

编写一个函数,在调用堆栈内容时将其打印出来,并在要查看调用堆栈的函数中使用它。

这可能听起来像很多工作,但非常有用。

slashmais answered 2019-08-12T10:39:22Z
1 votes

我知道这个帖子很旧,但我认为它对其他人有用。 如果您使用的是gcc,则可以使用其仪器功能(-finstrument-functions选项)来记录任何函数调用(进入和退出)。 有关更多信息,请查看此内容:[http://hacktalks.blogspot.fr/2013/08/gcc-instrument-functions.html]

因此,您可以将每个调用推送并弹出到堆栈中,当您想要打印它时,只需查看堆栈中的内容即可。

我已经对它进行了测试,它工作得非常好并且非常方便

更新:您还可以在GCC文档中找到有关“仪器”选项的-finstrument-functions编译选项的信息:[https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html]

François answered 2019-08-12T10:40:10Z
1 votes

您可以使用Boost库来打印当前的callstack。

#include <boost/stacktrace.hpp>

// ... somewhere inside the `bar(int)` function that is called recursively:
std::cout << boost::stacktrace::stacktrace();

男子:[https://www.boost.org/doc/libs/1_65_1/doc/html/stacktrace.html]

Barkles answered 2019-08-12T10:40:42Z
0 votes

您可以使用GNU分析器。 它也显示了调用图! 命令是gprof,您需要使用一些选项编译代码。

Saurabh Shah answered 2019-08-12T10:41:08Z
-2 votes

有没有办法在每次调用某个函数时在C或C ++中正在运行的进程中转储调用堆栈?

不存在,尽管可能存在与平台相关的解决方案。

sbi answered 2019-08-12T10:41:36Z
translate from https://stackoverflow.com:/questions/3899870/print-call-stack-in-c-or-c