vytisknout zásobník volání v C nebo C++

Pro řešení pouze pro linux můžete použít backtrace(3), který jednoduše vrátí pole void * (ve skutečnosti každý z nich ukazuje na návratovou adresu z odpovídajícího rámce zásobníku). Chcete-li je převést na něco užitečného, ​​existuje backtrace_symbols(3).

Věnujte pozornost sekci poznámek v backtrace(3):

Názvy symbolů mohou být nedostupné bez použití speciálních možností linkeru. U systémů používajících linker GNU je nutné použít volbu-rdynamic linkeroption. Všimněte si, že názvy "statických" funkcí nejsou odhaleny a nebudou dostupné v backtrace.

Existuje nějaký způsob, jak vypsat zásobník volání v běžícím procesu v C nebo C++ pokaždé, když je zavolána určitá funkce?

Ve specifické funkci můžete místo příkazu return použít funkci makra.

Například namísto použití return

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

    ... do something ...

    return 0
}

Můžete použít funkci makra.

#include "c-callstack.h"

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

    ... do something ...

    NL_RETURN(0);
}

Kdykoli dojde ve funkci k chybě, zobrazí se zásobník volání ve stylu Java, jak je uvedeno níže.

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)

Úplný zdrojový kód je k dispozici zde.

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

Zvýšení stacktrace

Zdokumentováno na:https://www.boost.org/doc/libs/1_66_0/doc/html/stacktrace/getting_started.html#stacktrace.getting_started.how_to_print_current_call_stack

Toto je nejpohodlnější možnost, kterou jsem zatím viděl, protože:

• může skutečně vytisknout čísla řádků.

  Pouze volá na addr2line což však přidává ošklivou externí závislost a značně zpomalí váš kód, pokud děláte mnoho stop

• demangles ve výchozím nastavení

• Boost je pouze hlavička, takže s největší pravděpodobností není potřeba upravovat systém sestavení

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
    }
}

Bohužel se zdá, že jde o novější přírůstek a balíček libboost-stacktrace-dev není přítomen v Ubuntu 16.04, pouze 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

Musíme přidat -ldl na konci, jinak se kompilace nezdaří.

Výstup:

 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

Výstup a je dále vysvětleno v sekci "glibc backtrace" níže, která je analogická.

Všimněte si, jak my_func_1(int) a my_func_1(float) , které jsou zničené z důvodu přetížení funkcí, byly pro nás pěkně demanglovány.

Všimněte si, že první int hovory jsou vypnuty o jednu linku (28 místo 27 a druhá je vypnuta o dvě linky (27 místo 29). V komentářích bylo navrženo, že je to proto, že se uvažuje o následující adrese instrukce, takže z 27 se stane 28 , a 29 vyskočí ze smyčky a stane se 27.

Potom to pozorujeme pomocí -O3 , výstup je zcela zmrzačený:

 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

Zpětné stopy jsou obecně optimalizací nenávratně zmrzačeny. Optimalizace koncového volání je toho pozoruhodným příkladem:Co je optimalizace koncového volání?

Benchmark běží na -O3 :

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

Výstup:

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

Jak jsme očekávali, vidíme, že tato metoda je extrémně pomalá pro externí volání addr2line , a bude to možné pouze v případě, že bude uskutečněn omezený počet hovorů.

Zdá se, že každý tisk zpětného trasování trvá stovky milisekund, takže mějte na paměti, že pokud k zpětnému trasování dochází velmi často, výkon programu výrazně utrpí.

Testováno na Ubuntu 19.10, GCC 9.2.1, boost 1.67.0.

glibc backtrace

Zdokumentováno na: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;
}

Kompilace:

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

-rdynamic je klíčová požadovaná možnost.

Spustit:

./main.out

Výstupy:

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

Okamžitě tedy vidíme, že došlo k inliningové optimalizaci a některé funkce byly ze trasování ztraceny.

Pokud se pokusíme získat adresy:

