Benutzer-Werkzeuge

Webseiten-Werkzeuge


topics:gdb

GDB

GDB (GNU Debugger) ist ein weit verbreiteter Debugger für diverse Sprachen wie C, C++ und Java. GDB ist ein Kommandozeilen-Programm und lässt sich somit relativ einfach bedienen.

Wichtige Kommandos

Kommando Beschreibung
file Programm angeben zum debuggen
watch Variable beobachten
break Breakpunkt setzen
run Programm starten
continue Programm fortfahren
step nächsten Schritt ausführen (auch in Subroutinen)
next nächsten Schtitt ausführen (Subroutinen überspringen)
print Variableninhalt dezimal ausgeben
print/x Variableninhalt hexadezimal ausgeben
finish Programm laufen lassen bis Funktion beendet ist
delete Breakpunkt löschen
info breakpoints Informationen zu den gesetzten Breakpoints

Beispiel

Programmcode

|main.c
#include <stdio.h>                      /*  1 */
                                        /*  2 */
int main(int argv, char **argc)         /*  3 */
{                                       /*  4 */
        int a, b, c;                    /*  5 */
                                        /*  6 */
        c = 0;                          /*  7 */
        a = 5;                          /*  8 */
        b = 2;                          /*  9 */
                                        /* 10 */
        c += a;                         /* 11 */
        c += b;                         /* 12 */
                                        /* 13 */
        printf("%i", c);                /* 14 */
                                        /* 15 */
        return 0;                       /* 16 */
}                                       /* 17 */

Makefile

|Makefile
CFLAGS = -I. -lm -std=gnu11
SOURCES = main.c
 
.PHONY: all clean
 
main:
        gcc $(CFLAGS) -o main.o $(SOURCES)
 
debug:
        gcc $(CFLAGS) -g -o debug.o $(SOURCES) -DDEBUG
 
all:
        gcc $(CFLAGS) -o main.o $(SOURCES)
        gcc $(CFLAGS) -g -o debug.o $(SOURCES) -DDEBUG
 
clean:
        rm main.o
        rm debug.o

Compiler-Option

Um das obige main.c zu kompilieren könnte man gcc -o main.o main.c verwenden. Um aber das Debugging zu ermöglichen muss die Option -g hinzugefügt werden.

gcc -g -o debug.o main.c

GDB starten

Um das kompilierte Programm (debug.o) zu debuggen, kann einfach GDB gestartet werden in der Kommandozeile.

$ gdb

Datei laden

Ist GDB gestartet kann die datei debug.o angegeben werden zum debuggen.

(gdb) file debug.o
Reading symbols from debug.o...done.

Sollte eine Fehlermeldung auftreten wie die folgende

(gdb) file main.o
Reading symbols from main.o...(no debugging symbols found)...done.

sollte überprüft werden, ob die Compiler-Option -g gesetzt wurde beim kompilieren.

Breakpoint setzen

Um einen Breakpunkt zu setzten muss lediglich der Name der Quelldatei und die Zeilennummer angegeben werden. Das folgede Beispiel setzt einen Breakpunkt im main.c auf Zeile 7 und 12.

(gdb) break main.c:7
Breakpoint 1 at 0x400515: file main.c, line 5.
(gdb) break main.c:12
Breakpoint 2 at 0x400536: file main.c, line 12.

Programm starten

Möchte man das Programm starten so kann run ausgeführt werden.

(gdb) run

Das Kommando run startet das Programm, d.h. es sollte nicht nach einem Brekapoint verwendet werden.

Wendet man run auf das obige Beispiel an mit den gesetzten Breakpoints im main.c auf Zeile 7 und 12, so wird das Programm bei der Zeile 7 stehen bleiben.

(gdb) run
Starting program: /home/ninux/data/studium/mc/gdb/ex1/debug.o 
Got object file from memory but can't read symbols: File truncated.
warning: Could not load shared library symbols for linux-vdso.so.1.
Do you need "set solib-search-path" or "set sysroot"?
 
Breakpoint 1, main (argv=1, argc=0x7fffffffe9d8) at main.c:7
7		c = 0;

Weiterfahren nach Breakpoint

Ist das Programm stehen geblieben bei einem Breakpoint so kann man es weiter laufen lassen mittels step, next oder continue. continue läuft dabei einfach weiter bis wieder ein Breakpoint oder ähnliches erreicht wird. next und step dienen zum schrittweisen durchlaufen des Programms. Im Unterschied zu next geht step auch durch sämtliche Subroutinen durch, next dagegen behandelt Subroutinen wie einzelne Befehle.

(gdb) continue 
Continuing.
 
Breakpoint 2, main (argv=1, argc=0x7fffffffe9d8) at main.c:12
12		c += b;

Variableninhalt anzeigen

Um bei einem Breakpoint Variableninhalte anzeigen zu lassen, kann das Kommando print (dezimal) bzw. print/x (hexadecimal) verwendet werden. Das folgende Beispiel zeigt die Ausgabe für die Variablen c und a zur Zeile 12 aus main.c je einaml dezimal und einmal hexadezimal.

(gdb) print c
$1 = 5
(gdb) print/x c
$2 = 0x5
(gdb) print a
$3 = 5
(gdb) print/x a
$4 = 0x5

Info zu Breakpoints anzeigen

Um eine Übersicht der aktuellen Breakpoints zu erhalten kann das Kommando info breakpointsverwendet werden. Dieses listet sämtliche Breakpoints auf.

(gdb) info breakpoints 
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x0000000000400515 in main at main.c:7
2       breakpoint     keep y   0x0000000000400530 in main at main.c:12

Graphische front-ends

Ein bekanntes graphisches front-end für den GDB ist DDD. DDD verfügt über mehrere Teilfenster innerhalb der Anwendung, je eines für die GDB session, die aktuelle Quelldatei und optional noch diverse Grafiken. Wie bei bekannten IDEs werden auch hier Breakpoints und der aktuelle Standort in der Quelldatei graphisch angezeigt.

Literatur

  • GDB - kurz & gut, O'Reilly, ISBN 3-89721-512-8, im LuXeria verfügbar
topics/gdb.txt · Zuletzt geändert: 2014/11/15 21:13 von ninux