Come fare in modo che backtrace () / backtrace_symbols () stampi i nomi delle funzioni?

Lo specifico per Linux backtrace()e backtrace_symbols()consente di produrre una traccia delle chiamate del programma. Tuttavia, stampa solo gli indirizzi delle funzioni, non i loro nomi per il mio programma. Come posso fare in modo che stampino anche i nomi delle funzioni? Ho provato a compilare il programma con -gcosì come -ggdb. Il test case seguente stampa solo questo:

    BACKTRACE ------------
    ./a.out () [0x8048616]
    ./a.out () [0x8048623]
    /lib/libc.so.6(__libc_start_main+0xf3) [0x4a937413]
    ./a.out () [0x8048421]
    ----------------------
    

Vorrei che i primi 2 elementi mostrassero anche i nomi delle funzioni fooemain

Codice:

#include <execinfo.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>

static void full_write(int fd, const char *buf, size_t len)
{
        while (len > 0) {
                ssize_t ret = write(fd, buf, len);

                if ((ret == -1) && (errno != EINTR))
                        break;

                buf += (size_t) ret;
                len -= (size_t) ret;
        }
}

void print_backtrace(void)
{
        static const char start[] = "BACKTRACE ------------\n";
        static const char end[] = "----------------------\n";

        void *bt[1024];
        int bt_size;
        char **bt_syms;
        int i;

        bt_size = backtrace(bt, 1024);
        bt_syms = backtrace_symbols(bt, bt_size);
        full_write(STDERR_FILENO, start, strlen(start));
        for (i = 1; i < bt_size; i++) {
                size_t len = strlen(bt_syms[i]);
                full_write(STDERR_FILENO, bt_syms[i], len);
                full_write(STDERR_FILENO, "\n", 1);
        }
        full_write(STDERR_FILENO, end, strlen(end));
    free(bt_syms);
}
void foo()
{
    print_backtrace();
}

int main()
{
    foo();
    return 0;
}

I simboli sono presi dalla tabella dinamica dei simboli; hai bisogno -rdynamicdell'opzione per gcc, che gli fa passare un flag al linker che assicura che tutti i simboli siano posizionati nella tabella.

(Vedere la pagina Opzioni di collegamento del manuale di GCC e / o la pagina Backtraces del manuale di glibc .)

Utilizzare il comando addr2line per mappare gli indirizzi eseguibili al codice sorgente nomefile + numero di riga. Dare la -fpossibilità di ottenere anche i nomi delle funzioni.

In alternativa, prova libunwind .

L'eccellente Libbacktrace di Ian Lance Taylor risolve questo problema. Gestisce lo svolgimento dello stack e supporta sia i simboli ELF ordinari che i simboli di debug DWARF.

Libbacktrace non richiede l'esportazione di tutti i simboli, il che sarebbe brutto, e ASLR non lo rompe.

Libbacktrace faceva originariamente parte della distribuzione GCC. Ora, una versione standalone può essere trovata su Github:

https://github.com/ianlancetaylor/libbacktrace

la risposta in alto ha un bug se ret == -1 e errno è EINTER dovresti riprovare, ma non contare ret come copiato (non creerai un account solo per questo, se non ti piace duro)

static void full_write(int fd, const char *buf, size_t len)
{
        while (len > 0) {
                ssize_t ret = write(fd, buf, len);

                if ((ret == -1) {
                        if (errno != EINTR))
                                break;
                        //else
                        continue;
                }
                buf += (size_t) ret;
                len -= (size_t) ret;
        }
}

Aumenta il backtrace

Molto comodo perché stampa sia:

• nomi di funzioni C ++ non confusi
• numeri di riga

automaticamente per te.

Riepilogo utilizzo:

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

std::cout << boost::stacktrace::stacktrace() << std::endl;

Ho fornito un esempio minimo eseguibile per questo e molti altri metodi su: print stack di chiamate in C o C ++