La pile

La pile Laurent JEANPIERRE <jeanpl@iutc3.unicaen.fr> D’après le cours de Pascal FOUGERAY IUT de CAEN – Campus 3 Département Informatique

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

Définition de la pile (stack) • Structure de données • Stratégie LIFO • Last In First Out • Dernier entré, premier sorti • Analogie avec pile d’assiettes. • Mémoire de stockage • Temporaire • Stockage bien parenthésé • [({}{}{})()({})][] Département Informatique

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 • ss:esp indique la dernière valeur empilée • Sur x86, elle croît à l’envers… • Sommet_pile ≤ Base_pile Département Informatique

Manipulations de la pile Trois possibilités : • Modification de eSP • movl %ebp,%esp # ebp  esp • addl $4,%esp # esp  esp+4 • Accès direct à la mémoire (voir cours sur modes d’adressage) • movw 4(%esp), %ax # mem[esp+4]  ax • Instructions spécifiques • pushw, pushl • popw, popl Département Informatique

Instructions spécifiques • PUSH = empiler • Met une valeur sur la pile. • Le registre esp diminue de la taille spécifiée • L’opérande est stockée à l’adresse (%esp) • POP = dépiler • Retire une valeur de la pile. • L’opérande est remplie avec le contenu de l’adresse (%esp) • Le registre esp augmente de la taille spécifiée • Spécificité : • Pas d’opération sur 1 octet (processeur 16 bits) Département Informatique

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 Département Informatique

esp Exemple de manipulation de pile (2) • movl $0,%eax • pushl $0x01234567 • pushw $0x89AB Pile 00000000 Département Informatique

esp esp Exemple de manipulation de pile (2) • movl $0,%eax • pushl $0x01234567 • pushw $0x89AB Pile 0123 4567 9610 Département Informatique

esp esp Exemple de manipulation de pile (2) • pushl $0x01234567 • pushw $0x89AB • pushw $0xCDEF Pile 0123 4567 89AB 9410 Département Informatique

esp esp Exemple de manipulation de pile (2) • pushw $0x89AB • pushw $0xCDEF • movb (esp),%al Pile 0123 4567 89AB CDEF 9210 Département Informatique

esp Exemple de manipulation de pile (2) • pushw $0xCDEF • movb (%esp),%al • popl %ebx Pile 0123 4567 89AB CDEF 000000EF Département Informatique

esp esp Exemple de manipulation de pile (2) • movb (esp),%al • popl %ebx • movw %ax, 1(%esp) Pile 0123 4567 89AB CDEF 89ABCDEF 9610 Département Informatique

esp Exemple de manipulation de pile (2) • popl %ebx • movw %ax, 1(%esp) • popl %eax Pile 0123 0100 4567 EF67 89AB CDEF Département Informatique

esp esp Exemple de manipulation de pile (2) • popl %ebx • movw %ax,1(%esp) • popl %eax Pile 0100 EF67 89AB CDEF 0100EF67 10010 Département Informatique

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 Département Informatique

Appel de fonctions en assembleur Instruction : call <label> • Empile EIP (compteur ordinal) • EIP label • La fonction s’exécute… Instruction : ret • Dépile EIP • Le programme principal reprend… Département Informatique

Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 3 9 96 3 Département Informatique

Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 10 3 Département Informatique

Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 3 100 3 Département Informatique

Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 7 4 Département Informatique

Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 13 96 4 5 8 Département Informatique

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 Département Informatique

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 structurestrès délicat. • Valeurs flottantes (float, single, double) • Dans st(0) (pile FPU, voir cours sur la FPU) Département Informatique

Les variables • Une fonction peut avoir des variables… • int main() { int a = 3; int b = a+5;} • A et B sont locales à la fonction main • Comment les mémoriser ? • Sur le tas • Sur la pile Département Informatique

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 ? Département Informatique

