La pile un

1
La pile un élément essentiel

• Merci Laurent JEANPIERRE

2
Contenu du cours

• Définition
• Manipulations
• Appel de fonctions
• Gestion du résultat
• Gestion des variables
• Gestion des paramètres
• Exemple Fibonacci
• Conclusion

3
Définition de la pile (stack)

• Structure de données
• Stratégie LIFO
• Last In First Out
• Dernier entré, premier sorti
• Analogie avec pile dassiettes.
• Mémoire de stockage
• Temporaire
• Stockage bien parenthésé
• ()()()

4
La pile en mémoire

• Zone de mémoire séparée
• Registre de segment spécifique
• SS Stack Segment
• Registre de position spécifique
• eSP (extended) Stack Pointer
• ssesp indique la dernière valeur empilée
• Sur x86, elle croît à lenvers
• Sommet_pile Base_pile

5
Contenu du cours

• Définition
• Manipulations
• Appel de fonctions
• Gestion du résultat
• Gestion des variables
• Gestion des paramètres
• Exemple Fibonacci
• Conclusion

6
Manipulations de la pile

• Trois possibilités
• Modification de eSP
• movl ebp,esp ebp ? esp
• addl 4,esp esp ? esp4
• Accès direct à la mémoire (voir cours sur modes
  dadressage)
• movw 4(esp), ax memesp4 ? ax
• Instructions spécifiques
• pushw, pushl
• popw, popl

7
Instructions spécifiques

• PUSH empiler
• Met une valeur sur la pile.
• Le registre esp diminue de la taille spécifiée
• Lopérande est stockée à ladresse (esp)
• POP dépiler
• Retire une valeur de la pile.
• Lopérande est remplie avec le contenu de
  ladresse (esp)
• Le registre esp augmente de la taille spécifiée
• Spécificité
• Pas dopération sur 1 octet (processeur 16 bits)

8
Exemple de manipulation de pile (1)

• movl 0,eax
• pushl 0x01234567
• pushw 0x89AB
• pushw 0xCDEF
• movb (esp),al
• popl ebx
• movw ax,1(esp)
• popl eax

9
Exemple de manipulation de pile (2)

• movl 0,eax
• pushl 0x01234567
• pushw 0x89AB

Pile
Registres Registres Registres
EAX EBX ESP
???????? 10010
00000000
10
Exemple de manipulation de pile (2)

• movl 0,eax
• pushl 0x01234567
• pushw 0x89AB

Pile
0123
4567
Registres Registres Registres
EAX EBX ESP
00000000 ???????? 10010
9610
11
Exemple de manipulation de pile (2)

• pushl 0x01234567
• pushw 0x89AB
• pushw 0xCDEF

Pile
0123
4567
89AB
Registres Registres Registres
EAX EBX ESP
00000000 ???????? 9610
9410
12
Exemple de manipulation de pile (2)

• pushw 0x89AB
• pushw 0xCDEF
• movb (esp),al

Pile
0123
4567
89AB
Registres Registres Registres
EAX EBX ESP
00000000 ???????? 9410
CDEF
9210
13
Exemple de manipulation de pile (2)

• pushw 0xCDEF
• movb (esp),al
• popl ebx

Pile
0123
4567
89AB
Registres Registres Registres
EAX EBX ESP
00000000 ???????? 9210
CDEF
000000EF
14
Exemple de manipulation de pile (2)

• movb (esp),al
• popl ebx
• movw ax, 1(esp)

Pile
0123
4567
89AB
Registres Registres Registres
EAX EBX ESP
000000EF ???????? 9210
CDEF
9610
89ABCDEF
15
Exemple de manipulation de pile (2)

• popl ebx
• movw ax, 1(esp)
• popl eax

Pile
0123
0100
4567
EF67
89AB
Registres Registres Registres
EAX EBX ESP
000000EF 89ABCDEF 9610
CDEF
16
Exemple de manipulation de pile (2)

• popl ebx
• movw ax,1(esp)
• popl eax

Pile
0100
EF67
89AB
Registres Registres Registres
EAX EBX ESP
000000EF 89ABCDEF 9610
CDEF
10010
0100EF67
17
Contenu du cours

