GNU Debugger oder GDB: Ein leistungsstarkes Quellcode-Debugging-Tool für Linux-Programme

A debugger plays a vital role in any software development system. Nobody can write a bug-free code all at once. During the course of development, bugs are being raised and needs to be solved for further enhancement. A development system is incomplete without a debugger. Considering the open source developers community, GNU Debugger is their best choice. It is also used for commercial software development on UNIX type platforms.

GNU Debugger, auch bekannt als gdb, ermöglicht es uns, den Code zu durchsuchen, während er ausgeführt wird oder was ein Programm versuchte zu tun, bevor es abstürzte. GDB hilft uns im Grunde genommen, vier Hauptaufgaben zu erledigen, um Fehler im Quellcode zu finden.

1. Das Programm starten und Argumente festlegen, die das allgemeine Verhalten beeinflussen können.
2. Das Programm unter bestimmten Bedingungen stoppen.
3. Den Absturz untersuchen oder wenn das Programm gestoppt wurde.
4. Den Code ändern und mit dem modifizierten Code experimentieren.

Wir können gdb verwenden, um Programme in C und C++ ohne großen Aufwand zu debuggen. Derzeit ist die Unterstützung für andere Programmiersprachen wie D, Modula-2, Fortran teilweise vorhanden.

Erste Schritte mit dem GNU Debugger oder GDB

GDB wird durch den Befehl gdb aufgerufen. Beim Ausführen von gdb wird einige Informationen über die Plattform angezeigt und Sie in den (gdb)-Prompt wie unten gezeigt versetzt.

[root@fedora20 ~]# gdb

Beispielausgabe

GNU gdb (GDB) Fedora 7.6.50.20130731-19.fc20 
Copyright (C) 2013 Free Software Foundation, Inc. 
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> 
This is free software: you are free to change and redistribute it. 
There is NO WARRANTY, to the extent permitted by law.  Type "show copying" 
and "show warranty" for details. 
This GDB was configured as "x86_64-redhat-linux-gnu". 
Type "show configuration" for configuration details. 
For bug reporting instructions, please see: 
<http://www.gnu.org/software/gdb/bugs/>. 
Find the GDB manual and other documentation resources online at: 
<http://www.gnu.org/software/gdb/documentation/>. 
For help, type "help". 
Type "apropos word" to search for commands related to "word". 
(gdb)

Geben Sie help list ein, um die verschiedenen Klassen von Befehlen anzuzeigen, die in gdb verfügbar sind. Geben Sie help und anschließend einen Klassennamen ein, um eine Liste der Befehle in dieser Klasse zu erhalten. Geben Sie help all für die Liste aller Befehle ein. Befehlsnamenabkürzungen sind zulässig, wenn sie eindeutig sind. Sie können z.B. n anstelle von next oder c für continue und so weiter eingeben.

Am häufigsten verwendete GDB-Befehle

Die häufig verwendeten GDB-Befehle sind in der folgenden Tabelle aufgeführt. Diese Befehle sind von der gdb-Befehlszeile aus zu verwenden (gdb).

Beachten Sie den Unterschied zwischen den beiden Befehlen step und next. Der next-Befehl geht nicht in die Funktion, wenn die nächste Zeile ein Funktionsaufruf ist. Der step-Befehl kann jedoch in die Funktion gehen und sehen, was dort passiert.

A sample session with GDB

Betrachten Sie den folgenden Quellcode.

// sum.c
#include <stdio.h> 

int sum (int a, int b) { 
	int c; 
	c = a + b; 
	return c; 
} 

int main() { 
	int x, y, z; 
	printf("\nEnter the first number: "); 
	scanf("%d", &x); 
	printf("Enter the second number: "); 
	scanf("%d", &y); 
	z = sum (x, y); 
	printf("The sum is %d\n\n", z); 
	return 0; 
}

Um die Ausgabedatei zu debuggen, muss diese mit der Option -g an gcc wie folgt kompiliert werden.

$ gcc -g sum.c -o sum

Die Ausgabedatei sum kann auf zwei Arten an gdb angehängt werden:

1. Indem die Ausgabedatei als Argument an gdb angegeben wird.

$ gdb sum

2. Ausführung der Ausgabedatei innerhalb von gdb mithilfe des Befehls file.

$ gdb
(gdb) file sum

Der list-Befehl listet Zeilen in der Quellcodedatei auf und bewegt den Zeiger. So zeigt list zuerst die ersten 10 Zeilen an und das nächste list zeigt dann die nächsten 10 Zeilen und so weiter.

