CまたはC ++でのコールスタックの出力


120

特定の関数が呼び出されるたびに、CまたはC ++で実行中のプロセスのコールスタックをダンプする方法はありますか?私が考えているのは次のようなものです:

void foo()
{
   print_stack_trace();

   // foo's body

   return
}

where はPerl print_stack_traceと同様に機能callerします。

またはこのようなもの:

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

    // etc...
}

where は、呼び出さregister_stack_trace_functionれたときにスタックトレースが出力されるようにする内部ブレークポイントを配置しますfoo

このようなものはいくつかの標準Cライブラリに存在しますか?

LinuxでGCCを使用しています。


バックグラウンド

この動作に影響しないはずのコマンドラインスイッチに基づいて異なる動作をするテスト実行があります。私のコードには、これらのスイッチに基づいて異なる方法で呼び出されていると想定する疑似乱数ジェネレーターがあります。スイッチの各セットを使用してテストを実行し、乱数ジェネレーターの呼び出しがスイッチごとに異なるかどうかを確認したいのですが。


1
@Armen、これらのいずれかを知っていますか?
ネイサンフェルマン

1
@Nathan:デバッガがgdbの場合、そのケース処理できます。他の人についてはお話しできませんが、この機能を備えているのはgdbだけではないと思います。 余談です、私は以前のコメントをただけです。:: gag :: s/easier/either/一体どうやって起こったのですか?
dmckee ---元モデレーターの子猫

2
@dmckee:実際には、それがなければなりませんs/either/easier。私がgdbで行う必要があるのは、その関数を中断してスタックトレースを出力し、続行するスクリプトを記述することです。考えてみたところで、gdbスクリプトについて学ぶ時がきたのかもしれません。
Nathan Fellman、

1
ガ!少し眠りにつく。すぐに本物になります...
dmckee ---元モデレーターの子猫

回答:


79

Linuxのみのソリューションの場合、単純に配列を返すbacktrace(3)を使用できますvoid *(実際、これらのそれぞれは、対応するスタックフレームからの戻りアドレスを指します)。これらを何かに変換するために、backtrace_symbols(3)があります。

backtrace(3)のノートセクションに注意してください。

シンボル名は、特別なリンカオプションを使用しないと使用できない場合があります。GNUリンカーを使用するシステムの場合、-rdynamicリンカーオプションを使用する必要があります。「静的」関数の名前は公開されておらず、バックトレースでは使用できないことに注意してください。


10
FWIWは、この機能は、Mac OS X上に存在する:developer.apple.com/library/mac/#documentation/Darwin/Reference/...
EmeryBerger



を備えたLinuxではglibc、残念ながら、backtrace_symbols関数は関数名、ソースファイル名、行番号を提供しません。
Maxim Egorushkin

の使用-rdynamicに加えて、ビルドシステムに-fvisibility=hiddenオプションが追加されていないことも確認してください。(これはの効果を完全に破棄するため-rdynamic
Dima Litvinov

36

スタックトレースをブースト

文書化: https //www.boost.org/doc/libs/1_66_0/doc/html/stacktrace/getting_started.html#stacktrace.getting_started.how_to_print_current_call_stack

これは、これまでに見た中で最も便利なオプションです。

  • 実際に行番号を出力できます。

    ただし、を呼び出すaddr2lineだけです。これは醜く、あまりに多くのトレースを取得している場合は遅くなる可能性があります。

  • デフォルトでデマングル

  • ブーストはヘッダーのみなので、ビルドシステムを変更する必要はほとんどありません

boost_stacktrace.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) {
    (void)f;
    my_func_2();
}

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

int main(int argc, char **argv) {
    long long unsigned int n;
    if (argc > 1) {
        n = strtoul(argv[1], NULL, 0);
    } else {
        n = 1;
    }
    for (long long unsigned int i = 0; i < n; ++i) {
        my_func_1(1);   // line 28
        my_func_1(2.0); // line 29
    }
}

残念ながら、これは最近追加されたようで、パッケージlibboost-stacktrace-devはUbuntu 16.04には存在せず、18.04にのみ存在します。

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

追加する必要があります -ldl最後しないとコンパイルに失敗します。