• Définition
• Manipulations
• Appel de fonctions
• Gestion du résultat
• Gestion des variables
• Gestion des paramètres
• Exemple Fibonacci
• Conclusion

18
Appel de fonctions

• Programme structuré ? fonctions
• Exemple
• Fonction déplacer(Object o)
• Soulever(o)
• SeDéplacer()
• Poser(o)
• Fin
• Fonctions ? blocs bien parenthésés
• ? Utilisation naturelle de la pile

19
Appel de fonctions en assembleur

• Instruction call ltlabelgt
• Empile EIP (compteur ordinal)
• EIP ? label
• La fonction sexécute
• Instruction ret
• Dépile EIP
• Le programme principal reprend

20
Contenu du cours

• Définition
• Manipulations
• Appel de fonctions
• Gestion du résultat
• Gestion des variables
• Gestion des paramètres
• Exemple Fibonacci
• Conclusion

21
Le résultat de la fonction (1)

• Convention du langage C
• Le résultat est renvoyé dans EAX
• Parfait pour des entiers ou des adresses
• Inadapté pour le reste
• Le résultat est stocké temporairement
• Dans une pseudo-variable locale
• Dans la dernière variable allouée

22
Le résultat de la fonction (2)

• Valeurs plus petites (char, short)
• Extension à 32 bits.
• Attention au signe ! (unsigned char ? char)
• Valeurs plus grandes
• Par adresse (pointeur dans eax)
• Cas des structures très délicat.
• Valeurs flottantes (float, single, double)
• Dans st(0) (pile FPU, voir cours sur la FPU)

23
Contenu du cours

• Définition
• Manipulations
• Appel de fonctions
• Gestion du résultat
• Gestion des variables
• Gestion des paramètres
• Exemple Fibonacci
• Conclusion

24
Les variables

• Une fonction peut avoir des variables
• int main() int a 3 int b a5
• A et B sont locales à la fonction main
• Comment les mémoriser ?
• Sur le tas
• Sur la pile

25
Variables globales le tas

• .data
• a .long 3
• b .long 0
• .text
• main
• movl (a), eax
• addl 5, eax
• movl eax, (b)
• ret
• Très bien pour les variables globales
• Mais pour les fonctions récursives ?

26
Fonctions récursives

• Définition
• Une fonction est dite  récursive  si elle
  sappelle elle-même, ou si elle utilise une autre
  fonction qui lappelle (la 1ère).
• Exemple la suite de fibonacci
• Fibo(0) 0
• Fibo(1) 1
• Fibo(n) Fibo(n-1) Fibo(n-2) ?n2
• 0 1 1 2 3 5 8 13 21 34 55 89

27
Exemple2 Fibonacci

• int Fibo(int n)
• int a,b
• if (n0) return 0
• if (n1) return 1
• a Fibo(n-1)
• b Fibo(n-2)
• return ab
• Chaque appel de Fibo a des valeurs de a et de b
  différentes
• Impossible donc de les stocker en mémoire

28
Variables locales la pile

• La pile offre une mémoire
• Contextuelle
• Selon des blocs parenthésés
• ? Il suffit dy stocker les variables locales
• Problème
• ESP varie sans cesse
• Comment retrouver les variables ?
• Solution
• Le cadre de pile

29
Cadre de pile (ébauche)

• Utilisation du registre EBP
• Mémorise la base de la pile pour la fonction
  active
• Accès direct aux variables via EBP
• ? Un registre EBP pour chaque fonction
• ? Sauvegarde de la valeur précédente
• ? Sur la pile !
• Chaque fonction commence donc par
• Sauvegarde EBP
• Allocation du cadre de pile

30
Contenu du cours

• Définition
• Manipulations
• Appel de fonctions
• Gestion du résultat
• Gestion des variables
• Gestion des paramètres
• Exemple Fibonacci
• Conclusion

31
Les paramètres des fonctions

• Une fonction peut avoir des paramètres
• printf ("hello s!","World")
• Un paramètre une variable initialisée
• ? Géré comme une variable locale
• Mais
• Initialisé par lappelant
• A ce moment, pas encore de cadre de pile
• ? Position particulière dans le FUTUR cadre de
  pile

