GNU Debugger of GDB: Een krachtige broncode-debuggingstool voor Linux-programma’s

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, ook bekend als gdb, stelt ons in staat om door de code te sluipen terwijl deze wordt uitgevoerd of te zien wat een programma probeerde te doen op het moment voordat het crashte. GDB helpt ons in feite om vier hoofdzaken te doen om fouten in de broncode op te sporen.

1. Het programma starten, met opgave van argumenten die het algemene gedrag kunnen beïnvloeden.
2. Het programma stoppen bij gespecificeerde voorwaarden.
3. Het onderzoeken van de crash of wanneer het programma was gestopt.
4. De code wijzigen en experimenteren met de aangepaste code onmiddellijk.

We kunnen gdb gebruiken om programma’s geschreven in C en C++ te debuggen zonder al te veel moeite. Momenteel zijn de ondersteuning voor andere programmeertalen zoals D, Modula-2, Fortran gedeeltelijk.

Aan de slag met GNU Debugger of GDB

GDB wordt geactiveerd met het gdb commando. Bij het invoeren van gdb, wordt wat informatie over het platform weergegeven en word je in de (gdb) prompt geplaatst zoals hieronder weergegeven.

[root@fedora20 ~]# gdb

Voorbeelduitvoer

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)

Type help list om de verschillende commandoklassen die beschikbaar zijn in gdb te bekijken. Typ help gevolgd door een klassenaam voor een lijst van commando’s in die klasse. Typ help all voor de lijst van alle commando’s. Commandonaamafkortingen zijn toegestaan als ze ondubbelzinnig zijn. Zo kun je bijvoorbeeld n typen in plaats van next of c voor continue enzovoort.

Meest gebruikte GDB-commando’s

Veelgebruikte gdb-commando’s staan in de volgende tabel. Deze commando’s moeten worden gebruikt vanaf de gdb-opdrachtprompt (gdb).

Let op het verschil tussen de twee commando’s step en next. Het next commando gaat niet naar binnen in een functie als de volgende regel een functieaanroep is. Daarentegen kan het step commando naar binnen gaan in een functie en zien wat daar gebeurt.

A sample session with GDB

Bekijk de volgende broncode.

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

Om het uitvoerbestand te debuggen moeten we hetzelfde compileren met de -g optie naar gcc als volgt.

$ gcc -g sum.c -o sum

Het uitvoerbestand sum kan aan gdb worden gekoppeld via een van de volgende 2 manieren:

1. Door het uitvoerbestand op te geven als argument voor gdb.

$ gdb sum

2. Het uitvoerbestand uitvoeren in gdb met het file commando.

$ gdb
(gdb) file sum

Het list commando geeft regels weer in het broncodebestand en verplaatst de cursor. Dus eerst list zal de eerste 10 regels weergeven en vervolgens list toont de volgende 10 en zo verder.

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

Om de uitvoering te starten, geef het run commando. Nu wordt het programma normaal uitgevoerd. Maar we zijn vergeten om wat breakpoints in de broncode te plaatsen voor het debuggen, toch? Deze breakpoints kunnen worden gespecificeerd voor functies of op aangegeven regels.

(gdb) b main

Opmerking: Ik heb een afkorting b gebruikt voor break.

Na het instellen van een breekpunt bij de hoofdfunctie, zal het opnieuw uitvoeren van het programma stoppen bij regel 11. Hetzelfde effect kan worden bereikt als het regelnummer van tevoren bekend is.

(gdb) b sum.c:11

Stap nu door de regels code met behulp van het volgende of n commando. Het is belangrijk op te merken dat het volgende commando niet naar binnen gaat in de functiecode, tenzij er een breekpunt is ingesteld in de functie. Laten we nu het afdruk commando proberen. Stel een breekpunt in bij functie sum zoals hieronder.

(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]

Als het uit te voeren programma commandoregelparameters vereist, geef deze dan mee met het run commando als volgt.

(gdb) run   . . .

Gedeelde bibliotheekbestanden die zijn gekoppeld aan het momenteel uitgevoerde programma, kunnen worden weergegeven als.

(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

Variabelen aanpassen

GDB is ook in staat variabelen aan te passen gedurende de uitvoering van het programma. Laten we dit proberen. Zoals hierboven vermeld, stel een breekpunt in bij regel 16 en voer het programma uit.

(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

Nu is a = 1, b = 2 en het resultaat zou z = 3 moeten zijn. Maar hier hebben we het uiteindelijke resultaat veranderd naar z = 4 in de hoofdfunctie. Op deze manier kan het debuggen gemakkelijker worden gemaakt met gdb.

Breekpunten in- of uitschakelen

Om de lijst met alle breekpunten te krijgen, typ info breekpunten.

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

Hier is slechts één breekpunt en deze is To. om breekpunten in of uit te schakelen, geef het breekpuntnummer op samen met het uitschakelen commando. Gebruik vervolgens het inschakelen commando om het later opnieuw in te schakelen.

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

Je kunt ook de onderbrekingen verwijderen met het delete commando.

Debuggen van lopende processen

Er draaien tal van processen op de achtergrond in een GNU/Linux systeem. Om een lopend proces te debuggen moeten we eerst het proces-id van dat specifieke proces vinden. pidof commando geeft je het pid van een proces.

$ pidof <process_name>

Nu moeten we dit pid aan gdb koppelen. Er zijn 2 manieren.

1. Door het pid samen met gdb op te geven.

$ gdb -p <pid>

2. Door het attach commando vanuit gdb te gebruiken.

(gdb) attach <pid>

Dat is alles voor nu. Dit zijn slechts de basisprincipes van gdb om een goede start te maken met het debuggen van broncode en het is veel meer dan de hierboven uitgelegde zaken. Bijvoorbeeld, we kunnen debuggen met behulp van de stackinformatie, omgevingsvariabelen en nog veel meer. Probeer te experimenteren met al deze zaken…