出力:

 0# boost::stacktrace::basic_stacktrace<std::allocator<boost::stacktrace::frame> >::basic_stacktrace() at /usr/include/boost/stacktrace/stacktrace.hpp:129
 1# my_func_1(int) at /home/ciro/test/boost_stacktrace.cpp:18
 2# main at /home/ciro/test/boost_stacktrace.cpp:29 (discriminator 2)
 3# __libc_start_main in /lib/x86_64-linux-gnu/libc.so.6
 4# _start in ./boost_stacktrace.out

 0# boost::stacktrace::basic_stacktrace<std::allocator<boost::stacktrace::frame> >::basic_stacktrace() at /usr/include/boost/stacktrace/stacktrace.hpp:129
 1# my_func_1(double) at /home/ciro/test/boost_stacktrace.cpp:13
 2# main at /home/ciro/test/boost_stacktrace.cpp:27 (discriminator 2)
 3# __libc_start_main in /lib/x86_64-linux-gnu/libc.so.6
 4# _start in ./boost_stacktrace.out

出力は、以下の「glibcバックトレース」セクションでさらに説明されており、類似しています。

どのように注意my_func_1(int)してmy_func_1(float)機能の過負荷に起因するマングルされ、きれいに私たちのために復号化されました。

最初のint呼び出しは1行(27行ではなく28行)、2行目は2行(29行ではなく27行)ずれていることに注意してください。これは、次の命令アドレスが考慮されているためであることがコメント示唆されています。27は28になり、29はループからジャンプして27になります。

次に、を使用すると-O3、出力が完全に切断されていることがわかります。

 0# boost::stacktrace::basic_stacktrace<std::allocator<boost::stacktrace::frame> >::size() const at /usr/include/boost/stacktrace/stacktrace.hpp:215
 1# my_func_1(double) at /home/ciro/test/boost_stacktrace.cpp:12
 2# __libc_start_main in /lib/x86_64-linux-gnu/libc.so.6
 3# _start in ./boost_stacktrace.out

 0# boost::stacktrace::basic_stacktrace<std::allocator<boost::stacktrace::frame> >::size() const at /usr/include/boost/stacktrace/stacktrace.hpp:215
 1# main at /home/ciro/test/boost_stacktrace.cpp:31
 2# __libc_start_main in /lib/x86_64-linux-gnu/libc.so.6
 3# _start in ./boost_stacktrace.out

バックトレースは一般に、最適化によって取り返しのつかないほど切断されます。テールコールの最適化は、その顕著な例です。テールコールの最適化とは何ですか。

ベンチマーク実行-O3

time  ./boost_stacktrace.out 1000 >/dev/null

出力:

real    0m43.573s
user    0m30.799s
sys     0m13.665s

したがって、予想どおり、このメソッドはへの外部呼び出しの可能性が非常に低くaddr2line、限られた数の呼び出しが行われている場合にのみ実行可能であることがわかります。

各バックトレース出力には数百ミリ秒かかるようです。バックトレースが非常に頻繁に発生すると、プログラムのパフォーマンスが大幅に低下することに注意してください。

Ubuntu 19.10、GCC 9.2.1、ブースト1.67.0でテスト済み。

glibc backtrace

文書化: 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

-rdynamic 重要な必須オプションです。

実行:

./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

完全にオフです。

-O0代わりに同じことを行うと./main.out、正しい完全なトレースが得られます。

./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

線が1つずれているのにTODOなのはなぜですか?しかし、これはまだ使えるかもしれません。

結論:バックトレースはでのみ完全に表示でき-O0ます。最適化により、元のバックトレースはコンパイルされたコードで根本的に変更されます。

これでC ++シンボルを自動的にデマングルする簡単な方法を見つけることができませんでしたが、いくつかハックがあります:

Ubuntu 16.04、GCC 6.4.0、libc 2.23でテスト済み。

glibc backtrace_symbols_fd

このヘルパーは、よりも少し便利でbacktrace_symbols、基本的に同じ出力を生成します。

