Patricia Renault UPMC 2005/2006

Présentation au sujet: "Patricia Renault UPMC 2005/2006"— Transcription de la présentation:

1 Patricia Renault UPMC 2005/2006
UE MAREP Cours 7 : La pile d’exécution (Fonctions avec variables locales - Passage des arguments par valeur ou par adresse) Patricia Renault UPMC 2005/2006

2 Plan Rappels Représentation des variables locales d’une fonction
Passage des arguments par valeur ou par adresse

3 Plan Rappels Représentation des variables locales d’une fonction
Fonction sans variable locale, passage des arguments par valeur Représentation des variables locales d’une fonction Passage des arguments par valeur ou par adresse

4 Convention La fonction appelante La fonction appelée
Empile les arguments (en commençant par le dernier) Effectue l’appel à l’appelé Obtient le résultat dans $2 Dépile les arguments La fonction appelée Empile $31 Empile les registres dont elle se sert dans son traitement Effectue son traitement et place le résultat dans $2 Restaure les valeurs des registres qu’elle avait sauvegardées Dépile $31 et les registres utilisés par la fonction appelée Retourne à l’appelant prologue épilogue

5 Plan Rappels Représentation des variables locales d’une fonction
Définition Convention Exemple Cas général Passage des arguments par valeur ou par adresse