(gdb) list
1	#include <stdio.h>   
2	 
3	int sum (int a, int b) { 
4		int c; 
5		c = a + b; 
6		return c; 
7	} 
8	 
9	int main() { 
10		int x, y, z;

Zum Starten der Ausführung geben Sie den Befehl run ein. Nun wird das Programm normal ausgeführt. Aber wir haben vergessen, einige Breakpoints im Quellcode für das Debuggen zu setzen, nicht wahr? Diese Breakpoints können für Funktionen oder bestimmte Zeilen angegeben werden.

(gdb) b main

Hinweis: Ich habe die Abkürzung b für break verwendet.

Nachdem Sie einen Haltepunkt in der Hauptfunktion gesetzt haben, wird das erneute Ausführen des Programms an Zeile 11 stoppen. Das gleiche kann auch erreicht werden, wenn die Zeilennummer im Voraus bekannt ist.

(gdb) b sum.c:11

Jetzt schreiten Sie durch die Codezeilen mit dem next oder n Befehl. Es ist wichtig zu beachten, dass der next Befehl nicht in den Funktionscode geht, es sei denn, ein Haltepunkt wird in der Funktion festgelegt. Lassen Sie uns nun den print Befehl ausprobieren. Setzen Sie einen Haltepunkt in der Funktion sum wie unten beschrieben.

(gdb) b sum 
Breakpoint 1 at 0x4005aa: file sum.c, line 5. 
(gdb) r 
Starting program: /root/sum 

Enter the first number: 2 
Enter the second number: 3 

Breakpoint 1, sum (a=2, b=3) at sum.c:5 
5		c = a + b; 
(gdb) p a 
$1 = 2 
(gdb) p b 
$2 = 3
(gdb) c 
Continuing. 
The sum is 5 

[Inferior 1 (process 3444) exited normally]

Wenn das ausgeführte Programm Befehlszeilenparameter benötigt, geben Sie diese zusammen mit dem run Befehl an.

(gdb) run   . . .

Mit dem aktuellen laufenden Programm verknüpfte freigegebene Bibliotheksdateien können aufgelistet werden.

(gdb) info share 
From                To                  Syms Read   Shared Object Library 
0x00000035a6000b10  0x00000035a6019c70  Yes         /lib64/ld-linux-x86-64.so.2 
0x00000035a641f560  0x00000035a6560bb4  Yes         /lib64/libc.so.6

Variablen bearbeiten

GDB kann auch Variablen während der Programmausführung bearbeiten. Lassen Sie uns das ausprobieren. Wie oben erwähnt, setzen Sie einen Haltepunkt in Zeile 16 und führen Sie das Programm aus.

(gdb) r 
Starting program: /root/sum 

Enter the first number: 1 
Enter the second number: 2 

Breakpoint 1, main ( ) at sum.c:16 
16		printf("The sum is %d\n\n", z); 
(gdb) set z=4 
(gdb) c 
Continuing. 
The sum is 4

Jetzt ist a = 1, b = 2 und das Ergebnis sollte z = 3 sein. Aber hier haben wir das Endergebnis auf z = 4 in der Hauptfunktion geändert. Auf diese Weise kann das Debuggen mit gdb erleichtert werden.

Aktivieren/Deaktivieren von Haltepunkten

Um die Liste aller Haltepunkte zu erhalten, geben Sie info breakpoints ein.

(gdb) info breakpoints 
Num     Type           Disp Enb Address            What 
1       breakpoint     keep y   0x00000000004005c2 in main at sum.c:11

Hier gibt es nur einen Haltepunkt und er ist deaktiviert. Um Haltepunkte zu aktivieren oder zu deaktivieren, geben Sie die Haltepunktnummer zusammen mit dem disable Befehl an. Verwenden Sie nachfolgend den enable Befehl, um sie zu aktivieren.

(gdb) disable 1 
(gdb) info breakpoints 
Num     Type           Disp Enb Address            What 
1       breakpoint     keep n   0x00000000004005c2 in main at sum.c:11

Sie können auch die Unterbrechungen mit dem Befehl delete löschen.

Debuggen von laufenden Prozessen

In einem GNU/Linux-System werden zahlreiche Prozesse im Hintergrund ausgeführt. Um einen laufenden Prozess zu debuggen, müssen wir zunächst die Prozess-ID dieses bestimmten Prozesses finden. Der Befehl pidof gibt Ihnen die PID eines Prozesses.

$ pidof <process_name>

Jetzt müssen wir diese PID an gdb anhängen. Es gibt 2 Möglichkeiten.

1. Durch Angabe der PID zusammen mit gdb.

$ gdb -p <pid>

2. Verwendung des Befehls attach von gdb.

(gdb) attach <pid>

Das ist vorerst alles. Dies sind nur die Grundlagen von gdb, um mit dem Debuggen von Quellcode gut zu beginnen, und es ist viel mehr als die oben erklärten Dinge. Zum Beispiel können wir mit den Stack-Informationen, Umgebungsvariablen und vielem mehr debuggen. Versuchen Sie, mit all diesen Dingen herumzuspielen…