/* 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でテスト済み。

glibc backtraceとC ++デマングルハック1:-export-dynamic+dladdr

原作: https //gist.github.com/fmela/591333/c64f4eb86037bb237862a8283df70cdfc25f01d3

ELFをで変更する必要があるため、これは「ハック」-export-dynamicです。

glibc_ldl.cpp

#include <dlfcn.h>     // for dladdr
#include <cxxabi.h>    // for __cxa_demangle

#include <cstdio>
#include <string>
#include <sstream>
#include <iostream>

// This function produces a stack backtrace with demangled function & method names.
std::string backtrace(int skip = 1)
{
    void *callstack[128];
    const int nMaxFrames = sizeof(callstack) / sizeof(callstack[0]);
    char buf[1024];
    int nFrames = backtrace(callstack, nMaxFrames);
    char **symbols = backtrace_symbols(callstack, nFrames);

    std::ostringstream trace_buf;
    for (int i = skip; i < nFrames; i++) {
        Dl_info info;
        if (dladdr(callstack[i], &info)) {
            char *demangled = NULL;
            int status;
            demangled = abi::__cxa_demangle(info.dli_sname, NULL, 0, &status);
            std::snprintf(
                buf,
                sizeof(buf),
                "%-3d %*p %s + %zd\n",
                i,
                (int)(2 + sizeof(void*) * 2),
                callstack[i],
                status == 0 ? demangled : info.dli_sname,
                (char *)callstack[i] - (char *)info.dli_saddr
            );
            free(demangled);
        } else {
            std::snprintf(buf, sizeof(buf), "%-3d %*p\n",
                i, (int)(2 + sizeof(void*) * 2), callstack[i]);
        }
        trace_buf << buf;
        std::snprintf(buf, sizeof(buf), "%s\n", symbols[i]);
        trace_buf << buf;
    }
    free(symbols);
    if (nFrames == nMaxFrames)
        trace_buf << "[truncated]\n";
    return trace_buf.str();
}

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

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

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

int main() {
    my_func_1(1);
    my_func_1(2.0);
}

コンパイルして実行:

g++ -fno-pie -ggdb3 -O0 -no-pie -o glibc_ldl.out -std=c++11 -Wall -Wextra \
  -pedantic-errors -fpic glibc_ldl.cpp -export-dynamic -ldl
./glibc_ldl.out 

出力:

1             0x40130a my_func_2() + 41
./glibc_ldl.out(_Z9my_func_2v+0x29) [0x40130a]
2             0x40139e my_func_1(int) + 16
./glibc_ldl.out(_Z9my_func_1i+0x10) [0x40139e]
3             0x4013b3 main + 18
./glibc_ldl.out(main+0x12) [0x4013b3]
4       0x7f7594552b97 __libc_start_main + 231
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xe7) [0x7f7594552b97]
5             0x400f3a _start + 42
./glibc_ldl.out(_start+0x2a) [0x400f3a]

1             0x40130a my_func_2() + 41
./glibc_ldl.out(_Z9my_func_2v+0x29) [0x40130a]
2             0x40138b my_func_1(double) + 18
./glibc_ldl.out(_Z9my_func_1d+0x12) [0x40138b]
3             0x4013c8 main + 39
./glibc_ldl.out(main+0x27) [0x4013c8]
4       0x7f7594552b97 __libc_start_main + 231
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xe7) [0x7f7594552b97]
5             0x400f3a _start + 42
./glibc_ldl.out(_start+0x2a) [0x400f3a]

Ubuntu 18.04でテスト済み。

backtraceC ++デマングルハックを使用したglibc 2:バックトレース出力を解析する

表示場所:https : //panthema.net/2008/0901-stacktrace-demangled/

解析が必要なため、これはハックです。

TODOでコンパイルしてここに表示します。

libunwind

TODOこれはglibcバックトレースよりも優れていますか?非常に類似した出力で、ビルドコマンドの変更も必要ですが、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

どちらの#define _XOPEN_SOURCE 700上でなければならない、あるいは我々が使用する必要があります-std=gnu99

実行:

./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

-O0

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でテスト済み。

libunwindとC ++名のデマングル

採用コード:https : //eli.thegreenplace.net/2015/programmatic-access-to-the-call-stack-in-c/

unwind.cpp

#define UNW_LOCAL_ONLY
#include <cxxabi.h>
#include <libunwind.h>
#include <cstdio>
#include <cstdlib>
#include <iostream>

void backtrace() {
  unw_cursor_t cursor;
  unw_context_t context;

  // Initialize cursor to current frame for local unwinding.
  unw_getcontext(&context);
  unw_init_local(&cursor, &context);

  // Unwind frames one by one, going up the frame stack.
  while (unw_step(&cursor) > 0) {
    unw_word_t offset, pc;
    unw_get_reg(&cursor, UNW_REG_IP, &pc);
    if (pc == 0) {
      break;
    }
    std::printf("0x%lx:", pc);

    char sym[256];
    if (unw_get_proc_name(&cursor, sym, sizeof(sym), &offset) == 0) {
      char* nameptr = sym;
      int status;
      char* demangled = abi::__cxa_demangle(sym, nullptr, nullptr, &status);
      if (status == 0) {
        nameptr = demangled;
      }
      std::printf(" (%s+0x%lx)\n", nameptr, offset);
      std::free(demangled);
    } else {
      std::printf(" -- error: unable to obtain symbol name for this frame\n");
    }
  }
}

void my_func_2(void) {
    backtrace();
    std::cout << std::endl; // line 43
}

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

void my_func_1(int i) {
    (void)i;
    my_func_2();
}  // line 54

int main() {
    my_func_1(1);
    my_func_1(2.0);
}

コンパイルして実行:

sudo apt-get install libunwind-dev
g++ -fno-pie -ggdb3 -O0 -no-pie -o unwind.out -std=c++11 \
  -Wall -Wextra -pedantic-errors unwind.cpp -lunwind -pthread
./unwind.out

出力:

0x400c80: (my_func_2()+0x9)
0x400cb7: (my_func_1(int)+0x10)
0x400ccc: (main+0x12)
0x7f4c68926b97: (__libc_start_main+0xe7)
0x400a3a: (_start+0x2a)

0x400c80: (my_func_2()+0x9)
0x400ca4: (my_func_1(double)+0x12)
0x400ce1: (main+0x27)
0x7f4c68926b97: (__libc_start_main+0xe7)
0x400a3a: (_start+0x2a)

その後、我々はのライン見つけることができるmy_func_2my_func_1(int)しての:

addr2line -e unwind.out 0x400c80 0x400cb7

それは与える:

/home/ciro/test/unwind.cpp:43
/home/ciro/test/unwind.cpp:54

TODO:ラインが1つずれるのはなぜですか?

Ubuntu 18.04、GCC 7.4.0、libunwind 1.2.1でテスト済み。

GDB自動化

これを使用して、GDBで再コンパイルせずにこれを行うこともできます。

バックトレースをたくさん印刷する場合は、他のオプションよりも遅くなる可能性がありますが、でネイティブの速度に到達できるかもしれませんcompile codeが、今はテストするのが面倒です。が面倒です gdbでアセンブリを呼び出す方法?

main.cpp

void my_func_2(void) {}

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

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

int main() {
    my_func_1(1);
    my_func_1(2.0);
}

main.gdb

start
break my_func_2
commands
  silent
  backtrace
  printf "\n"
  continue
end
continue

コンパイルして実行:

g++ -ggdb3 -o main.out main.cpp
gdb -nh -batch -x main.gdb main.out

出力:

Temporary breakpoint 1 at 0x1158: file main.cpp, line 12.

Temporary breakpoint 1, main () at main.cpp:12
12          my_func_1(1);
Breakpoint 2 at 0x555555555129: file main.cpp, line 1.
#0  my_func_2 () at main.cpp:1
#1  0x0000555555555151 in my_func_1 (i=1) at main.cpp:8
#2  0x0000555555555162 in main () at main.cpp:12

#0  my_func_2 () at main.cpp:1
#1  0x000055555555513e in my_func_1 (f=2) at main.cpp:4
#2  0x000055555555516f in main () at main.cpp:13

[Inferior 1 (process 14193) exited normally]

TODO -ex作成する必要main.gdbがないように、コマンドラインだけでこれを実行したかったのですが、commandsそこで作業することができませんでした。

Ubuntu 19.04、GDB 8.2でテスト済み。

Linuxカーネル

Linuxカーネル内の現在のスレッドスタックトレースを出力する方法

libdwfl

これはもともとhttps://stackoverflow.com/a/60713161/895245で言及されており、それが最善の方法かもしれませんが、もう少しベンチマークする必要がありますが、その回答に賛成投票してください。

TODO:機能していたその回答のコードを1つの関数に最小化しようとしましたが、セグメンテーション違反です。誰かがその理由を見つけられるかどうか知らせてください。

dwfl.cpp

#include <cassert>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>

#include <cxxabi.h> // __cxa_demangle
#include <elfutils/libdwfl.h> // Dwfl*
#include <execinfo.h> // backtrace
#include <unistd.h> // getpid

// /programming/281818/unmangling-the-result-of-stdtype-infoname
std::string demangle(const char* name) {
    int status = -4;
    std::unique_ptr<char, void(*)(void*)> res {
        abi::__cxa_demangle(name, NULL, NULL, &status),
        std::free
    };
    return (status==0) ? res.get() : name ;
}

std::string debug_info(Dwfl* dwfl, void* ip) {
    std::string function;
    int line = -1;
    char const* file;
    uintptr_t ip2 = reinterpret_cast<uintptr_t>(ip);
    Dwfl_Module* module = dwfl_addrmodule(dwfl, ip2);
    char const* name = dwfl_module_addrname(module, ip2);
    function = name ? demangle(name) : "<unknown>";
    if (Dwfl_Line* dwfl_line = dwfl_module_getsrc(module, ip2)) {
        Dwarf_Addr addr;
        file = dwfl_lineinfo(dwfl_line, &addr, &line, nullptr, nullptr, nullptr);
    }
    std::stringstream ss;
    ss << ip << ' ' << function;
    if (file)
        ss << " at " << file << ':' << line;
    ss << std::endl;
    return ss.str();
}

std::string stacktrace() {
    // Initialize Dwfl.
    Dwfl* dwfl = nullptr;
    {
        Dwfl_Callbacks callbacks = {};
        char* debuginfo_path = nullptr;
        callbacks.find_elf = dwfl_linux_proc_find_elf;
        callbacks.find_debuginfo = dwfl_standard_find_debuginfo;
        callbacks.debuginfo_path = &debuginfo_path;
        dwfl = dwfl_begin(&callbacks);
        assert(dwfl);
        int r;
        r = dwfl_linux_proc_report(dwfl, getpid());
        assert(!r);
        r = dwfl_report_end(dwfl, nullptr, nullptr);
        assert(!r);
        static_cast<void>(r);
    }

    // Loop over stack frames.
    std::stringstream ss;
    {
        void* stack[512];
        int stack_size = ::backtrace(stack, sizeof stack / sizeof *stack);
        for (int i = 0; i < stack_size; ++i) {
            ss << i << ": ";

            // Works.
            ss << debug_info(dwfl, stack[i]);

#if 0
            // TODO intended to do the same as above, but segfaults,
            // so possibly UB In above function that does not blow up by chance?
            void *ip = stack[i];
            std::string function;
            int line = -1;
            char const* file;
            uintptr_t ip2 = reinterpret_cast<uintptr_t>(ip);
            Dwfl_Module* module = dwfl_addrmodule(dwfl, ip2);
            char const* name = dwfl_module_addrname(module, ip2);
            function = name ? demangle(name) : "<unknown>";
            // TODO if I comment out this line it does not blow up anymore.
            if (Dwfl_Line* dwfl_line = dwfl_module_getsrc(module, ip2)) {
              Dwarf_Addr addr;
              file = dwfl_lineinfo(dwfl_line, &addr, &line, nullptr, nullptr, nullptr);
            }
            ss << ip << ' ' << function;
            if (file)
                ss << " at " << file << ':' << line;
            ss << std::endl;
#endif
        }
    }
    dwfl_end(dwfl);
    return ss.str();
}

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

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

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

int main(int argc, char **argv) {
    long long unsigned int n;
    if (argc > 1) {
        n = strtoul(argv[1], NULL, 0);
    } else {
        n = 1;
    }
    for (long long unsigned int i = 0; i < n; ++i) {
        my_func_1(1);
        my_func_1(2.0);
    }
}

コンパイルして実行:

sudo apt install libdw-dev
g++ -fno-pie -ggdb3 -O0 -no-pie -o dwfl.out -std=c++11 -Wall -Wextra -pedantic-errors dwfl.cpp -ldw
./dwfl.out

出力:

0: 0x402b74 stacktrace[abi:cxx11]() at /home/ciro/test/dwfl.cpp:65
1: 0x402ce0 my_func_2() at /home/ciro/test/dwfl.cpp:100
2: 0x402d7d my_func_1(int) at /home/ciro/test/dwfl.cpp:112
3: 0x402de0 main at /home/ciro/test/dwfl.cpp:123
4: 0x7f7efabbe1e3 __libc_start_main at ../csu/libc-start.c:342
5: 0x40253e _start at ../csu/libc-start.c:-1

0: 0x402b74 stacktrace[abi:cxx11]() at /home/ciro/test/dwfl.cpp:65
1: 0x402ce0 my_func_2() at /home/ciro/test/dwfl.cpp:100
2: 0x402d66 my_func_1(double) at /home/ciro/test/dwfl.cpp:107
3: 0x402df1 main at /home/ciro/test/dwfl.cpp:121
4: 0x7f7efabbe1e3 __libc_start_main at ../csu/libc-start.c:342
5: 0x40253e _start at ../csu/libc-start.c:-1

ベンチマーク実行:

g++ -fno-pie -ggdb3 -O3 -no-pie -o dwfl.out -std=c++11 -Wall -Wextra -pedantic-errors dwfl.cpp -ldw
time ./dwfl.out 1000 >/dev/null

出力:

real    0m3.751s
user    0m2.822s
sys     0m0.928s

したがって、この方法はBoostのスタックトレースよりも10倍高速であり、より多くのユースケースに適用できる可能性があることがわかります。

Ubuntu 19.10 amd64、libdw-dev 0.176-1.1でテスト済み。

こちらもご覧ください


1
「TODO:lines by one」はすべて、次の式の先頭から行番号が取得されるためです。
SSアン


6

特定の関数が呼び出されるたびに、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)

完全なソースコードはここから入手できます。

https://github.com/Nanolatのc-callstack


6

古いスレッドへの別の答え。

これを行う必要があるときは、通常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や同等の機能があるとは思いませんが、このスレッドには代替手段があるようです。

を使用している場合はCC文字列関数を使用する必要があります。

#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

void f()
{
    pid_t myPid = getpid();
    /*
      length of command 7 for 'pstack ', 7 for the PID, 1 for nul
    */
    char pstackCommand[7+7+1];
    sprintf(pstackCommand, "pstack %d", (int)myPid);
    system(pstackCommand);
}