addr2line -e main.out 0x4008f9 0x4008fe

získáme:

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

který je úplně mimo.

Pokud uděláme totéž s -O0 místo toho ./main.out poskytuje správnou úplnou stopu:

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

a poté:

addr2line -e main.out 0x400a74 0x400a79

dává:

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

takže linky jsou mimo jen o jeden, TODO proč? Ale to může být stále použitelné.

Závěr:zpětné stopy se mohou perfektně zobrazit pouze s -O0 . Pomocí optimalizací je původní zpětné sledování zásadně upraveno v kompilovaném kódu.

Nemohl jsem najít jednoduchý způsob, jak pomocí toho automaticky demastovat C++ symboly, nicméně zde jsou některé hacky:

• https://panthema.net/2008/0901-stacktrace-demangled/
• https://gist.github.com/fmela/591333/c64f4eb86037bb237862a8283df70cdfc25f01d3

Testováno na Ubuntu 16.04, GCC 6.4.0, libc 2.23.

glibc backtrace_symbols_fd

Tento pomocník je o něco pohodlnější než backtrace_symbols , a vytváří v podstatě identický výstup:

/* 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("");
}

Testováno na Ubuntu 16.04, GCC 6.4.0, libc 2.23.

glibc backtrace s C++ demangling hack 1:-export-dynamic + dladdr

Převzato z:https://gist.github.com/fmela/591333/c64f4eb86037bb237862a8283df70cdfc25f01d3

Toto je "hack", protože vyžaduje změnu ELF pomocí -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);
}

Kompilace a spuštění:

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 

výstup:

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]

Testováno na Ubuntu 18.04.

glibc backtrace s C++ demangling hack 2:parse backtrace output

Zobrazeno na:https://panthema.net/2008/0901-stacktrace-demangled/

Toto je hack, protože vyžaduje analýzu.

TODO jej zkompilujte a ukažte zde.

libunwind

TODO má to nějakou výhodu oproti glibc backtrace? Velmi podobný výstup, také vyžaduje úpravu příkazu build, ale není součástí glibc, takže vyžaduje instalaci dalšího balíčku.

Kód upraven z: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;
}

Kompilace a spuštění:

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

Buď #define _XOPEN_SOURCE 700 musí být nahoře, nebo musíme použít -std=gnu99 :

• Není již typ `stack_t` v linuxu definován?
• Glibc – chyba v ucontext.h, ale pouze s -std=c11

Spustit:

./main.out

Výstup:

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

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

a:

addr2line -e main.out 0x4007db 0x4007e2

dává:

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

S -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)

a:

addr2line -e main.out 0x4009f3 0x4009f8

dává:

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

Testováno na Ubuntu 16.04, GCC 6.4.0, libunwind 1.1.

libunwind s demanglováním názvu C++

Kód upraven z: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);
}

Kompilace a spuštění:

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

Výstup:

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)

a pak můžeme najít řádky my_func_2 a my_func_1(int) s:

addr2line -e unwind.out 0x400c80 0x400cb7

což dává:

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

TODO:proč jsou řádky o jeden posunuté?

Testováno na Ubuntu 18.04, GCC 7.4.0, libunwind 1.2.1.

Automatizace GDB

Můžeme to udělat také s GDB bez rekompilace pomocí:Jak provést konkrétní akci, když je v GDB zasažen určitý bod přerušení?

Ačkoli pokud budete tisknout backtrace hodně, bude to pravděpodobně méně rychlé než ostatní možnosti, ale možná můžeme dosáhnout nativní rychlosti s compile code , ale jsem líný to teď vyzkoušet:Jak volat shromáždění v 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

Kompilace a spuštění:

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

Výstup:

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 Chtěl jsem to udělat pouze s -ex z příkazového řádku, abyste nemuseli vytvářet main.gdb ale nemohl jsem získat commands pracovat tam.

Testováno v Ubuntu 19.04, GDB 8.2.

Linuxové jádro

Jak vytisknout aktuální trasování zásobníku vláken uvnitř linuxového jádra?

libdwfl

Toto bylo původně zmíněno na:https://stackoverflow.com/a/60713161/895245 a může to být nejlepší metoda, ale musím trochu více srovnávat, ale hlasujte pro tuto odpověď.

TODO:Snažil jsem se minimalizovat kód v té odpovědi, která fungovala, na jedinou funkci, ale je to segfaulting, dejte mi vědět, jestli někdo najde proč.

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

// https://stackoverflow.com/questions/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);   // line 122
        my_func_1(2.0); // line 123
    }
}

Kompilace a spuštění:

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

Potřebujeme také libunwind, protože výsledky jsou přesnější. Pokud se bez něj obejdete, běží, ale uvidíte, že některé řádky jsou trochu špatně.

Výstup:

0: 0x402b72 stacktrace[abi:cxx11]() at /home/ciro/test/dwfl.cpp:65
1: 0x402cda my_func_2() at /home/ciro/test/dwfl.cpp:100
2: 0x402d76 my_func_1(int) at /home/ciro/test/dwfl.cpp:111
3: 0x402dd1 main at /home/ciro/test/dwfl.cpp:122
4: 0x7ff227ea0d8f __libc_start_call_main at ../sysdeps/nptl/libc_start_call_main.h:58
5: 0x7ff227ea0e3f [email protected]@GLIBC_2.34 at ../csu/libc-start.c:392
6: 0x402534 _start at ../csu/libc-start.c:-1

0: 0x402b72 stacktrace[abi:cxx11]() at /home/ciro/test/dwfl.cpp:65
1: 0x402cda my_func_2() at /home/ciro/test/dwfl.cpp:100
2: 0x402d5f my_func_1(double) at /home/ciro/test/dwfl.cpp:106
3: 0x402de2 main at /home/ciro/test/dwfl.cpp:123
4: 0x7ff227ea0d8f __libc_start_call_main at ../sysdeps/nptl/libc_start_call_main.h:58
5: 0x7ff227ea0e3f [email protected]@GLIBC_2.34 at ../csu/libc-start.c:392
6: 0x402534 _start at ../csu/libc-start.c:-1

Spuštění benchmarku:

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

Výstup:

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

Vidíme tedy, že tato metoda je 10x rychlejší než stacktrace Boost, a proto by mohla být použitelná pro více případů použití.

Testováno v Ubuntu 22.04 amd64, libdw-dev 0.186, libunwind 1.3.2.

libbacktrace

https://github.com/ianlancetaylor/libbacktrace

Vzhledem k autorovi harcore knihovny to stojí za vyzkoušení, možná je to The One. TODO zkontrolujte.

Knihovna C, která může být propojena s programem C/C++ za účelem vytváření symbolických zpětných tras

Od října 2020 podporuje libbacktrace spustitelné soubory ELF, PE/COFF, Mach-O a XCOFF s informacemi o ladění DWARF. Jinými slovy, podporuje GNU/Linux, *BSD, macOS, Windows a AIX. Knihovna je napsána tak, aby bylo snadné přidat podporu pro jiné formáty objektových souborů a ladění.

Knihovna se spoléhá na C++ unwind API definované na https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html Toto API poskytuje GCC a clang.

Viz také

• Jak lze získat trasování zásobníku v C?
• Jak zajistit, aby backtrace()/backtrace_symbols() tiskla názvy funkcí?
• Existuje přenosný/standardně vyhovující způsob, jak získat názvy souborů a čísla řádků v trasování zásobníku?
• Nejlepší způsob, jak vyvolat gdb zevnitř programu pro tisk jeho stacktrace?
• automatické trasování zásobníku při selhání:
  • při výjimce C++:C++ zobrazí trasování zásobníku při výjimce
  • obecné:Jak automaticky vygenerovat stacktrace, když můj program spadne