Cours de «concepts avancés de compilation» Travaux pratiques. Séance du 17 décembre Auteurs : B. Monsuez, F. Védrine

Transcription

1 Cours de «concepts avancés de compilation» Travaux pratiques Séance du 17 décembre 2007 Auteurs : B. Monsuez, F. Védrine L exemple suivant nous servira d exemple de référence pour le TD. Nous présentons à la fois le code source tel que défini par l utilisateur et le résultat après l affectation des registres. const char* prefix= "La valeur est "; void f(int x) { printf("%s", prefix); printf("%d\n", x); int main(int argc, char** argv) { int x; int y; x = argc; x = x*x-2*x; y = 4+argc; do { if (x > 2) if (2*x > y) y = 2; f(x); ; ; while (x > 0); return 0; const char* prefix= "La valeur est "; void f(int x) { printf("%s", prefix); printf("%d\n", x); int main(int argc, char** argv) { int r1, r2, r3, r4; r1 = argc; r1 = r1* r1-2* r1; r2 = 4+argc; do { if (r1 > 2) if (2*r1 > r2) r4 = 2; f(r1); r4 = r2; ; ; r2 = r4; while (r1 > 0); return 0; Production de code Le jeu d instruction cible est du MIPS (Microprocessor without Interlocked Pipeline Stages) pour la simplicité de son jeu d instructions de type RISC (Reduced Instruction Set Computer). Ce jeu d instruction est celui de la référence "Computer Architecture: A Quantitative Approach de John L. Hennessy, David A. Patterson" et du simulateur de code assembleur SPIM disponible sur Le simulateur travaille sur du code assembleur, très proche du code compilé. Cet assembleur est suffisant pour déboguer le résultat de votre compilation. Noter que la phase de production de code de votre compilateur pourra produire en sortie soit de l assembleur (chaque instruction tient en une ligne texte d assembleur comme add $t0, $t0, $t1) soit du code compilé (chaque instruction tient en un mot ou 4 octets ou 32 bits, comme 0x correspondant à la décomposition en base deux de l instruction. Le décodage suivant prim_opcode=6 register_source=5 register_transfert=5 register_destination=5 0=5 second_opcode=6 1/6

2 donne =$t =$t =$t =add). Le choix de production dépendra d une variable que vous aurez fixé. L organisation de la mémoire pour le MIPS est la suivante : 7FFF FFFC Stack Segment appels de fonctions, arguments, valeurs de retours, variables locales, registres sauvegardés Dynamic data Static data Data Segment allocation dynamique = résultat de malloc variables globales Text Segment Code compilé Constantes chaînes de caractères Reserved Un fichier exécutable défini comme le résultat d une compilation a pour objectif d être exécuté. Lorsqu on demande à l exécuter (par une commande dans le shell par exemple), le système d exploitation charge le code correspondant au fichier exécutable dans le «Text Segment». La première instruction à exécuter se trouve à l adresse 0x Le chargement réserve également une zone pour stocker les variables globales. Ces dernières seront initialisées lors de l exécution du code. Les adresses référencées sont des adresses virtuelles. C est le système d exploitation qui définit la correspondance entre adresses virtuelles et adresses physiques dans la mémoire de l ordinateur, et ce à l aide de tables de correspondances. Cela permet en particulier aux systèmes d exploitation d exécuter plusieurs programmes simultanément (systèmes multi-tâches). Lors de l exécution d un programme, les instructions empilent des données dans la pile du programme (et font ainsi décroître le pointeur de pile voir les explications suivantes), appellent des fonctions (et font ainsi décroître le pointeur du cadre d activation voir les explications suivantes), remplissent et vident la zone de données dynamiques. placent des données dans les registres et utilisent ces données. L organisation de la pile d appel est alors la suivante : 7FFF FFFC appel à f() Stack Segment appel à g(2,3,'a',4,'b',17) appel à h() Argument 6 = 17 Argument 5 = 'b' registres sauvegardés Dynamic data Static data Reserved Data Segment Text Segment int f() { g(2, 3, 'a', 4, 'b', 17); variables locales int g(int x, int y, char z, int t, char u, int z) { h(); Les conventions d usage des 32 registres du MIPS sont définies par : Les registres $at (1), $k0 (26) et $k1 (27) sont réservés pour l exécution de l assembleur et par le système d exploitation. Ils ne doivent pas être utilisés par le programmeur ou par les compilateurs. 2/6

3 Les registres $a0 $a3 (4 7) sont utilisés pour passer les 4 premiers arguments aux fonctions appelées (notamment pour les appels systèmes), les autres arguments étant passés sur la pile. Les registres $v0 et $v1 (2, 3) sont utilisés pour stocker les valeurs de retour des fonctions. Les registres $t0 $t9 (8 15, 24, 25) sont des registres utilisés pour stocker des variables temporaires locales. Il ne doit pas y avoir d appels fonctionnels entre la définition de ces variables et leurs utilisations, car ces registres ne sont pas préservés par les fonctions appelées. Les registres $s0 $s7 (16 23) sont des registres utilisés pour stocker des variables temporaires supportant des appels de fonction entre leur définition et leurs utilisations. Ces registres sont préservés par les fonctions appelées. À la différence des registres précédents, leur préservation est de la responsabilité des fonctions appelées et non pas des fonctions appelantes. Le registre $gp (28) correspond à un pointeur sur les variables globales. Il pointe dans le milieu des 64ko de mémoire statique correspondant aux «Static Data». Le registre $sp (29) est le pointeur de pile. Il pointe juste après la dernière variable locale stockée dans la pile «Stack Segment». Le registre $fp (30) pointe sur le dernier cadre d activation, qui correspond à la fonction en cours d exécution. Il permet de retrouver les paramètres de la fonction et autorise une mise à jour du pointeur de pile après le retour de la fonction. L instruction jal utilisée pour implanter les appels fonctionnels, écrit dans le registre $ra (31) l adresse de retour de la fonction et ce au moment de l appel à cette fonction. L instruction jr $ra dans la fonction appelée permet de retourner à la fonction appelante sur l adresse de retour. Question 1.1 Étude du résultat de la compilation Le code de la question 1.2 se traduit en assembleur MIPS sous la forme suivante :.data chaine:.asciiz "La valeur est " # variable globale.text f: subu $sp, $sp, 32 # le cadre d'activation est large de 32 octets sw $ra, 20($sp) # sauve l'adresse de retour sw $fp, 16($sp) # sauve l'ancien cadre de pile addiu $fp, $sp, 28 # met en place le cadre de pile # move $t0, $a0 # copie l'argument # la $a0, $LC # met en place l'argument pour printf # jal printf # la $a0, chaine # met en place l'argument pour printf # move $a1, $t0 # jal printf move $t0, $a0 # copie l'argument li $v0, 4 # appel système pour print_str la $a0, chaine # met en place l'argument pour printf syscall li $v0, 1 # appel système pour print_int move $a0, $t0 syscall li $v0, 4 # appel système pour print_str la $a0, $LC # met en place l'argument pour printf addi $a0,$a0, 2 # se positionne sur le retour chariot syscall lw $ra, 20($sp) # restaure l'adresse de retour lw $fp, 16($sp) # restaure le cadre d'activation addiu $sp, $sp, 32 # restaure le pointeur de pile jr $ra # retourne à l'appelant.rdata $LC:.asciiz "%d\n".text.globl main main: subu $sp, $sp, 32 # le cadre d'activation est large de 32 octets sw $ra, 20($sp) # sauve l'adresse de retour sw $fp, 16($sp) # sauve l'ancien cadre de pile addiu $fp, $sp, 28 # met en place le cadre de pile 3/6

4 sll $t1, $a0, 1 mul $t0, $a0, $a0 sub $t0, $t0, $t1 addi $t1, $a0, 4 loop: addi $t2, $t0, -2 blez $t2, fst_else j fst_label fst_else: sll $t2, $t0, 1 ble $t2, $t1, snd_else li $t2, 2 j snd_label snd_else: move $a0, $t0 jal f move $t2, $t0 snd_label: move $t0, $t2 fst_label: bgtz $t0, loop li $v0, 0 lw $ra, 20($sp) # restaure l'adresse de retour lw $fp, 16($sp) # restaure le cadre d'activation addiu $sp, $sp, 32 # restaure le pointeur de pile jr $ra # retourne à l'appelant La gestion des appels fonctionnels est relativement systématique. La routine main crée son cadre d activation et sauve dans la pile (avant leur modification) les deux registres à sauvegarder qu elle modifie localement. Le cadre général est plus large que la sauvegarde seule de ces deux registres, parce que les conventions d appel requièrent une taille minimale de 24 octets. Ce cadre minimal doit contenir les 4 registres arguments $a0-$a3 (16 octets), plus l adresse de retour $ra (4 octets), laquelle doit être décalée via une référence tenant sur un double-mot (8 octets). Vous pouvez charger ce code sous PCSPIM et voir son exécution à travers le simulateur. Il est possible de modifier argc après la première instruction (on pourra lui mettre une valeur de 3 pour effectuer au moins un tour de boucle). [0x ] 0x8fa40000 lw $4, 0($29) ; 174: lw $a0 0($sp) # argc [0x ] 0x27a50004 addiu $5, $29, 4 ; 175: addiu $a1 $sp 4 # argv [0x ] 0x24a60004 addiu $6, $5, 4 ; 176: addiu $a2 $a1 4 # envp [0x c] 0x sll $2, $4, 2 ; 177: sll $v0 $a0 2 [0x ] 0x00c23021 addu $6, $6, $2 ; 178: addu $a2 $a2 $v0 [0x ] 0x0c10001d jal 0x [main] ; 179: jal main [0x ] 0x nop ; 180: nop [0x c] 0x a ori $2, $0, 10 ; 182: li $v0 10 [0x ] 0x c syscall ; 183: syscall # syscall 10 (exit) [0x ] 0x27bdffe0 addiu $29, $29, -32 ; 6: subu $sp, $sp, 32 # le cadre d'activation = 32 octets [0x ] 0xafbf0014 sw $31, 20($29) ; 7: sw $ra, 20($sp) # sauve l'adresse de retour [0x c] 0xafbe0010 sw $30, 16($29) ; 8: sw $fp, 16($sp) # sauve l'ancien cadre de pile [0x ] 0x27be001c addiu $30, $29, 28 ; 9: addiu $fp, $sp, 28 # met en place le cadre de pile [0x ] 0x addu $8, $0, $4 ; 18: move $t0, $a0 # copie l'argument [0x ] 0x ori $2, $0, 4 ; 19: li $v0, 4 # appel système pour print_str [0x c] 0x3c lui $1, 4097 [$LC] ; 20: la $a0, $LC # met en place l'argument pour print [0x ] 0x e ori $4, $1, 14 [$LC] [0x ] 0x c syscall ; 21: syscall [0x ] 0x ori $2, $0, 1 ; 22: li $v0, 1 # appel système pour print_int [0x c] 0x addu $4, $0, $8 ; 23: move $a0, $t0 [0x ] 0x c syscall ; 24: syscall [0x ] 0x ori $2, $0, 4 ; 25: li $v0, 4 # appel système pour print_str [0x ] 0x3c lui $4, 4097 [chaine] ; 26: la $a0, chaine # met en place l'argument pour print [0x c] 0x addi $4, $4, 2 ; 27: addi $a0,$a0, 2 # se positionne sur le retour chariot [0x ] 0x c syscall ; 28: syscall [0x ] 0x8fbf0014 lw $31, 20($29) ; 30: lw $ra, 20($sp) # restaure l'adresse de retour [0x ] 0x8fbe0010 lw $30, 16($29) ; 31: lw $fp, 16($sp) # restaure le cadre d'activation [0x c] 0x27bd0020 addiu $29, $29, 32 ; 32: addiu $sp, $sp, 32 # restaure le pointeur de pile [0x ] 0x03e00008 jr $31 ; 33: jr $ra # retourne à l'appelant 4/6

5 [0x ] 0x27bdffe0 addiu $29, $29, -32 ; 41: subu $sp, $sp, 32 # le cadre d'activation = 32 octets [0x ] 0xafbf0014 sw $31, 20($29) ; 42: sw $ra, 20($sp) # sauve l'adresse de retour [0x c] 0xafbe0010 sw $30, 16($29) ; 43: sw $fp, 16($sp) # sauve l'ancien cadre de pile [0x ] 0x27be001c addiu $30, $29, 28 ; 44: addiu $fp, $sp, 28 # met en place le cadre de pile [0x ] 0x sll $9, $4, 1 ; 46: sll $t1, $a0, 1 [0x ] 0x mul $4, $4 ; 47: mul $t0, $a0, $a0 [0x c] 0x sub $8, $8, $9 ; 48: sub $t0, $t0, $t1 [0x ] 0x addi $9, $4, 4 ; 49: addi $t1, $a0, 4 [0x ] 0x210afffe addi $10, $8, -2 ; 52: addi $t2, $t0, -2 [0x ] 0x blez $10 12 [fst_else-0x ]; 53: blez $t2, fst_else [0x c] 0x2108ffff addi $8, $8, -1 ; 54: [0x004000a0] 0x j 0x004000d0 ; 55: j fst_label [0x004000a4] 0x sll $10, $8, 1 ; 57: sll $t2, $t0, 1 [0x004000a8] 0x012a082a slt $1, $9, $10 ; 58: ble $t2, $t1, snd_else [0x004000ac] 0x beql $1, $0, 12 [snd_else-0x004000ac] [0x004000b0] 0x340a0002 ori $10, $0, 2 ; 59: li $t2, 2 [0x004000b4] 0x j 0x004000c8 ; 60: j snd_label [0x004000b8] 0x2108ffff addi $8, $8, -1 ; 62: [0x004000bc] 0x addu $4, $0, $8 ; 63: move $a0, $t0 [0x004000c0] 0x0c jal 0x [f] ; 64: jal f [0x004000c4] 0x addu $10, $0, $8 ; 65: move $t2, $t0 [0x004000c8] 0x2108ffff addi $8, $8, -1 ; 67: [0x004000cc] 0x000a4021 addu $8, $0, $10 ; 68: move $t0, $t2 [0x004000d0] 0x2108ffff addi $8, $8, -1 ; 70: [0x004000d4] 0x1d00fff0 bgtz $8-64 [loop-0x004000d4] ; 71: bgtz $t0, loop [0x004000d8] 0x ori $2, $0, 0 ; 73: li $v0, 0 [0x004000dc] 0x8fbf0014 lw $31, 20($29) ; 74: lw $ra, 20($sp) # restaure l'adresse de retour [0x004000e0] 0x8fbe0010 lw $30, 16($29) ; 75: lw $fp, 16($sp) # restaure le cadre d'activation [0x004000e4] 0x27bd0020 addiu $29, $29, 32 ; 76: addiu $sp, $sp, 32 # restaure le pointeur de pile [0x004000e8] 0x03e00008 jr $31 ; 77: jr $ra # retourne à l'appelant Ainsi le résultat de la compilation du code pour la cible MIPS à partir de notre programme original peut être 8fa a a c230210c10001d a c27bdf fe0afbf0014afbe001027be001c c e c c c c8fbf00148fbe001027bd002003e bdffe0afbf0014afbe001027be001c afffe ffff a082a a ffff c ffff000a ffff1d00fff fbf00148fbe001027bd002003e transformé en binaire pour la partie segment de code commençant à l adresse 0x Question 1.2 Procédures locales de compilation La phase de production de code s effectue à l aide d une simple propagation sur le graphe de contrôle : class CodeProductionTask : public VirtualTask. Cette propagation ne passe qu une et une seule fois sur les instructions. Indiquez brièvement la suite des opérations que doit faire notre tâche de production de code lorsqu elle rencontre : une expression de type VirtualExpression, une instruction if de type IfExpression, un label de type LabelInstruction, un goto de type GotoInstruction, un return de type ReturnInstruction. en précisant les champs à rajouter dans les structures de données existantes afin que cette phase de production de code se comporte correctement. Par exemple, il est nécessaire de rajouter dans la classe LabelInstruction un champ int32 ucodeaddress indiquant à quel emplacement dans le code se trouve notre étiquette pour que la production de code correspondant au GotoInstruction corresponde à un saut au bon emplacement. 5/6

6 Question 1.3 Passe de production de code (à faire éventuellement après la mise sous forme SSA et après une passe d optimisation et d allocation des registres) Implantez la passe de production de code en sauvegardant cette passe dans une chaîne de caractères, avant de sauvegarder cette chaîne de caractères sur un fichier. Vérifier que le code produit correspond à l assembleur de la question 1.1 sur l exemple du début de TD et simuler l exécution du code produit sous PCSpim. Références : Computer Architecture: A Quantitative Approach de John L. Hennessy, David A. Patterson définit comment sont implantés sur silicium des processeurs de type MIPS. Assemblers, Linkers, and the SPIM Simulator : définit les caractéristiques propres du jeu d instruction MIPS utilisé dans ce TD. Executable and Linkable Format (ELF) : définit un format d exécutable avec ses problématiques associées (compilation de code objet, chargement de code, de bibliothèques dynamiques). 6/6