この投稿に基づいて、PIDの最大桁数に7を使用しました。


std :: stringはC ++のみなので、サブジェクトはCを要求するため、変更する必要はありません。回答をCバージョンで更新します。
ポールフロイド

5

Linux固有、TLDR:

  1. backtraceは、リンクされているglibc場合にのみ正確なスタックトレースを生成し-lunwindます(文書化されていないプラットフォーム固有の機能)。
  2. 関数名ソースファイル行番号を使用して出力します#include <elfutils/libdwfl.h>(このライブラリはヘッダーファイルにのみ記載されています)。backtrace_symbolsそしてbacktrace_symbolsd_fd、最も有益ではありません。

最新のLinuxでは、関数を使用してスタックトレースアドレスを取得できますbacktracebacktrace一般的なプラットフォームでより正確なアドレスを生成する文書化されていない方法は、-lunwindlibunwind-devUbuntu 18.04で)とリンクすることです(以下の出力例を参照)。backtrace関数_Unwind_Backtraceを使用し、デフォルトでは後者が使用されlibgcc_s.so.1、その実装は最も移植性があります。-lunwindがリンクされている場合、より正確なバージョンが提供されます_Unwind_Backtraceが、このライブラリは移植性が低くなります(でサポートされているアーキテクチャを参照libunwind/src)。