6 Définition Une variable locale est une variable dont la portée est limitée à une fonction (variable définie à l’intérieur d’une fonction) Exemple : int fadd(int a, int b){ int i, c = 0; for (i=a; i<b; i++){ c = c + i; } return c;

7 Convention Les variables locales d’une fonction appelée sont systématiquement allouées sur la pile d’exécution, par la fonction appelée, dans son prologue. La zone mémoire attribuée aux variables locales est détruite par la fonction appelée dans son épilogue. Cette réservation est parfois superflue, mais par soucis de simplicité et de régularité de représentation des appels de fonction, nous réaliserons systématiquement cette allocation.

8 Convention La fonction appelante (aucune modification)
Empile les arguments (en commençant par le dernier) Effectue l’appel à l’appelé Obtient le résultat dans $2 Dépile les arguments

9 Convention La fonction appelée Empile $31
Empile les registres dont elle se sert dans son traitement Réserve la place sur la pile pour représenter ses variables locales Effectue son traitement et place le résultat dans $2 Restaure les valeurs des registres qu’elle avait sauvegardées Libère l’espace de la pile réservé aux variables locales Dépile $31 et les registres utilisés par la fonction appelée Retourne à l’appelant

10 Exemple int x = 1, y = 4, t1; int fadd(int a, int b){ int i, c = 0;
for (i=a; i<b; i++){ c = c + i;} return c; } void main(){ t1 = fadd(x,y); printf(”%d\n”, t1); exit(0);

11 Exemple .data x : .word 1 y : .word 4 t1 : .word
.stack 256 #256 octets pour la pile .text __start : lui $5, x>>16 ori $5, $5, x & 0xFFFF lw $5, ($5) # x dans $5 lui $6, y>>16 ori $6, $6, y & 0xFFFF lw $6, ($6) # y dans $6

12 Exemple addiu $29, $29, -8 # empile les 2 arguments
sw $6, 4($29) # passage de y sw $5, ($29) # passage de x jal fadd # appel de fadd addiu $29, $29, 8 # depile les 2 arguments lui $7, t1 >> 16 ori $7, $7, t1 & 0xFFFF sw $2, ($7) # met fadd(x,y) ds mot t1 ori $4, $2, 0 # affichage ori $2, $0, 1 syscall

13 Exemple ori $2, $0, 10 # fin syscall fadd : # prologue
addiu $29, $29, -28 #$ reg + 2 v. loc sw $31, 24($29) sw $5, 20($29) sw $6, 16($29) sw $7, 12($29) sw $8, 8($29) lw $5, 28($29) # $5 contient a lw $6, 32($29) # $6 contient b

14 Exemple # corps de la fonction fadd #$5 : a, $6 : b, $7 : i, $8 : c
xor $8, $8, $8 ori $7, $5, 0 fboucle : slt $9, $7, $6 # 1 si i<b beq $9, $0, fin_fadd add $8, $8, $7 addi $7, $7, 1 j fboucle

15 Exemple fin_fadd : ori $2, $8, 0 # resultat dans le registre 2
# epilogue lw $31, 24($29) lw $5, 20($29) lw $6, 16($29) lw $7, 12($29) lw $8, 8($29) addiu $29, $29, 28 jr $31

16 Exemple i ($29) c 4($29) $8 8($29) $7 12($29) $6 16($29) $5 20($29)
@ret ($31) 24($29) a 28($29) b 32($29) ////////////// Variables locales de fadd Empilements par fadd Empilements par main

17 Cas général f appelle une fonction g ayant na arguments. g utilise nr registres pour réaliser le traitement. La fonction g déclare nv variables locales. On nomme : RAi le registre contenant l’argument i (dans l’appelant f ) RRj le registre persistant numéro j (dans l’appelé g) RPk le registre contenant le paramètre k (dans l’appelé g)

18 Cas général Code de f : # inchangé … addiu $29, $29, -4 * na
sw $Ana-1, 4*(na-1)($29) sw $Ana-2, 4*(na-2)($29) sw $A0, 0($29) jal g addiu $29, $29, 4 * na

19 Cas général Code de g : g : # prologue addiu $29, $29, -4*(nr + nv +1)
sw $31, 4* (nr + nv) ($29)# sauvegarde reg sw $Rnr, 4* (nr + nv – 1) ($29) … sw $R0, 4* nv($29) lw $P0, 4*(nr + nv +1)($29)# récup des arg lw $P1, 4*(nr + nv +2)($29) lw $Pna-1, 4*(nr + nv + na)($29)

20 Cas général # … traitement de la fonction
# $2 contient le résultat de la fonction # epilogue lw $R0, 4* nv($29) … lw $Rnr, 4 * (nr + nv – 1) ($29) lw $31, 4 * (nr + nv) ($29) jr $31

21 Cas général Zone des variables locales V(nv-1)
 $29 après prologue fonction appelée … V(0) Zone de sauvegarde des registres R(nr-1) R(0) @ret ($31) Zone des arguments A(0)  $29 avant et après appel fonction appelée A(na-1) //////////////  $29 initial et final Empilements par la fonction appelée Empilements par la fonction appelante

22 Plan Rappels Représentation des variables locales d’une fonction
Passage des arguments par valeur ou par adresse Limites du passage par valeur Solution : le passage par adresse Exemple

23 Limites du passage par valeur
Avec un passage par valeur : Lors de l’appel d’une fonction, les arguments sont transmis à la fonction appelée par recopie dans la pile. Ceci implique que les modifications effectuées dans la fonction appelée sur les arguments ne sont pas répercutées à la fonction appelante. C’est ce qu’on appelle un passage par valeur. Problème : La recopie des variables volumineuses peut nécessiter du temps. Le résultat retourné par la fonction appelante est dans le registre 2. Une fonction peut vouloir retourner plusieurs valeurs.

24 Solution : le passage par adresse
Pour éviter la recopie des variables volumineuses dans la pile et permettre à la fonction appelée de modifier des arguments il faut passer les arguments par adresse. L’adresse de la case mémoire où se trouve l’argument à modifier est placée dans la pile par la fonction appelante. La fonction appelée peut alors avec cette adresse modifier le contenu de cette case mémoire. Pour réaliser un passage d’argument par adresse, il faut déclarer l’argument dans le segment data.

25 Exemple int faddinc(int a, int* p){ *p = *p + 1; return (a + *p); }
int x = 2, y = 3, z = 4; int t1; void main(){ t1 = faddinc(x,&y); printf("%d\n",t1); exit(0); Valeur de la variable Adresse de la variable

26 Exemple .data x : .word 2 y : .word 3 t1 : .word
.stack 256 #256 octets pour la pile .text __start : lui $5, x>>16 ori $5, $5, x & 0xFFFF lw $5, ($5) # x dans $5 lui $6, y>>16 ori $6, $6, y & 0xFFFF de y dans $6

27 Exemple addiu $29, $29, -8 # empile les 2 arguments
sw $6, 4($29) # passage de de y sw $5, ($29) # passage de x jal faddinc addiu $29, $29, 8 lui $7, t1 >> 16 ori $7, $7, t1 & 0xFFFF sw $2, ($7) # met faddinc(x,&y) mot t1 ori $4, $2, 0 # affichage ori $2, $0, 1 syscall

28 Exemple ori $2, $0, 10 # fin syscall faddinc : # prologue
addiu $29, $29, -16 #$ registres sw $31, 12($29) sw $5, 8($29) sw $6, 4($29) sw $7, ($29) lw $5, 16($29) # $5 contient a lw $6, 20($29) # $6 de p

29 Exemple #$5 : a, $6 : @ de p, $7 : valeur de p lw $7, ($6)
addi $7, $7, 1 sw $7,($6) add $2, $7, $5 lw $31, 12($29) # epilogue lw $5, 8($29) lw $6, 4($29) lw $7, ($29) addiu $29, $29, 16 jr $31

30 Exemple $7 ($29) $6 4($29) $5 8($29) @ret ($31) 12($29) a 16($29) @ p
20($29) ////////////// Empilements par faddinc Empilements par main