TP gdb

1. Introduction

gdb est un debugger symbolique, c'est-à-dire un utilitaire permettant de contrôler le déroulement de programmes C, C++, Pascal ou Fortran. gdb permet (entre autres) de mettre des points d'arrêt dans un programme, de visualiser l'état de sa pile d'exécution ou de ses variables, de calculer des expressions, d'appeler interactivement des fonctions, etc.

xxgdb est une interface graphique qui facilite l'utilisation de gdb sous X-Window. ddd est une autre variante, plus évoluée.

Enfin gdb peut être lancé depuis Emacs via le menu "Tools" ou en tapant sous emacs la commande suivante :

	ESC-X gdb

	ESC-X compile

Tout d'abord

Créer un nouveau répertoire et y copier les fichiers suivants :

• deux fichiers contenant du code source en C : tri.c et donnees.c
• deux fichiers en-têtes (ou "headers") contenant les déclarations correspondantes : tri.h et donnees.h
• un fichier Makefile contenant les règles nécessaires à la compilation des deux fichiers C et à la production de l'exécutable.
  (Attention : ce fichier contient des tabulations. Il ne faut pas le couper-coller mais passer par la commande de sauvegarde de fichier de votre navigateur)

Compilation

Les programmes C doivent être compilés avec le compilateur gcc avec l'option -g pour pouvoir être débuggés par gdb. Si on utilise un Makefile (comme c'est le cas ici), il faut que la macro CFLAGS contienne l'option -g.

Compiler les fichiers et créer l'exécutable en tapant la commande : make

Lancement de gdb

pour lancer le débogueur tapez dans le Terminal :

	xxgdb  nom-du-programme-à-debugger
   ou, sinon
	gdb  nom-du-programme-à-debugger

Si vous avez lancé xxgdb vous verrez apparaître sur l'écran une fenêtre xxgdb qui comprend deux ou trois zones de texte:

• celle du haut (la fenêtre source) sert à afficher le fichier courant
• celle du milieu (la fenêtre de commande) sert à taper des commandes gdb.
• celle du bas (la fenêtre de visualisation) sert à afficher le contenu de certaines variables. (Cette fenêtre n'est normalement pas visible au lancement de xxgdb).

On peut alors utiliser xxgdb de deux manières:

• soit en tapant des commandes dans la deuxième fenêtre.
• soit en cliquant sur les boutons situés entre la fenêtre source et la fenêtre de commande. Ces boutons ont le même effet que si les commandes étaient tapées en toutes lettres.

2. Utilisation de gdb

Lancer l'exécution

Pour lancer l'exécution du programme taper:

	run  arguments-du-programme

gdb exécute alors le programme comme s'il avait été lancé normalement. L'exécution se poursuit jusqu'à la fin du programme sauf:

• si l'on a mis des points d'arrêt (voir paragraphe suivant)
• s'il y a une erreur (un "bug") et que le programme plante
• si l'utilisateur tape ^C (touches CONTROL et C appuyées simultanément)

Tant que le programme "tourne", il n'est pas possible d'entrer de nouvelles commandes gdb (celles-ci ne seront effectuées que lorsque le programme s'arrêtera). gdb est alors en mode exécution. La seule façon de revenir en mode commande pendant l'exécution d'un programme est de taper ^C.

Exemple:

Points d'arrêt

Les points d'arrêt servent à interrompre l'exécution et à revenir au mode commande à un endroit donné du programme.

Pour s'arrêter au debut d'une fonction, faire :

         break  nom-de-la-fonction

Pour s'arrêter dans le corps d'une fonction faire:

         break  numéro-de-ligne

L'exécution sera alors interrompue juste avant cette ligne.

On peut :

• soit taper la commande en toutes lettres dans la fenêtre de commande,
• soit selectionner le nom de la fonction ou la ligne ou l'on veut s'arrêter dans la fenêtre source à l'aide de la souris, puis cliquer sur le bouton break.

Dans les deux cas un marqueur s'affiche alors dans la fenêtre source pour signaler la présence d'un point d'arrêt.

Contrôle de l'exécution

La commande:

• step exécute une ligne de code (i.e. la ligne pointée par la flèche)
• next fait de même mais en sautant les procédures ou fonctions
• cont continue jusqu'au prochain point d'arrêt

Relancer le programme en cliquant sur run et re-entrer les données. Le programme s'arrêtera à la même ligne que précédemment. Continuer l'exécution en utilisant cette fois la commande step. Que constate-t'on ?

Rajouter un point d'arrêt au debut de la fonction Trier et juste avant la deuxième boucle for de cette même fonction. Relancer l'exécution et faire de même que pécédemment mais en utilisant cette fois la commande cont.

Conclusions ?

Compléments sur les points d'arrêt

• Pour afficher la liste des points d'arrêt faire:

        info  breakpoints
  

  ou plus simplement:

        info  b
  

• Pour effacer un point d'arrêt faire:

        clear  numéro-de-ligne
  

  à l'aide du bouton clear (apres avoir sélectionné cette ligne à la souris) ou en tapant directement la commande.
• Pour mettre un point d'arrêt dans une fonction qui est dans un autre fichier que celui qui est affiché l'écran:
  • 1ère solution :
    - sélectionner et visualiser ce fichier en cliquant sur le bouton file et en choisissant dans une liste.
    - puis faire comme précédemment

  • 2eme solution : taper la commande :

          break  nom-du-fichier.c:nom-de-la-fonction
    

    (ne pas oublier le ".c" et le ":")

Visualisation des variables

Lorsque le programme est arrêté dans une fonction, on peut visualiser ses variables au moyen de la commande ou du bouton print.

On peut soit taper en toutes lettres :

	print  nom-de-la-variable

De manière plus générale, on peut afficher la valeur de n'importe quelle expression valide en C
Exemple : Dans la fonction Trier, afficher la valeur de:

     swap, items[1], i + j, items[i].nom, items[i].age, etc...

Attention : ces expressions n'ont de sens que si elles sont définies (par exemple la variable i n'est correctement initialisée qu'après la première boucle for).

Compléments:

• Pour afficher la valeur pointée par un pointeur faire :

        print*  nom-de-la-variable
  

• Pour afficher de manière permanente le contenu d'une variable ou d'une expression, faire:

        display  expression
  

  Le contenu de cette variable est alors affiché dans la fenêtre "de visualisation" . Cet affichage sera réactualisé jusqu'à ce que l'on fasse:

        undisplay  expression
  

• Enfin, le bouton locals permet d'afficher toutes les variables locales d'une fonction et le bouton args, ses arguments.

Visualiser (et se déplacer dans) la pile

La commande:

• where (ou le bouton stack) visualise la pile d'exécution, c'est-à-dire la liste des fonctions ou procédures empilées jusqu'à celle où l'on est momentanément arrêté. where affiche également les numéros de lignes correspondants.
• up permet de remonter dans la liste
• down permet de redescendre dans la liste

Exemple : On doit théoriquement se trouver dans la fonction Trier. Si ce n'est pas le cas, relancer l'exécution jusqu'a cette fonction. Cliquer sur le bouton where pour afficher la pile, puis utiliser les commandes up et down pour se déplacer dans la pile. Afficher les variables de la fonction Trier, puis celles de la fonction Choix, et enfin celles de la fonction main.

3. Interruptions

De même que les points d'arrêts, les interruptions arrêtent le déroulement du programme. Dans le cas qui nous interesse, celles-ci sont principalement de deux types :

• interruption utilisateur, provoquée lorsque l'on tape ^C
• interruptions système dues à une erreur dans le programme (Segmentation Fault, Bus Error, etc...)

Exemple : Relancer le programme et faire ^C au moment où le programme demande le premier nom. Afficher où l'on se trouve dans la pile à l'aide de la commande where ou du bouton stack.

Remarque: la commande cont permet alors de poursuivre l'exécution normalement.

4. Divers

Aide en ligne

Faire :

	help  nom-de-commande

Abréviations

De nombreuses commandes peuvent être abrégées. Par exemple:

        r  pour run
        b  pour break
        s  pour step
        n  pour next
        c  pour cont
        p  pour print
	etc ....

Recompilation

On peut recompiler le programme sans sortir de gdb en tapant directement sous gdb la commande:

	make

Appel interactif des fonctions

Les commandes :

	print  expression
	call  fonction(arguments)

permettent d'appeler interactivement les fonctions contenues dans le programme ainsi que la plupart des fonctions C des bibliothèques standard (comme par exemple "printf" etc...). Ceci peut-être très utile pour tester rapidement le comportement d'une fonction dans la mesure où l'on peut changer interactivement les arguments passés à cette fonction sans avoir à recompiler (surtout si l'on rajoute des points d'arrets dans cette fonction avant de l'appeler)

Exemple: Relancer le programme en tapant la commande :

	call  main()

Autres commandes utiles

• quit : sort de gdb
• list fonction : affiche cette fonction
• whatis : informations sur une variable ou une fonction
• tbreak : point d'arrêt temporaire
• delete no : enlève le point d'arrêt numéro no
• condition no condition : stop conditionnel: s'arrête quand la condition devient vraie
• ignore : "attrappe" (ignore) les signaux donnés en argument
• set var = expression : affectation de variable
• cd, pwd : comme sous Unix

Pour plus d'informations faire : help commande

5. Exercice

Le but de l'exercice est de compléter le programme tri.

a) Tri décroissant et alphabétique

Compléter le programme afin de permettre un tri alphabétique ou décroissant. (plusieurs solutions possibles) Comment faire pour n'avoir à définir qu'une seule fonction de tri ? (on pourra par exemple s'inspirer de la technique utilisée par la fonction standard qsort() en regardant le manuel interactif de cette fonction).

b) Vérification des entrées

• Vérifier la taille du nom et du prenom entrés (tronquer si trop de caractères)
• Vérifier que l'age est bien numérique (lire l'age sous forme alphabétique puis le tranformer en entier en utilisant la fonction atoi())

c) Mémoire dynamique

Généraliser le programme pour un nombre quelconque d'items : utiliser des pointeurs et les fonctions malloc(), realloc() et free().

d) Sauvegarde et relecture

Permettre de sauvergarder les données et de les relire dans un fichier.