残念ながら、コンパニオンbacktrace_symbolsdbacktrace_symbols_fd関数は、おそらく10年間、スタックトレースアドレスをソースファイル名と行番号を含む関数名に解決できませんでした(以下の出力例を参照)。

ただし、アドレスをシンボルに解決する別の方法があり、関数名ソースファイル行番号含む最も有用なトレースを生成します。メソッドは#include <elfutils/libdwfl.h>-ldwlibdw-devUbuntu 18.04の場合)にリンクします。

C ++の例(test.cc):

#include <stdexcept>
#include <iostream>
#include <cassert>
#include <cstdlib>
#include <string>

#include <boost/core/demangle.hpp>

#include <execinfo.h>
#include <elfutils/libdwfl.h>

struct DebugInfoSession {
    Dwfl_Callbacks callbacks = {};
    char* debuginfo_path = nullptr;
    Dwfl* dwfl = nullptr;

    DebugInfoSession() {
        callbacks.find_elf = dwfl_linux_proc_find_elf;
        callbacks.find_debuginfo = dwfl_standard_find_debuginfo;
        callbacks.debuginfo_path = &debuginfo_path;

        dwfl = dwfl_begin(&callbacks);
        assert(dwfl);

        int r;
        r = dwfl_linux_proc_report(dwfl, getpid());
        assert(!r);
        r = dwfl_report_end(dwfl, nullptr, nullptr);
        assert(!r);
        static_cast<void>(r);
    }

