Kant1/French_Wikiversity_articles · Datasets at Hugging Face

text stringlengths 0 7.83k
Le code codice_1 lit une valeur juste un
peu devant l'allocation. Comme c'est la première allocation, elle est
en bordure de page et cela provoque instantanément un SEGFAULT.
Il est donc relativement aisé de trouver la source du
problème avec gdb en demandant simplement les valeurs des
variables.
Écrire un peu après la zone allouée.
Le code codice_5 écrit une
valeur juste un peu après l'allocation (un entier de 4 octets, 0 octet
après, donc juste après). Lors d'une exécution normale, il ne se passe
rien ! Il se termine parfaitement normalement. Mais le bug est bien
là. Valgrind est capable de le détecter.
Écrire loin au-delà de la zone allouée.
Dans le code codice_7
l'allocation est 4 fois trop petite. Beaucoup d'écritures
débordent. Néanmoins, la détection n'a lieu qu'au moment du free.
Valgrind sait détecter le problème. Mais si nous soupçonnons un
débordement en écriture, nous pouvons demander à gdb de surveiller
explicitement des modifications juste après notre allocation.
Cette technique est particulièrement utile lorsque quelque chose a
modifié une de vos structures de données: vous ne savez pas quoi ou
quand, mais vous savez où.



Débogage avancé/Travail pratique/Allocation dans la pile

