GDB

GDB (GNU Debugger) est un outil qui te permet d'exécuter ton programme en mode ralenti, de l'arrêter à n'importe quelle ligne, d'inspecter les variables, la mémoire et la pile d'appels. C'est ton meilleur allié contre les segfaults et les bugs impossibles à trouver avec des printf.

# Lancer GDB avec ton programme
gdb ./prog

# Lancer avec des arguments (argv)
gdb --args ./prog arg1 arg2

# Lancer et exécuter directement (sans prompt interactif)
gdb -batch -ex run ./prog

# Analyser un core dump (fichier de crash)
gdb ./prog core

# Mode quiet (sans le message de bienvenue)
gdb -q ./prog

GNU gdb (Ubuntu 12.1) 12.1
Reading symbols from ./prog...
(gdb) ← le prompt GDB, tu peux taper tes commandes ici

# ── PRINT (p) — afficher une valeur ────────────────────

(gdb) print i                  # p i — valeur de la variable i
$1 = 42

(gdb) print ptr               # afficher un pointeur
$2 = (int *) 0x602260

(gdb) print *ptr              # déréférencer — valeur pointée
$3 = 7

(gdb) print str               # afficher une string
$4 = 0x402010 "Hello"

(gdb) print arr[3]            # valeur à l'index 3 d'un tableau
(gdb) print node->n           # champ d'une struct via pointeur
(gdb) print 2 + 2             # GDB peut évaluer des expressions

# ── FORMATS D'AFFICHAGE ─────────────────────────────────

(gdb) print/x i               # en hexadécimal
$5 = 0x2a
(gdb) print/d i               # en décimal (défaut)
(gdb) print/b i               # en binaire
(gdb) print/c 65              # comme caractère → 'A'
(gdb) print/s ptr             # comme string (char*)
(gdb) print/f x               # comme float

# Voir un registre précis
(gdb) print $rip       # adresse de l'instruction courante
(gdb) print $rax       # valeur de retour (après un call)
(gdb) info registers   # tous les registres d'un coup

# Ton programme crash → lancer GDB
gdb ./prog

(gdb) run
Program received signal SIGSEGV, Segmentation fault.
0x0000000000401145 in ft_strlen (str=0x0) at ft_strlen.c:7
7           while (*str)

# → Le crash est à ft_strlen.c ligne 7, str vaut 0x0 (NULL) !

# Voir la pile d'appels pour comprendre qui a appelé ft_strlen
(gdb) backtrace
#0  ft_strlen (str=0x0) at ft_strlen.c:7      ← la fonction crashée
#1  0x00401165 in main () at main.c:12         ← main a appelé ft_strlen

# Aller dans main pour voir ce qui a été passé
(gdb) frame 1
(gdb) info locals
str = 0x0                                      ← str est NULL ! Voilà le bug.

# Checklist quand tu vois un segfault :
# 1. run → lire le message d'erreur (fichier + ligne)
# 2. backtrace → voir la chaîne d'appels
# 3. frame N → aller dans chaque frame
# 4. info locals / print VAR → trouver la valeur invalide

╔══════════════════════════════════════════════════════════════════╗
║  ÉTAPE 0 — TOUJOURS compiler avec -g                             ║
╚══════════════════════════════════════════════════════════════════╝
gcc -g -Wall -Werror -Wextra main.c -o prog

╔══════════════════════════════════════════════════════════════════╗
║  FACE À UN CRASH (segfault, etc.)                                ║
╚══════════════════════════════════════════════════════════════════╝
gdb ./prog
(gdb) run                    # laisser crasher
(gdb) backtrace              # voir où et comment
(gdb) info locals            # inspecter les variables locales
(gdb) frame 1               # remonter d'un niveau

╔══════════════════════════════════════════════════════════════════╗
║  POUR TRACER L'EXÉCUTION LIGNE PAR LIGNE                         ║
╚══════════════════════════════════════════════════════════════════╝
(gdb) break main            # pause au début
(gdb) run
(gdb) display ma_var        # surveiller une variable
(gdb) next                   # [Entrée] pour répéter

╔══════════════════════════════════════════════════════════════════╗
║  RÈGLES D'OR GDB                                                 ║
╚══════════════════════════════════════════════════════════════════╝
# ✅ Toujours compiler avec -g avant de lancer GDB
# ✅ Lancer GDB avec -tui pour voir le code en temps réel
# ✅ Commencer par backtrace (bt) sur tout crash
# ✅ Utiliser info locals pour voir toutes les variables
# ✅ Utiliser print *ptr pour inspecter une struct entière
# ✅ Utiliser display pour surveiller une var dans une boucle
# ✅ Ctrl+C pour interrompre une boucle infinie
# ✅ Utiliser break conditionnel si la boucle a 1000 itérations
# ✅ Combiner GDB + Valgrind pour les bugs mémoire (double free...)
# ✅ Entrée vide = répéter → avancer vite
# ❌ Ne pas utiliser GDB sans -g → tu vois que des adresses hex
# ❌ Ne pas confondre next (reste dans la fonction) et step (y entre)