    ~DebugInfoSession() {
        dwfl_end(dwfl);
    }

    DebugInfoSession(DebugInfoSession const&) = delete;
    DebugInfoSession& operator=(DebugInfoSession const&) = delete;
};

struct DebugInfo {
    void* ip;
    std::string function;
    char const* file;
    int line;

    DebugInfo(DebugInfoSession const& dis, void* ip)
        : ip(ip)
        , file()
        , line(-1)
    {
        // Get function name.
        uintptr_t ip2 = reinterpret_cast<uintptr_t>(ip);
        Dwfl_Module* module = dwfl_addrmodule(dis.dwfl, ip2);
        char const* name = dwfl_module_addrname(module, ip2);
        function = name ? boost::core::demangle(name) : "<unknown>";

        // Get source filename and line number.
        if(Dwfl_Line* dwfl_line = dwfl_module_getsrc(module, ip2)) {
            Dwarf_Addr addr;
            file = dwfl_lineinfo(dwfl_line, &addr, &line, nullptr, nullptr, nullptr);
        }
    }
};

std::ostream& operator<<(std::ostream& s, DebugInfo const& di) {
    s << di.ip << ' ' << di.function;
    if(di.file)
        s << " at " << di.file << ':' << di.line;
    return s;
}

void terminate_with_stacktrace() {
    void* stack[512];
    int stack_size = ::backtrace(stack, sizeof stack / sizeof *stack);

    // Print the exception info, if any.
    if(auto ex = std::current_exception()) {
        try {
            std::rethrow_exception(ex);
        }
        catch(std::exception& e) {
            std::cerr << "Fatal exception " << boost::core::demangle(typeid(e).name()) << ": " << e.what() << ".\n";
        }
        catch(...) {
            std::cerr << "Fatal unknown exception.\n";
        }
    }

    DebugInfoSession dis;
    std::cerr << "Stacktrace of " << stack_size << " frames:\n";
    for(int i = 0; i < stack_size; ++i) {
        std::cerr << i << ": " << DebugInfo(dis, stack[i]) << '\n';
    }
    std::cerr.flush();

    std::_Exit(EXIT_FAILURE);
}

