Conception et exploitation des processeurs

Notes
Conception et exploitation des processeurs
Chargés de cours : Frédéric Pétrot et Sébastien Viardot
Année universitaire 2011-2012
Conception et exploitation des processeurs
Structure du cours
C1
C2
C3
Notes
Introduction au VHDL
Introduction aux langages d'assemblage
pour les ISA x86 et MIPS
Conventions pour les appels de fonctions
en assembleur x86 et MIPS
2 / 21
Conception et exploitation des processeurs
Introduction
Notes
Plan
1
Introduction
2
ABI x86
3
ABI MIPS
3 / 21
Conception et exploitation des processeurs
Introduction
Notes
Introduction
Fonction
Ensemble d'instructions réalisant une tâche donnée pouvant être
appelée à divers points d'un programme et retournant après le
point d'appel une fois exécutée
Une fonction :
prend 0, 1 ou n paramètre(s) et retourne un résultat
utilise des variables locales dont la durée de vie est celle de la
fonction
peut utiliser des variables globales dont la durée de vie est celle
du programme
ou des pointeurs sur le tas dont la durée de vie est déterminée
par le programme
4 / 21
Conception et exploitation des processeurs
Introduction
Notes
Introduction
Fonctions : Notion d'appelante et d'appelée
/* Fonction appelante */
int32_t sos(int x)
{
/* variables locales */
int32_t u, v, w;
u = square(x);
/*^point de retour de la
première invocation */
v = square(x);
/*^point de retour de la
deuxième invocation */
w = u + v;
/* valeur de retour */
return w;
}
/* Fonction appelée */
int32_t square(int32_t y)
{
/* variable locale */
int32_t u;
u = y * y;
/* valeur de retour */
return u;
}
5 / 21
Conception et exploitation des processeurs
Introduction
Notes
Introduction
Contexte d'exécution
Il contient :
les paramètres, ou au moins de la place pour eux
les variables locales
les registres dont les valeurs doivent être sauvegardés pour
l'appelant
l'adresse de retour dans l'appelant
Principes
création d'un contexte d'exécution pour chaque invocation
utilisation du contexte pour l'exécution de la fonction
destruction du contexte lors du retour de fonction
contextes crées et détruits dans une pile
appels imbriqués
appels successifs
empilement et dépilement des contextes
création contextes dans même zone de pile
6 / 21
Conception et exploitation des processeurs
Introduction
Notes
Introduction
Programmation des fonctions
Repose sur des conventions spéciques à chaque architecture de
processeur :
utilisation des registres
support matériel ad-hoc
C'est l'Application Binary Interface (ABI)
7 / 21
Conception et exploitation des processeurs
ABI x86
Notes
Plan
1
Introduction
2
ABI x86
3
ABI MIPS
8 / 21
Conception et exploitation des processeurs
ABI x86
Notes
ABI x86
Instructions d'appel et retour de fonction
call func : saute à adresse étiquette func, empile adresse
instruction suivant call, dite adresse de retour
ret : dépile adresse sauvée par call et y saute
Structuration de la pile (stack
adresses hautes
⇓
..
.
⇓
adresses basses
)
frame
paramètres d'entrée
adresse de retour
optionnel
systématique
%ebp précédent
variables locales
registres à sauver
systématique
optionnel
optionnel
9 / 21
Conception et exploitation des processeurs
ABI x86
Notes
ABI x86
Registres spécialisés
%esp (pointeur de pile) : contient adresse de la dernière case
occupée dans pile
%ebp (pointeur de contexte) : contient adresse de base
contexte d'exécution (adresse dans pile de %ebp précédent)
utilisé pour accéder au contexte : -4(%ebp) par ex.
Mise en place de la structuration de la pile
Une responsabilité partagée :
appelante : empile valeur paramètres dans l'ordre, empile
adresse de retour implicitement en appelant call
appelée : réserve la place nécessaire à son propre contexte
d'exécution
10 / 21
Conception et exploitation des processeurs
ABI x86
Notes
ABI x86
Utilisation des autres registres :
Modiables par la fonction appelée (scratch ou clobber)
%eax, %ecx, %edx, %eflags
À sauver dans l'appelante si valeurs nécessaires après le retour de
l'appelée
À préserver dans la fonction appelée (non-scratch ou preserved)
%ebx, %esi, %edi
À sauver puis restaurer dans l'appelée si elle en fait usage
11 / 21
Conception et exploitation des processeurs
ABI x86
Notes
ABI x86
En pratique :
Dans la fonction appelée
calculer la place nécessaire aux variables locales et registres à sauver
empiler %ebp, sauver %esp dans %ebp
créer l'espace dans la pile pour variables locales et registres en déplaçant
%esp
pushl %eax, empile registre, popl %eax, dépile et sommet dans registre
mise en place
enter $N, $0
≡
retour à l'état précédent
leave
≡
pushl %ebp
movl %esp, %ebp
subl $N, %esp
movl %ebp, %esp
popl %ebp
≡
≡
subl
movl
movl
subl
$4, %esp
%ebp, (%esp)
%esp, %ebp
$N, %esp
movl %ebp, %esp
movl (%esp), %ebp
addl $4, %esp
12 / 21
Conception et exploitation des processeurs
ABI x86
Notes
ABI x86
Exemple :
int32_t plus(void)
{
int32_t a = 5;
int32_t b = 4;
return a + b;
}
plus: enter $8, $0
movl $5, -4(%ebp) ; a <- 5
movl $4, -8(%ebp) ; b <- 4
movl -4(%ebp), %eax
addl -8(%ebp), %eax
leave
ret
Pile après le enter et avant le leave :
adresses hautes
adresse de retour
%ebp précédent
a=5
b=4
⇓
⇓
adresses basses
%ebp + 4 = %esp précédent
%ebp
%ebp - 4
%ebp - 8 = %esp
13 / 21
Conception et exploitation des processeurs
ABI x86
Notes
ABI x86
Appels imbriqués :
int main(void)
{
int x = plus();
return 0;
}
main: enter $4, $0
call plus
movl %eax, -4(%ebp)
leave
movl $0, %eax
ret
État de la pile avant le leave de plus :
adresses hautes
⇓
.
.
.
⇓
adresses basses
adresse de retour au système
%ebp du système
x =?
adresse de retour à main
%ebp de main
a=5
b=4
14 / 21
Conception et exploitation des processeurs
ABI x86
Notes
ABI x86
Passage et récupération de paramètres :
int32_t plus(
int32_t a,
int32_t b)
{ return a + b;}
int32_t main(void)
{
int32_t x;
x = plus(5, 4);
return 0;
}
adresses hautes
⇓
main:
enter $4, $0
pushl $5
pushl $4
call plus
addl $8, %esp
movl %eax, -4(%ebp)
leave
movl $0, %eax
ret
adresse de retour au système
%ebp
du système
...
x =?
...
5
...
⇓
adresses basses
4
de
%ebp
dans
main
main
$0, $0
12(%ebp), %eax
8(%ebp), %eax
main
paramètre
a
b
%ebp
plus
paramètre
adresse de retour à
%ebp
plus:
enter
movl
addl
leave
ret
dans
dans
dans
plus
plus
15 / 21
Conception et exploitation des processeurs
ABI MIPS
Notes
Plan
1
Introduction
2
ABI x86
3
ABI MIPS
16 / 21
Conception et exploitation des processeurs
ABI MIPS
Notes
ABI MIPS
Instructions d'appel et retour de fonction
jal func : saute à adresse étiquette func, sauve adresse
instruction suivante dans $31
jalr $2 : saute à adresse contenue dans $2, sauve adresse
instruction suivante dans $31
jr $31 : retourne à l'appelant ($ra)
Pas d'instruction de manipulation de la pile
Une seule opération de déplacement de pile dans une fonction : le
plus grand nécessaire
addiu : fait croître et décroître le pointeur de pile
lw, sw : mise à jour des données dans la pile
$29 ($sp) : pointe toujours sur la dernière case occupée
17 / 21
Conception et exploitation des processeurs
ABI MIPS
Notes
ABI MIPS
Structuration de la pile (stack
adresses hautes
⇓
⇓
adresses basses
)
frame
espace pour paramètres
adresse de retour
registres à sauver
variables locales
systématique
optionnel
optionnel
optionnel
Convention d'usage des registres
Registre
$0
$1
$2-$3
$4-$7
$8-$15,$24,$25
$16-$23,$30
$26-$27
$28
$29
$31
Nom
$0
$at
$v0-$v1
$a0-$a3
$t0-$t9
$s0-$s8
$k0-$k1
$gp
$sp
$ra
Usage
toujours 0
réservé à l'assembleur
valeur(s) de retour
4 premiers arguments (scratch)
temporaires (scratch)
à sauver (non-scratch)
réservés au noyau
pointeur global
pointeur de pile
adresse de retour
18 / 21
Conception et exploitation des processeurs
ABI MIPS
Notes
ABI MIPS
Passage et récupération des paramètres
les 4 premiers paramètres dans $4, $5, $6 et $7
f(...) {
g(...);
k(...);
}
g(...) {
h(...);
}
adresses
hautes
⇓
déplacement dans
f()
compatible
appel g() et appel
k()
mise en place argu⇓
ments dépendant adresses
de déplacement
basses
5ème paramètre
place pour $7
place pour $6
place pour $5
place pour $4
valeur de $31
autres registres
à sauver
variables locales
paramètre n − 1
paramètre 5
place pour $7
place pour $6
place pour $5
place pour $4
et les autres au dessus
utilisé uniquement si
la fonction appelée (g) les
modie
$29 dans appelante (f)
adresse de retour
lors de l'appel d'une
autre fonction (h)
lors appel suivant (h)
$29 dans appelée (g)
19 / 21
Conception et exploitation des processeurs
ABI MIPS
Notes
ABI x86
Exemple, la factorielle, enn !
int f(int n)
{
return
n <= 1
? 1
: n
*
f(n-1);
}
f:
addiu
sw
sw
slt
bne
add
addiu
jal
mult
mflo
j
L3: li
L2: lw
lw
addiu
j
$sp,$sp,-24
$31,20($sp)
$16,16($sp)
$2,$4,2
$2,$0,L3
$16,$4,$0
$4,$4,-1
f
$2,$16
$2
L2
$2,1
$31,20($sp)
$16,16($sp)
$sp,$sp,24
$31
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
args + ra + 1 non-scratch
empile $31 (ra)
empile $16 (non-scratch)
si < 2
va en L3
sauve n dans $16
n <- n-1
appel récursif
n * valeur de retour
resultat dans $2
saut vers epilogue
valeur de retour 1
recupère ra
restaure $16
élimine la pile courante
retour à l'appelant
20 / 21
Conception et exploitation des processeurs
ABI MIPS
Notes
En Résumé
ABI
Usage des registres
imposé par le matériel
ou reposant sur des conventions
Souvent un mix des 2
Appels de fonctions
responsabilité partagée en fonction appelante et appelée
structure prédénie et acceptée : prix à payer pour la
compatibilité
fonction appelante ne sait pas ce que fait fonction appelée, ne
connaît que son prototype
basée sur des conventions qu'il faut suivre
21 / 21