Fonctions récursives • Définition : • Une fonction est dite « récursive » si elle s’appelle elle-même, ou si elle utilise une autre fonction qui l’appelle (la 1ère). • Exemple : la suite de fibonacci • Fibo(0) = 0 • Fibo(1) = 1 • Fibo(n) = Fibo(n-1) + Fibo(n-2) n≥2 • 0 1 1 2 3 5 8 13 21 34 55 89 … Département Informatique

Exemple2 : Fibonacci int Fibo(int n) { int a,b; if (n==0) return 0; if (n==1) return 1; a = Fibo(n-1); b = Fibo(n-2); return a+b; } • Chaque appel de Fibo a des valeurs de a et de b différentes… • Impossible donc de les stocker en mémoire… Département Informatique

Variables locales : la pile • La pile offre une mémoire • Contextuelle • Selon des blocs parenthésés •  Il suffit d’y stocker les variables locales • Problème : • ESP varie sans cesse… • Comment retrouver les variables ? • Solution : • Le cadre de pile Département Informatique

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 Département Informatique

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 l’appelant • A ce moment, pas encore de cadre de pile •  Position particulière dans le FUTUR cadre de pile Département Informatique

ebp esp Cadre de pile (complet) Le cadre de pile contient donc : • Paramètres de fonction • Par l’appelant • Adresse de retour • Automatique (call) • Sauvegarde EBP • pushl %ebp • movl %esp, %ebp • Variables Locales • subl $taille,%esp Paramètres (taille ?) @ retour (32b) Svg EBP (32b) Var. Locales (taille ?) Département Informatique

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 n*32 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 s’intéressera qu’aux multiples de 32 bits • Reste  Pas au programme Département Informatique

ebp esp Fibonacci, le résultat final (1) • int fibo(int n)Locales : int a,b,r; _fibo: # sauvegarde EBP pushl %ebp # EBP <- ESP movl %esp, %ebp # Alloue 16 octets # sur lapile subl$16, %esp n (int) Paramètres @retour Contexte EBP0 a (int) Variables locales b (int) r (int) * (32b) Spécial Département Informatique

Fibonacci, le résultat final (2) # if n==0 cmpl$0, 8(%ebp) # compare 0 et n(EBP+8) jne L10 # saute si différent movl$0, -12(%ebp) # mets 0 dans r(EBP-12) jmp L9 # saute à fin L10: # if n==1 cmpl$1, 8(%ebp) # compare 1 et n(EBP+8) jne L11 # saute si différent movl$1, -12(%ebp) # mets 1 dans r(EBP-12) jmp L9 # saute à fin L11: Département Informatique

Fibonacci, le résultat final (3) # a = fibo(n-1) movl8(%ebp), %eax # eax <- n(EBP+8) decl %eax # eax <- eax-1 movl %eax, (%esp) # (ESP+0) <- eax# {Paramètre1 <- n-1} call _fibo # appelle fibo# {résultat dans eax} movl %eax, -4(%ebp) # mets eax dans a(EBP-4) # b = fibo(n-2) movl8(%ebp), %eax # eax <- n(EBP+8) subl$2, %eax # eax <- eax-2 movl %eax, (%esp) # (ESP+0) <- eax # {Paramètre1 =n-2} call _fibo # appelle fibo {reseax}movl %eax, -8(%ebp) # mets eax dans b(EBP-8) Département Informatique

Fibonacci, le résultat final (4) # r = a+b movl-8(%ebp), %eax # eax <- b(EBP-8) addl-4(%ebp), %eax # eax <- eax + a(EBP-4) movl %eax, -12(%ebp) # mets eax dans r(EBP-12) L9: movl-12(%ebp), %eax # eax <- r=(EBP+12) movl %ebp, %esp# %esp <- %ebp popl %ebp# Restaure ebp ret # fin • Ou encore… (autre solution) L9: movl-12(%ebp), %eax # eax <- r=(EBP+12) leave # Restaure le cadre de pile ret # fin Département Informatique

La pile

Télécharger la présentation

Plus de contenu associé