la pile un élément essentiel

La pileLa pileun élément essentielun élément essentiel

Merci Laurent JEANPIERRE

Contenu du coursContenu du cours

DéfinitionDéfinition

Manipulations

Appel de fonctions

Gestion du résultat

Gestion des variables

Gestion des paramètres

Exemple : Fibonacci

Conclusion

Définition de la pile (Définition de la pile (stackstack))

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émoireLa pile en mémoire

Zone de mémoire séparéeRegistre de segment spécifique

SS = Stack SegmentRegistre de position spécifique

eSP = (extended) Stack Pointerss:esp indique la dernière valeur empilée

Sur x86, elle croît à l’envers…Sommet_pile ≤ Base_pile


Définition

ManipulationsManipulations

Appel de fonctions




Exemple : Fibonacci

Conclusion

Manipulations de la pileManipulations 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écifiquesInstructions spécifiques

PUSH = empilerMet une valeur sur la pile.Le registre esp diminue de la taille spécifiéeL’opérande est stockée à l’adresse (%esp)

POP = dépilerRetire 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)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

esp


movl $0,%eax

pushl $0x01234567

pushw $0x89AB

Registres

EAX EBX ESP

******** ???????? 10010

Pile

00000000

esp


movl $0,%eax

pushl $0x01234567

pushw $0x89AB

Registres

EAX EBX ESP

00000000 ???????? 10010

Pile

9610

esp0123

4567

esp


pushl $0x01234567

pushw $0x89AB

pushw $0xCDEF

Registres

EAX EBX ESP

00000000 ???????? 9610

Pile

esp

0123

4567

89AB

9410

esp


pushw $0x89AB

pushw $0xCDEF

movb (esp),%al

Registres

EAX EBX ESP

00000000 ???????? 9410

Pile

esp

0123

4567

89AB

9210

CDEF

esp


pushw $0xCDEF

movb (%esp),%al

popl %ebx

Registres

EAX EBX ESP

00000000 ???????? 9210

Pile0123

4567

89AB

CDEF

000000EF

esp


movb (esp),%al

popl %ebx

movw %ax, 1(%esp)

Registres

EAX EBX ESP

000000EF ???????? 9210

Pile

esp

0123

4567

89AB

9610

CDEF

89ABCDEF

esp


popl %ebx

movw %ax, 1(%esp)

popl %eax

Registres

EAX EBX ESP

000000EF 89ABCDEF 9610

Pile0123

4567

89AB

CDEF

0100

EF67


popl %ebx

movw %ax,1(%esp)

popl %eax

Registres

EAX EBX ESP

000000EF 89ABCDEF 9610

Pile0100

EF67

89AB

CDEF

esp

esp

100100100EF67


Définition

Manipulations

Appel de fonctionsAppel de fonctions




Exemple : Fibonacci

Conclusion

Appel de fonctionsAppel de fonctions

Programme structuré fonctionsExemple :

Fonction déplacer(Object o)Soulever(o)SeDéplacer()Poser(o)

FinFonctions blocs bien parenthésés Utilisation naturelle de la pile

Appel de fonctions en assembleurAppel 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éfinition

Manipulations

Appel de fonctions

Gestion du résultatGestion du résultat



Exemple : Fibonacci

Conclusion

Le résultat de la fonction (1)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)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)


Définition

Manipulations

Appel de fonctions


Gestion des variablesGestion des variables


Exemple : Fibonacci

Conclusion

Les variablesLes 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 tasSur la pile

Variables globales : le tasVariables globales : le tas

.dataa: .long 3b: .long 0

.textmain:

movl (a), %eaxaddl $5, %eaxmovl %eax, (b)ret

Très bien pour les variables globales…Mais pour les fonctions récursives ?

Fonctions récursivesFonctions 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 …

Exemple2 : FibonacciExemple2 : 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…

Variables locales : la pileVariables 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 (Cadre de pile (ébaucheé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éfinition

Manipulations

Appel de fonctions



Gestion des paramètresGestion des paramètres

Exemple : Fibonacci

Conclusion

Les paramètres des fonctionsLes 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 (Cadre de pile (completcomplet))

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

ebp

esp

Note spécifique 386 et plus…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 okchar/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 okdouble 64 bits ok

On ne s’intéressera qu’aux multiples de 32 bitsReste Pas au programme


Définition

Manipulations

Appel de fonctions




Exemple : FibonacciExemple : Fibonacci

Conclusion

Fibonacci, le résultat final (1)Fibonacci, le résultat final (1)

int fibo(int n)Locales : int a,b,r;

_fibo:# sauvegarde EBPpushl %ebp# EBP <- ESPmovl %esp, %ebp# Alloue 16 octets # sur la pilesubl $16, %esp

n (int)

@retour

EBP0

a (int)

b (int)

r (int)

* (32b)

ebp

esp

Paramètres

Contexte

Variables locales

Spécial


# if n==0cmpl $0, 8(%ebp) # compare 0 et n (EBP+8)jne L10 # saute si différentmovl $0, -12(%ebp) # mets 0 dans r (EBP-12)jmp L9 # saute à fin

L10:

# if n==1cmpl $1, 8(%ebp) # compare 1 et n (EBP+8)jne L11 # saute si différentmovl $1, -12(%ebp) # mets 1 dans r (EBP-12)jmp L9 # saute à fin

L11:


# a = fibo(n-1)movl 8(%ebp), %eax # eax <- n (EBP+8)decl %eax # eax <- eax-1movl %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)movl 8(%ebp), %eax # eax <- n (EBP+8)subl $2, %eax # eax <- eax-2movl %eax, (%esp) # (ESP+0) <- eax

# {Paramètre1 = n-2}call _fibo # appelle fibo {reseax} movl%eax, -8(%ebp) # mets eax dans b (EBP-8)


# r = a+bmovl -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 <- %ebppopl %ebp # Restaure ebpret # fin

Ou encore… (autre solution)L9:

movl -12(%ebp), %eax # eax <- r=(EBP+12)leave # Restaure le cadre de pileret # fin


Définition

Manipulations

Appel de fonctions




Exemple : Fibonacci

ConclusionConclusion

ConclusionConclusion

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

Documents