1 / 40

La pile un élément essentiel

La pile un élément essentiel. Merci Laurent JEANPIERRE. Contenu du cours. Définition Manipulations Appel de fonctions Gestion du résultat Gestion des variables Gestion des paramètres Exemple : Fibonacci Conclusion. Définition de la pile ( stack ). Structure de données Stratégie LIFO

yael
Download Presentation

La pile un élément essentiel

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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 d’assiettes. • 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 • ss:esp indique la dernière valeur empilée • Sur x86, elle croît à l’envers… • 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  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

  7. 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)

  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) esp • movl $0,%eax • pushl $0x01234567 • pushw $0x89AB Pile 00000000

  10. Exemple de manipulation de pile (2) esp esp • movl $0,%eax • pushl $0x01234567 • pushw $0x89AB Pile 0123 4567 9610

  11. Exemple de manipulation de pile (2) esp esp • pushl $0x01234567 • pushw $0x89AB • pushw $0xCDEF Pile 0123 4567 89AB 9410

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

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

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

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

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

  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 <label> • Empile EIP (compteur ordinal) • EIP label • La fonction s’exé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 structurestrè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 = a+5;} • 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 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 …

  27. 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…

  28. 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

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

  32. Cadre de pile (complet) ebp esp 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 ?)

  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 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

  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) ebp esp • 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

  36. 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:

  37. 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)

  38. 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

  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 »

More Related