TP 3 : Manipulation de la pile


L'objectif

Le but de ce tp est de vous montrer le principe d’une pile, sa gestion et de voir où se trouvent les différentes données d’un programme. En même temps, on va voir la taille mémoire occupée par différentes données déclarées initialisées ou non.
Vous pourrez aussi remarquer le codage des nombres négatifs, et voir que le microprocesseur utilise le complément à 2, comme nous l'avons vu lors d'un Td du premier semestre.

Le temps imparti

1h30

Le sujet

La pile est une zone mémoire dans laquelle il est possible de stocker des données temporaires. Dans les deux Tp précédents, vous avez dû remarquer dans les différents sources des programmes que les mêmes lignes de code se trouvaient toujours en début de code source :

  1. pushl %ebp
  2. movl %esp,%ebp

En fin de source, on trouve également :

  1. movl %ebp,%esp
  2. popl %ebp
  3. ret

A faire

Saisir le programme suivant, écrit en langage C, que vous devez comprendre assez facilement.

Pile.c
  1. /* Déclaration des variables globales */
  2. char a,b;
  3. unsigned char c,d;
  4. short e;
  5. unsigned short f;
  6. short g=;
  7. int h,i;
  8. long j;
  9. double k;
  10. int main()
  11. {
  12. /* Déclaration des variables locales */
  13. char ma,mb;
  14. unsigned char mc;md;
  15. short me = 12;
  16. unsigned short mf;
  17. short mg;
  18. int mh,mi;
  19. long mj;
  20. double mk=2,5;
  21. /* Quelques instructions quand même... */
  22. a=ma; b=mb; c=mc; d=md; e=me; f=mf;
  23. g=mg; h=mh; i=mi; j=mj; k=mk;
  24. mg=-5
  25. return 0;
  26. }

Traduisez-le en langage d’assemblage en tapant la commande:

$gcc -Wall -S pile.c

Notez l'utilisation de -Wall qui demande au compilateur C de vous donner des avertissements supplémentaires.
Utilisation recommandée pour TOUTE compilation d'un code C

Visualiser le fichier source en langage d’assemblage.
Faire le dessin de la pile et de l'occupation mémoire.
Conclure sur la taille des différents types.

Changer l’ordre des déclarations de variables (par exemple mettre mh entre mb et mc) de façon à ne pas les avoir déclarées en ordre de taille croissante.
Le traduire en langage d’assemblage.
Visualiser le fichier source en langage d’assemblage.
Faire le dessin de la pile et de l'occupation mémoire.

Desassembler le fichier objet :

$objdump -d pile.s > pile.dis

Constater le codage des nombres négatifs.

Remplacer les lignes int h et int mh respectivement par static int h et static int mh.
Recommencer l’étude précédente et conclure.


Nous allons approfondir un peu notre connaissance sur la pile.
Pour cela je vous invite à saisir le programme suivant :

Pile2.c
  1. int a;
  2. main()
  3. {
  4. int b;
  5. a = appel_fonction(b);
  6. return 0;
  7. }
  9. int appel_fonction(int c)
  10. {
  11. int d;
  12. d = c;
  13. return(d);
  14. }

Ce programme contient deux fonctions, main et appel_fonction.
Sachant que le compilateur C lit votre programme de haut en bas (dans ce sens), expliquer l'avertissement obtenu pendant la compilation.

Après traduction en langage d’assemblage, on récupère le source suivant :

Pile2.s
  1. main:
  2. pushl %ebp
  3. movl %esp, %ebp
  4. subl $8, %esp
  5. andl $-16, %esp
  6. movl $0, %eax
  7. subl %eax, %esp
  8. movl -4(%ebp), %eax
  9. movl %eax, (%esp)
  10. call appel_fonction
  11. movl %eax, a
  12. movl $0, %eax
  13. leave
  14. ret
  16. appel_fonction:
  17. pushl %ebp
  18. movl %esp, %ebp
  19. subl $4, %esp
  20. movl 8(%ebp), %eax
  21. movl %eax, -4(%ebp)
  22. movl -4(%ebp), %eax
  23. leave
  24. ret

Analyser le programme pile2.c de façon à comprendre pile2.s.
Donner le nombre de cadres de piles que le programme pile2.s contient,
Expliquer chaque ligne du source assembleur.
Dessiner la zone mémoire de ce programme.

Optimiser le programme pile2.s (option O3) en tapant la commande :

$gcc S -O3 pile2.c -o pile2.opt.s

Vous devez obtenir un source optimisé, et donc beaucoup plus simple, donc plus facile à analyser.
Expliquer chaque ligne du source assembleur.
Dessiner la zone mémoire de ce programme.