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 Last In First Out Dernier entré, premier sorti Analogie avec pile d’assiettes. Mémoire de stockage Temporaire Stockage bien parenthésé [({}{}{})()({})][]

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

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

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)

Exemple de manipulation de pile (1)
movl $0,%eax pushl $0x pushw $0x89AB pushw $0xCDEF movb (%esp),%al popl %ebx movw %ax,1(%esp) popl %eax

movl $0,%eax pushl $0x pushw $0x89AB Pile esp Registres EAX EBX ESP ******** ???????? 10010

movl $0,%eax pushl $0x pushw $0x89AB Pile esp 0123 4567 esp Registres EAX EBX ESP ???????? 10010 9610

pushl $0x pushw $0x89AB pushw $0xCDEF Pile 0123 4567 esp 89AB esp Registres EAX EBX ESP ???????? 9610 9410

pushw $0x89AB pushw $0xCDEF movb (esp),%al Pile 0123 4567 89AB esp Registres EAX EBX ESP ???????? 9410 CDEF esp 9210

pushw $0xCDEF movb (%esp),%al popl %ebx Pile 0123 4567 89AB Registres EAX EBX ESP ???????? 9210 CDEF esp 000000EF

movb (esp),%al popl %ebx movw %ax, 1(%esp) Pile 0123 4567 esp 89AB Registres EAX EBX ESP 000000EF ???????? 9210 CDEF esp 89ABCDEF 9610

popl %ebx movw %ax, 1(%esp) popl %eax Pile 0100 0123 EF67 4567 esp 89AB Registres EAX EBX ESP 000000EF 89ABCDEF 9610 CDEF

popl %ebx movw %ax,1(%esp) popl %eax Pile esp 0100 EF67 esp 89AB Registres EAX EBX ESP 000000EF 89ABCDEF 9610 CDEF 0100EF67 10010

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

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…

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

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)

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

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 ?

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 …

Exemple2 : Fibonacci int Fibo(int n) { int a,b; if (n==0) return 0;
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…

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

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

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

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) ebp Var. Locales (taille ?) esp

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

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 la pile subl $16, %esp n (int) Paramètres @retour Contexte EBP0 ebp a (int) Variables locales b (int) r (int) * (32b) Spécial esp

# 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) L11:

# a = fibo(n-1) movl 8(%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) 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)

# 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) leave # Restaure le cadre de pile

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 »

La pile un élément essentiel

Présentations similaires

Présentation au sujet: "La pile un élément essentiel"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

La pile un élément essentiel

Présentations similaires

Présentation au sujet: "La pile un élément essentiel"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back