Wie kann backtrace()/backtrace_symbols() die Funktionsnamen drucken?

Das Linux-spezifische backtrace() und backtrace_symbols() ermöglicht es Ihnen, eine Aufrufverfolgung des Programms zu erstellen. Es gibt jedoch nur Funktionsadressen aus, nicht ihre Namen für mein Programm. Wie kann ich sie dazu bringen, auch die Funktionsnamen zu drucken? Ich habe versucht, das Programm mit zu kompilieren -g ebenso gut wie -ggdb. Der folgende Testfall gibt nur Folgendes aus:

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

Ich möchte, dass die ersten 2 Elemente auch die Funktionsnamen anzeigen, foo und main

Code:

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

Die Symbole werden der dynamischen Symboltabelle entnommen; du brauchst die -rdynamic Option zu gccwodurch ein Flag an den Linker übergeben wird, der dies sicherstellt alle Symbole werden in der Tabelle platziert.

(Siehe die Link-Optionen Seite der GCC-Handbuchund / oder die Rückverfolgungen Seite der glibc-Handbuch.)

Verwenden Sie die addr2line-Befehl um ausführbare Adressen auf den Quellcode Dateiname+Zeilennummer abzubilden. Gib die -f Option, um auch Funktionsnamen zu erhalten.

Alternativ versuchen Libunwind.

Das hervorragende Libbacktrace von Ian Lance Taylor löst dieses Problem. Es handhabt das Stack-Unwinding und unterstützt sowohl gewöhnliche ELF-Symbole als auch DWARF-Debugging-Symbole.

Libbacktrace erfordert nicht den Export aller Symbole, was hässlich wäre, und ASLR bricht es nicht.

Libbacktrace war ursprünglich Teil der GCC-Distribution. Jetzt ist eine Standalone-Version auf Github zu finden:

https://github.com/ianlancetaylor/libbacktrace

Die Antwort oben hat einen Fehler, wenn ret == -1 und errno EINTER ist, sollten Sie es erneut versuchen, aber ret nicht als kopiert zählen (werden nur dafür keinen Account erstellen, wenn Sie es nicht hart mögen)

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

Backtrace verstärken

Sehr praktisch, weil es beides druckt:

• unverfälschte C++-Funktionsnamen
• Linien Nummern

automatisch für Sie.

Zusammenfassung der Verwendung:

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

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

Ich habe ein minimales lauffähiges Beispiel dafür und viele andere Methoden bereitgestellt unter: print call stack in C or C++