32
Cadre de pile (complet)

• Le cadre de pile contient donc
• Paramètres de fonction
• Par lappelant
• Adresse de retour
• Automatique (call)
• Sauvegarde EBP
• pushl ebp
• movl esp, ebp
• Variables Locales
• subl taille,esp

Paramètres (taille ?)
_at_ retour (32b)
Svg EBP (32b)
Var. Locales (taille ?)
33
Note spécifique 386 et plus

• La pile est alignée sur 32 bits
• Convention logicielle de gcc (et autres)
• Pas de justification matérielle
• ? Tout paramètre prend n32 bits !
• int/void ? 32 bits ? ok
• char/short ? 8/16 bits ? problème
• ? extension du signe ou bourrage si non signé
• ? création de variables locales de la bonne
  taille
• float/single ? 32 bits ? ok
• double ? 64 bits ? ok
• On ne sintéressera quaux multiples de 32 bits
• Reste ? Pas au programme

34
Contenu du cours

• Définition
• Manipulations
• Appel de fonctions
• Gestion du résultat
• Gestion des variables
• Gestion des paramètres
• Exemple Fibonacci
• Conclusion

35
Fibonacci, le résultat final (1)

• int fibo(int n)Locales int a,b,r
• _fibo
• sauvegarde EBP
• pushl ebp
• EBP lt- ESP
• movl esp, ebp
• Alloue 16 octets sur la pile
• subl 16, esp

n (int)
Paramètres
_at_retour
Contexte
EBP0
a (int)
Variables locales
b (int)
r (int)
(32b)
Spécial
36
Fibonacci, le résultat final (2)

• if n0
• cmpl 0, 8(ebp) compare 0 et n (EBP8)
• jne L10 saute si différent
• movl 0, -12(ebp) mets 0 dans r (EBP-12)
• jmp L9 saute à fin
• L10
• if n1
• cmpl 1, 8(ebp) compare 1 et n (EBP8)
• jne L11 saute si différent
• movl 1, -12(ebp) mets 1 dans r (EBP-12)
• jmp L9 saute à fin
• L11

37
Fibonacci, le résultat final (3)

• a fibo(n-1)
• movl 8(ebp), eax eax lt- n (EBP8)
• decl eax eax lt- eax-1
• movl eax, (esp) (ESP0) lt- eax
  Paramètre1 lt- n-1
• call _fibo appelle fibo résultat dans
  eax
• movl eax, -4(ebp) mets eax dans a (EBP-4)
• b fibo(n-2)
• movl 8(ebp), eax eax lt- n (EBP8)
• subl 2, eax eax lt- eax-2
• movl eax, (esp) (ESP0) lt- eax
• Paramètre1 n-2
• call _fibo appelle fibo res?eax movl eax,
  -8(ebp) mets eax dans b (EBP-8)

38
Fibonacci, le résultat final (4)

• r ab
• movl -8(ebp), eax eax lt- b (EBP-8)
• addl -4(ebp), eax eax lt- eax a (EBP-4)
• movl eax, -12(ebp) mets eax dans r (EBP-12)
• L9
• movl -12(ebp), eax eax lt- r(EBP12)
• movl ebp, esp esp lt- ebp
• popl ebp Restaure ebp
• ret fin
• Ou encore (autre solution)
• L9
• movl -12(ebp), eax eax lt- r(EBP12)
• leave Restaure le cadre de pile
• ret fin

39
Contenu du cours

• Définition
• Manipulations
• Appel de fonctions
• Gestion du résultat
• Gestion des variables
• Gestion des paramètres
• Exemple Fibonacci
• Conclusion

40
Conclusion

• La pile est un élément essentiel
• Sur TOUS les processeurs
• Du plus petit (microcontrôleur spécialisé)
• Au plus gros (serveur de calculs)
• Gestion identique
• Empile, Dépile, Registre  pointeur de pile 
• Notion de cadre de pile (avec des variantes)
• Maîtriser la pile (et le tas) permet de
• Comprendre les  segmentation faults 
• Eviter les  core dump