int main() {
    std::set_terminate(terminate_with_stacktrace);
    throw std::runtime_error("test exception");
}

Ubuntu 18.04.4 LTSとgcc-8.3でコンパイル:

g++ -o test.o -c -m{arch,tune}=native -std=gnu++17 -W{all,extra,error} -g -Og -fstack-protector-all test.cc
g++ -o test -g test.o -ldw -lunwind

出力:

Fatal exception std::runtime_error: test exception.
Stacktrace of 7 frames:
0: 0x55f3837c1a8c terminate_with_stacktrace() at /home/max/src/test/test.cc:76
1: 0x7fbc1c845ae5 <unknown>
2: 0x7fbc1c845b20 std::terminate()
3: 0x7fbc1c845d53 __cxa_throw
4: 0x55f3837c1a43 main at /home/max/src/test/test.cc:103
5: 0x7fbc1c3e3b96 __libc_start_main at ../csu/libc-start.c:310
6: 0x55f3837c17e9 _start

-lunwindリンクされていない場合、スタックトレースの精度は低くなります。

0: 0x5591dd9d1a4d terminate_with_stacktrace() at /home/max/src/test/test.cc:76
1: 0x7f3c18ad6ae6 <unknown>
2: 0x7f3c18ad6b21 <unknown>
3: 0x7f3c18ad6d54 <unknown>
4: 0x5591dd9d1a04 main at /home/max/src/test/test.cc:103
5: 0x7f3c1845cb97 __libc_start_main at ../csu/libc-start.c:344
6: 0x5591dd9d17aa _start

比較のbacktrace_symbols_fdために、同じスタックトレースの出力は情報量が最も少ないです:

/home/max/src/test/debug/gcc/test(+0x192f)[0x5601c5a2092f]
/usr/lib/x86_64-linux-gnu/libstdc++.so.6(+0x92ae5)[0x7f95184f5ae5]
/usr/lib/x86_64-linux-gnu/libstdc++.so.6(_ZSt9terminatev+0x10)[0x7f95184f5b20]
/usr/lib/x86_64-linux-gnu/libstdc++.so.6(__cxa_throw+0x43)[0x7f95184f5d53]
/home/max/src/test/debug/gcc/test(+0x1ae7)[0x5601c5a20ae7]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xe6)[0x7f9518093b96]
/home/max/src/test/debug/gcc/test(+0x1849)[0x5601c5a20849]

製品版(およびC言語バージョン)boost::core::demangleでは、std::stringを置き換えて、このコードをさらに堅牢にすることができます。std::coutを基になる呼び出しでます。

オーバーライド__cxa_throwして、例外がスローされたときにスタックトレースをキャプチャし、例外がキャッチされたときにスタックトレースを出力することもできます。catchブロックに入る時点で、スタックはほどかれているので、を呼び出すには遅すぎます。そのため、functionによって実装さbacktraceれるスタックをキャプチャする必要があります。マルチスレッド化されたプログラムであること注もしそれがなければなりませんグローバル配列にスタックトレースをキャプチャするように、複数のスレッドで同時に呼び出すことができます。throw__cxa_throw__cxa_throwthread_local


1
素敵な答え!よく研究されています。
SSアン

@SSAnneとても親切です、ありがとう。この-lunwind問題は、この投稿の作成中に発見されました。以前はlibunwind直接スタックトレースを取得するために使用し、それを投稿しようとbacktraceしていました-lunwindが、リンクされている場合はそれを行います。
Maxim Egorushkin

