GDB-Dashboard est une extension Python pour le débogueur GDB. Elle transforme l'interface en ligne de commande en un tableau de bord modulaire et visuel, améliorant considérablemetn l'efficacité du débogage en consolidant les informations critiques.

Prérequis et configuration initiale

Assurez-vous d'avoir installé GDB (version 7.0 ou supérieure) et Python 3.x sur votre système.

# Vérification des versions
gdb --version
python3 --version

L'installation de la bibliothèque Pygments est optionnelle mais fortement recommandée pour obtenir une coloration syntaxique de qualité.

# Installation via pip
pip3 install pygments

Architecture modulaire

Le cœur de l'outil repose sur des modules indépendants. Chaque module est un panneau d'affichage pour une information spécifique. Par défaut, une dizaine de modules est disponible.

L'ensemble des modules est contrôlé via une série de sous-commandes dashboard. L'interface se rafraîchit automatiquement à chaque interruption du programme (point d'arrêt, crash).

Procédure d'installation

L'installation se fait en récupérant un seul fichier de configuration. La méthode la plus directe consiste à le télécharger dans le répertoire personnel de l'utilisateur.

# Téléchargement du fichier de configuration
curl -o ~/.gdbinit https://github.com/cyrus-and/gdb-dashboard/raw/master/.gdbinit

# Alternative avec wget
wget -O ~/.gdbinit https://github.com/cyrus-and/gdb-dashboard/raw/master/.gdbinit

Après le téléchargement, lancez GDB sur un exécutable compilé avec les symboles de débogage (-g). Une confirmation peut être demandée pour charger le fichier .gdbinit.

# Compilation d'un programme exemple avec les symboles
gcc -g -O0 mon_programme.c -o mon_programme
# Lancement de GDB
gdb ./mon_programme

Utilisation de base

Au sein de l'invite GDB, la commande dashboard --help offre une liste complète des options. Le tableau de bord s'affiche normalement dès qu'une interruption se produit.

# Activer l'affichage automatique à chaque interruption
dashboard -t on
# Désactiver un module spécifique
dashboard -d memory
# Afficher un module particulier
dashboard -e threads

Un flux de débogage typique devient :

1. Lancer GDB sur l'exécutable.
2. Placer un point d'arrêt (b fonction).
3. Exécuter le programme (r). Le tableau de bord apparaît à l'arrêt.
4. Avancer pas à pas (n ou s). Les informations (variables, registres) se mettent à jour en temps réel.

Personnalisation avancée

Les préférences peuvent être persistées en ajoutant des directives à la fin du fichier ~/.gdbinit.

# Activer les couleurs et définir un thème de coloration
dashboard ansi on
dashboard syntax-highlighting monokai

# Spécifier l'ordre des modules affichés
dashboard layout source backtrace registers expressions

# Activer l'affichage automatique par défaut
dashboard -t on

Pour des besoins plus spécifiques, il est possible d'attacher des scripts Python aux événements de GDB. Par exemple, pour forcer un affichage à chaque arrêt.

python
import gdb
gdb.events.stop.connect(lambda e: gdb.execute("dashboard --show"))
end

Scénario pratique : Analyse d'une fuite mémoire

Considérons un programme C simple (leak.c) avec une fuite intentionnelle.

// leak.c
#include <stdlib.h>

void allocate_and_forget() {
    int *data = malloc(100 * sizeof(int));
    // Pas de free(data) ici
}

int main() {
    for (int i = 0; i < 5; i++) {
        allocate_and_forget();
    }
    return 0;
}

Étapes de débogage avec le tableau de bord :

1. Compiler : gcc -g -O0 leak.c -o leak.
2. Lancer : gdb ./leak.
3. Activer le module mémoire : dashboard -e memory.
4. Placer un point d'arrêt : b allocate_and_forget.
5. Exécuter : r. À l'arrêt, le module source montre la fonction, et expressions peut surveiller le pointeur data.
6. Utiliser finish pour sortir de la fonction et observer que la mémoire allouée n'est pas libérée dans l'historique des appels et des allocations.

Dépannage courant

• Le tableau de bord ne s'affiche pas : Vérifiez la présence et les permissions du fichier ~/.gdbinit. Confirmez son chargement au démarrage de GDB.
• Pas de coloration syntaxique : Installez Pygments (pip install pygments).
• Interface graphique corrompue : Votre terminal peut ne pas supporter les séquences ANSI. Essayez dashboard ansi off ou utilisez un terminal moderne.
• Conflit avec d'autres outils (ex: cgdb) : Ne chargez pas simultanément plusieurs interfaces visuelles de GDB.

Exercices pratiques

1. Affichage minimal : Configurez GDB-Dashboard pour n'afficher que les modules source et backtrace. Déboguez un programme simple et observez la pile d'appels lors d'un crash.
2. Inspection des registres : Activez le module registers. Placez un point d'arrêt dans une fonction mathématique et observez l'évolution des registres pendant l'exécution pas à pas.
3. Surveillance de variable : Utilisez le module expressions pour ajouter une variable locale au suivi. Modifiez sa valeur manuellement et voyez le tableau de bord se mettre à jour.

Ressources complémentaires

• Dépôt GitHub officiel : Contient la documentation, le code source et des exemples.
• README du projet : Explications détaillées sur chaque commande et personnalisation.
• Documentation officielle de GDB : Indispensable pour maîtriser le débogueur sous-jacent.