But de ce TP.
Pour éviter le tourbillon de Charybde des allocations dynamique dans
le tas (heap), certains programmeurs aventureux ou programmeuses
aventureuses sont prêts à se jeter dans la gueule du monstre Scylla
des allocations dynamique dans la pile (stack).
Ils doivent alors de garantir que l'adresse de l'allocation ne sera
jamais utilisée après la fin de l'exécution de la fonction, puisque
cette fin va entrainer la libération automatique de l'allocation.
Côté débogage, le problème est que la pile est librement
manipulable. Il est possible d'y lire et d'y écrire partout ! Et du
coup tous les outils deviennent beaucoup plus difficiles à
exploiter.
Le code à déboguer.
Créer un fichier "bug_allocinstack.c" contenant le code suivant.
typedef struct elem {
struct elem *next;
} Elem;
// Patron commun en Python mais délétère en C
// NB: l'arithmétique sur les pointeurs suffit empêcher l'apparition de
// l'avertissement par le compilateur.
Elem *Elem_new() {
Elem a = {.next = NULL}; // BUG: Elem *a = malloc(sizeof(Elem));
Elem *p = &a;
p++; // pour tromper le linter de votre IDE
p--; // pour tromper le linter de votre IDE
return p; // BUG: return a;
int list_length(Elem *h) {
long long int l = 0;
while (h != NULL) {
h = h->next;
l++;
return l;
int main() {
Elem *a = Elem_new();
Elem *b = Elem_new();
a->next = b; // the code should fail here
Elem *head = a;
printf("list length: %d", list_length(head));
return EXIT_SUCCESS;
Les consignes.
Le code codice_1 reproduit un schéma
classique de la programmation en Python. Mais, pour allouer tous ses
objets, Python utilise le tas (malloc) ! Même si la syntaxe est
identique, Python ne fait pas du tout la même chose que ce code qui
crée son objet dans la pile de la fonction.



Débogage avancé/Outils d'aide au débogage et fondamentaux

= La diversité des outils =
La programmation et le débogage impliquent des successions d'actions réparties en plusieurs phases: l'écriture du programme; la compilation; l'exécution du programme. Des différentes techniques interviennent suivant les phases: l'analyse statique du code lors de la phase d'écriture ou de compilation; les tests unitaires; le débogage interactif; la vérification sémantique dynamique des accès mémoires.
= Les tests unitaires =
Écrire les tests unitaires pendant la rédaction des programmes fait partie des bonnes pratiques. Dans des langages récents comme Rust et Go, ils sont complètement intégrés dans les chaînes de fabrication d'un programme. De manière notable, directement, dans les commentaires du code, sous une forme complémentaire à la ("literate programming").
= Le compilateur =
Le compilateur (ou l'interpréteur) peut parfois détecter des aspects du code qui lui semble incohérents dans un cadre général, même si le code est valide du point de vue purement syntaxique.
Il est très important dans la phase de débogage de favoriser cette remontée d'information. Mais comme ces détections augmentent le temps de compilation, il faut les activer explicitement.
Les avertissements.
Il y a plusieurs niveaux dans la détection. Le mieux est d'en demander le plus possible.
$ gcc -g -Wall -Wextra ...
Néanmoins, pour un code déjà ancien et de taille importante, il est parfois difficile de refactoriser le code pour les éliminer. Mais plutôt que de ne demander aucun avertissement, il vaut mieux supprimer uniquement ceux dont vous avez vérifié l'inocuité.
$ gcc -g -Wall -Wextra -Wno-unused-result ...
L'analyseur statique.
L'analyseur statique du compilateur fera une analyse beaucoup plus fine de la totalité du code, et donc beaucoup plus coûteuse en temps. L'activation est différente, et complémentaire, des avertissements.
Pour gcc, c'est relativement simple
$ gcc -g -Wall -Wextra -fanalyzer ...
Pour clang, l'analyse statique et sa visualisation sont plus intrusives dans le processus de compilation.
$ scan-build clang ...
[... affiche le répertoire avec les résultats ...]
$ scan-view <répertoire avec les résultats>
La page web de l'analyseur statique de clang est https://clang-analyzer.llvm.org/ .
AddressSanitizer.
AddressSanitizer est une bibliothèque de détection d'erreurs mémoire à l'exécution du programme. Elle est relativement rapide et détecte de nombreuses erreurs. Par contre, il faut demander explicitement au compilateur de l'utiliser.

Le code codice_1 lit une valeur juste un

peu devant l'allocation. Comme c'est la première allocation, elle est

en bordure de page et cela provoque instantanément un SEGFAULT.

Il est donc relativement aisé de trouver la source du

problème avec gdb en demandant simplement les valeurs des

variables.

Écrire un peu après la zone allouée.

Le code codice_5 écrit une

valeur juste un peu après l'allocation (un entier de 4 octets, 0 octet

après, donc juste après). Lors d'une exécution normale, il ne se passe

rien ! Il se termine parfaitement normalement. Mais le bug est bien

là. Valgrind est capable de le détecter.

Écrire loin au-delà de la zone allouée.

Dans le code codice_7

l'allocation est 4 fois trop petite. Beaucoup d'écritures

débordent. Néanmoins, la détection n'a lieu qu'au moment du free.

Valgrind sait détecter le problème. Mais si nous soupçonnons un

débordement en écriture, nous pouvons demander à gdb de surveiller

explicitement des modifications juste après notre allocation.

Cette technique est particulièrement utile lorsque quelque chose a

modifié une de vos structures de données: vous ne savez pas quoi ou

quand, mais vous savez où.

Débogage avancé/Travail pratique/Allocation dans la pile

But de ce TP.

Pour éviter le tourbillon de Charybde des allocations dynamique dans

le tas (heap), certains programmeurs aventureux ou programmeuses

aventureuses sont prêts à se jeter dans la gueule du monstre Scylla

des allocations dynamique dans la pile (stack).

Ils doivent alors de garantir que l'adresse de l'allocation ne sera

jamais utilisée après la fin de l'exécution de la fonction, puisque

cette fin va entrainer la libération automatique de l'allocation.

Côté débogage, le problème est que la pile est librement

manipulable. Il est possible d'y lire et d'y écrire partout ! Et du

coup tous les outils deviennent beaucoup plus difficiles à

exploiter.

Le code à déboguer.

Créer un fichier "bug_allocinstack.c" contenant le code suivant.

typedef struct elem {

struct elem *next;

} Elem;

// Patron commun en Python mais délétère en C

// NB: l'arithmétique sur les pointeurs suffit empêcher l'apparition de

// l'avertissement par le compilateur.

Elem *Elem_new() {

Elem a = {.next = NULL}; // BUG: Elem *a = malloc(sizeof(Elem));

Elem *p = &a;

p++; // pour tromper le linter de votre IDE

p--; // pour tromper le linter de votre IDE

return p; // BUG: return a;

int list_length(Elem *h) {

long long int l = 0;

while (h != NULL) {

h = h->next;

l++;

return l;

int main() {

Elem *a = Elem_new();

Elem *b = Elem_new();

a->next = b; // the code should fail here

Elem *head = a;

printf("list length: %d", list_length(head));

return EXIT_SUCCESS;

Les consignes.

Le code codice_1 reproduit un schéma

classique de la programmation en Python. Mais, pour allouer tous ses

objets, Python utilise le tas (malloc) ! Même si la syntaxe est

identique, Python ne fait pas du tout la même chose que ce code qui

crée son objet dans la pile de la fonction.

Débogage avancé/Outils d'aide au débogage et fondamentaux

= La diversité des outils =

La programmation et le débogage impliquent des successions d'actions réparties en plusieurs phases: l'écriture du programme; la compilation; l'exécution du programme. Des différentes techniques interviennent suivant les phases: l'analyse statique du code lors de la phase d'écriture ou de compilation; les tests unitaires; le débogage interactif; la vérification sémantique dynamique des accès mémoires.

= Les tests unitaires =

Écrire les tests unitaires pendant la rédaction des programmes fait partie des bonnes pratiques. Dans des langages récents comme Rust et Go, ils sont complètement intégrés dans les chaînes de fabrication d'un programme. De manière notable, directement, dans les commentaires du code, sous une forme complémentaire à la ("literate programming").

= Le compilateur =

Le compilateur (ou l'interpréteur) peut parfois détecter des aspects du code qui lui semble incohérents dans un cadre général, même si le code est valide du point de vue purement syntaxique.

Il est très important dans la phase de débogage de favoriser cette remontée d'information. Mais comme ces détections augmentent le temps de compilation, il faut les activer explicitement.

Les avertissements.

Il y a plusieurs niveaux dans la détection. Le mieux est d'en demander le plus possible.

$ gcc -g -Wall -Wextra ...

Néanmoins, pour un code déjà ancien et de taille importante, il est parfois difficile de refactoriser le code pour les éliminer. Mais plutôt que de ne demander aucun avertissement, il vaut mieux supprimer uniquement ceux dont vous avez vérifié l'inocuité.

$ gcc -g -Wall -Wextra -Wno-unused-result ...

L'analyseur statique.

L'analyseur statique du compilateur fera une analyse beaucoup plus fine de la totalité du code, et donc beaucoup plus coûteuse en temps. L'activation est différente, et complémentaire, des avertissements.

Pour gcc, c'est relativement simple

$ gcc -g -Wall -Wextra -fanalyzer ...

Pour clang, l'analyse statique et sa visualisation sont plus intrusives dans le processus de compilation.

$ scan-build clang ...

[... affiche le répertoire avec les résultats ...]

$ scan-view <répertoire avec les résultats>

La page web de l'analyseur statique de clang est https://clang-analyzer.llvm.org/ .

AddressSanitizer.

AddressSanitizer est une bibliothèque de détection d'erreurs mémoire à l'exécution du programme. Elle est relativement rapide et détecte de nombreuses erreurs. Par contre, il faut demander explicitement au compilateur de l'utiliser.