1
@SSAnneライブラリの元の作者であるDavid Mosbergerが最初はIA-64に焦点を合わせていたが、その後、ライブラリがより多くの牽引力を獲得したためである可能性がありますnongnu.org/libunwind/people.htmlgccAPIを公開していませんが、そうですか?
Maxim Egorushkin

3

自分で機能を実装できます。

グローバル(文字列)スタックを使用し、各関数の開始時に、関数名とそのような他の値(パラメーターなど)をこのスタックにプッシュします。関数の終了時に再度ポップします。

呼び出されたときにスタックの内容を出力する関数を記述し、呼び出しスタックを表示する関数でこれを使用します。

これは大変な作業のように聞こえるかもしれませんが、非常に便利です。


2
私はそうしません。むしろ、基盤となるプラットフォーム固有のAPIを使用するラッパーを作成します(以下を参照)。作業量はおそらく同じですが、投資はより早く返済するはずです。
ポールミカリック

3
@paul:あなたの答えは、OPがlinuxを明確に指定している場合のWindowsを参照していますが、ここに表示されるWindowsの人には役立つ可能性があります。
slashmais

そうです、私はそれを見落としました..ええと、それは質問の最後の文なので、おそらく投稿者は彼/彼女のターゲットプラットフォームをより目立つ場所で言及するように彼のリクエストを変更する必要があります。
Paul Michalik

1
私のコードベースに数百(数千ではないにしても)のファイルを含む数十のファイルが含まれていることを除いて、これは良いアイデアなので、これは実行不可能です。
Nathan Fellman、

sed / perlスクリプトをハックアップcall_registror MY_SUPERSECRETNAME(__FUNCTION__);して、コンストラクターで引数をプッシュし、そのデストラクターでポップする各関数宣言の後に追加する場合は、多分そうではありません。FUNCTIONは常に現在の関数の名前を表します。
flownt

2

もちろん次の質問は、これで十分でしょうか?

スタックトレースの主な欠点は、正確な関数が呼び出される理由は、引数の値など、デバッグに非常に役立つため、他に何もないことです。

gccとgdbにアクセスできる場合は、を使用assertして特定の条件を確認し、条件を満たしていない場合はメモリダンプを生成することをお勧めします。もちろん、これはプロセスが停止することを意味しますが、単なるスタックトレースではなく、本格的なレポートが作成されます。

目立たない方法が必要な場合は、いつでもロギングを使用できます。Pantheiosのような非常に効率的なロギング機能がありますたとえばます。これにより、何が起こっているかをより正確に把握できるようになります。


1
もちろん、それだけでは十分ではないかもしれませんが、関数が一方の構成で呼び出され、もう一方の構成では呼び出されないことがわかった場合、それはかなりよい開始点です。
Nathan Fellman、

2

これにはポピーを使用できます。これは通常、クラッシュ時にスタックトレースを収集するために使用されますが、実行中のプログラムに対しても出力できます。

これが良い点です。スタック上の各関数の実際のパラメーター値、さらにはローカル変数、ループカウンターなどを出力できます。


2

このスレッドは古いことは知っていますが、他の人にも役立つと思います。gccを使用している場合は、そのインストゥルメント機能(-finstrument-functionsオプション)を使用して、関数呼び出し(エントリと終了)をログに記録できます。詳細については、こちらをご覧ください。 http //hacktalks.blogspot.fr/2013/08/gcc-instrument-functions.html

したがって、たとえば、すべての呼び出しをスタックにプッシュしてポップすることができ、それを印刷したいときは、スタックにあるものを見るだけです。

私はそれをテストしました、それは完全に機能し、非常に便利です

更新:-finstrument-functionsコンパイルオプションに関する情報は、GCCドキュメントのインストルメンテーションオプションについても見つけることができます:https ://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html


また、記事がダウンした場合に備えて、GCCドキュメントにリンクする必要があります。
HolyBlackCat

ありがとう、あなたは正しい。私は、このようにgccのドキュメントへのリンクを私のポストにUPDATEを追加しました
フランソワ・

2

Boostライブラリを使用して、現在のコールスタックを出力できます。

#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


cannot locate SymEnumSymbolsExW at C:\Windows\SYSTEM32\dbgeng.dllWin10でエラーが発生しました。
zwcloud

0

GNUプロファイラを使用できます。コールグラフも表示!コマンドはgprofあり、いくつかのオプションを使用してコードをコンパイルする必要があります。


-6

特定の関数が呼び出されるたびに、CまたはC ++で実行中のプロセスのコールスタックをダンプする方法はありますか?

いいえ、ありません。ただし、プラットフォーム依存のソリューションが存在する可能性があります。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.