1 / 52

La pile

La pile. Laurent JEANPIERRE <jeanpl@iutc3.unicaen.fr> D’après le cours de Pascal FOUGERAY IUT de CAEN – Campus 3. Contenu du cours. Définition Manipulations Appel de fonctions Gestion du résultat Gestion des variables Gestion des paramètres Exemple : Fibonacci Conclusion.

kiana
Download Presentation

La pile

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 Laurent JEANPIERRE <jeanpl@iutc3.unicaen.fr> D’après le cours de Pascal FOUGERAY IUT de CAEN – Campus 3 Département Informatique

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

  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é • [({}{}{})()({})][] Département Informatique

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  23. Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 6 96 3 4 Département Informatique

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

  25. Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 15 92 4 8 Département Informatique

  26. Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 16 4 8 Département Informatique

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

  28. Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 4 100 4 8 Département Informatique

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

  30. Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 14 5 8 Département Informatique

  31. Deplacer: call Soulever call Bouger call Poser ret Bouger: call Marcher ret Soulever: … ret Bouger: … ret Poser: … ret Marcher:… ret Appel de fonctions : exemple 5 100 5 8 Département Informatique

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

More Related