Introduction a la compilation Aperçu de la compilation / Assembleur MIPS - C1
2 j'aime2,827 vues
Ce document présente le cours d'introduction à la compilation à l'université Paris-Sud, sous la direction de Sylvain Conchon. Il couvre les objectifs, les techniques de compilation, ainsi que les détails sur la programmation en Objective Caml, les phases d'un compilateur, et l'architecture MIPS à utiliser dans le cours. Les étudiants apprendront à maîtriser les mécanismes de compilation, l'analyse de programmes, et à utiliser des outils comme des simulateurs MIPS.
![Jeu d’instructions : transfert (lecture)
´
lire un mot (32 bits) en memoire
lw
$a0, 42($a1)
# a0 <- mem[a1 + 42]
´
´
´
l’adresse est donnee par un registre et un decalage sur 16 bits signes
´
variantes pour lire 8 ou 16 bits, signes ou non (lb, lh, lbu, lhu)
33](https://image.slidesharecdn.com/c1-131230053824-phpapp01/85/Introduction-a-la-compilation-Apercu-de-la-compilation-Assembleur-MIPS-C1-33-320.jpg)
![´
Jeu d’instructions : transfert (ecriture)
´
´
ecrire un mot (32 bits) en memoire
sw
$a0, 42($a1)
# mem[a1 + 42] <- a0
# attention au sens !
´
´
´
l’adresse est donnee par un registre et un decalage sur 16 bits signes
´
variantes pour ecrire 8 ou 16 bits (sb, sh)
34](https://image.slidesharecdn.com/c1-131230053824-phpapp01/85/Introduction-a-la-compilation-Apercu-de-la-compilation-Assembleur-MIPS-C1-34-320.jpg)
Introduction a la compilation Aperçu de la compilation / Assembleur MIPS - C1
- 1. ´ Universite Paris-Sud ` Introduction a la compilation Sylvain Conchon Cours 1 / 5 septembre 2013
- 2. ´ Presentation du cours cours le jeudi, 10h45–12h45 en petit amphi (PUIO) ´ pas de polycopie, mais transparents disponibles TD le lundi, 14h00–16h30, avec Sylvain Conchon le mercredi, 8h30–11h00, avec Kim Nguyen ´ evaluation ˆ partiel + controle continu + examen toutes les infos sur le site web du cours http://www.lri.fr/~conchon/compilation/ 2
- 3. Remerciements ` ˆ ´ ` a Jean-Christophe Filliatre pour le materiel de son cours de compilation a l’ENS Ulm 3
- 4. Objectif du cours ´ ` maˆtriser les mecanismes de la compilation, c’est-a-dire de la ı transformation d’un langage dans un autre ´ comprendre les differents aspects des langages de programmation par le biais de la compilation 4
- 5. Les techniques vues dans ce cours sont aussi . . . . . . utiles pour concevoir des outils qui manipulent les programmes de ` maniere symbolique, comme les outils de preuve de programmes (VCC, Dafny, Spec#, Frama-C, Spark, GNATProve, Why3, Boogie, etc.) ´ verification par model checking (Slam, Spin, CBMC, Murphi, Cubicle, Blast, Uppaal, Java Pathfinder, etc.) ´ ´ analyse par interpretation abstraite (Astree, polyspace, etc.) ´ demonstration automatique (z3, cvc4, Alt-Ergo, etc.), test formel (Pex, PathCrowler, etc.) etc. 5
- 6. Programmation ici on programme en cours en TD ´ pour realiser le projet ` a l’examen on programme en Objective Caml 6
- 7. Un peu de lecture 7
- 8. Compilation ´ schematiquement, un compilateur est un programme qui traduit un programme d’un langage source vers un langage cible, en signalant ´ d’eventuelles erreurs langage source compilateur langage cible erreurs 8
- 9. Compilation vers le langage machine ` quand on parle de compilation, on pense typiquement a la traduction d’un langage de haut niveau (C, Java, Caml, ...) vers le langage machine d’un processeur (Intel Pentium, PowerPC, ...) % gcc -o sum sum.c source sum.c compilateur C (gcc) int main(int argc, char **argv) { int i, s = 0; for (i = 0; i <= 100; i++) s += i*i;−→ printf("0*0+...+100*100 = %dn", s); } executable sum 00100111101111011111111111100000 10101111101111110000000000010100 10101111101001000000000000100000 10101111101001010000000000100100 10101111101000000000000000011000 10101111101000000000000000011100 10001111101011100000000000011100 ... 9
- 10. Langage cible ´ ` dans ce cours, nous allons effectivement nous interesser a la compilation vers de l’assembleur, mais ce n’est qu’un aspect de la compilation un certain nombre de techniques mises en œuvre dans la compilation ne ´ ` sont pas liees a la production de code assembleur certains langages sont d’ailleurs ´ ´ interpretes (Basic, COBOL, Ruby, etc.) ´ ´ ´ ´ compiles dans un langage intermediaire qui est ensuite interprete (Java, Caml, etc.) ´ compiles vers un autre langage de haut niveau ´ ` ´ compiles a la volee 10
- 11. ´ ` Difference entre compilateur et interprete un compilateur traduit un programme P en un programme Q tel que ´ ˆ pour toute entree x, la sortie de Q(x) soit la meme que celle de P (x) ∀P ∃Q ∀x... ´ ´ ` un interprete est un programme qui, etant donne un programme P et une ´ entree x, calcule la sortie s de P (x) ∀P ∀x ∃s... 11
- 12. ´ ` Difference entre compilateur et interprete dit autrement, le compilateur fait un travail complexe une seule fois, pour produire un ´ code fonctionnant pour n’importe quelle entree ` ´ l’interprete effectue un travail plus simple, mais le refait sur chaque entree ´ ´ ´ ´ autre difference : le code compile est generalement bien plus efficace que ´ ´ le code interprete 12
- 13. ´ Exemple de compilation et d’interpretation source gs fichier PostScript lilypond image << chords { c2 c f2 c } new Staff relative c’ { time 2/4 c4 c g’4 g a4 a g2 } new Lyrics lyricmode { twin4 kle twin kle lit tle star2 >> C C F C 2 4 twin kle twin kle lit tle star 13
- 14. ´ Qualite d’un compilateur ` ´ A quoi juge-t-on la qualite d’un compilateur ? ` a sa correction ` ´ a l’efficacite du code qu’il produit ` ´ a sa propre efficacite 14
- 15. Phases d’un compilateur typiquement, le travail d’un compilateur se compose d’une phase d’analyse ` reconnaˆt le programme a traduire et sa signification ı ´ signale les erreurs et peut donc echouer ´ (erreurs de syntaxe, de portee, de typage, etc.) ` puis d’une phase de synthese production du langage cible ´ utilise de nombreux langages intermediaires ´ n’echoue pas 15
- 16. Phase d’analyse source ↓ analyse lexicale ↓ ` suite de lexemes (tokens) ↓ analyse syntaxique ↓ arbre de syntaxe abstraite (AST ) ↓ ´ analyse semantique ↓ syntaxe abstraite + table des symboles 16
- 17. ` Phase de synthese syntaxe abstraite ↓ production de code (nombreuses phases) ↓ langage assembleur ↓ assembleur (as) ↓ langage machine ↓ ´ editeur de liens (ld) ↓ ´ code executable 17
- 18. l’assembleur MIPS (voir la documentation sur la page du cours) 18
- 19. Un peu d’architecture ` ´ ´ tres schematiquement, un ordinateur est compose ´ d’une unite de calcul (CPU), contenant un petit nombre de registres entiers ou flottants ´ des capacites de calcul ´ d’une memoire vive (RAM) ´ ` composee d’un tres grand nombre d’octets (8 bits) 33 ´ par exemple, 1 Go = 230 octets = 233 bits, soit 22 etats possibles ´ contient des donnees et des instructions 19
- 20. Un peu d’architecture RAM CPU $pc 0000052 $a0 0000012 $a1 0000040 $a2 0000022 $a3 0000000 $v0 0000000 ... ` ` ´ ` l’acces a la memoire coute cher (a un milliard d’instructions par seconde, ˆ ` ` la lumiere ne parcourt que 30 centimetres entre 2 instructions !) 20
- 21. Un peu d’architecture ´ ´ la realite est bien plus complexe ´ ´ plusieurs (co)processeurs, dont certains dedies aux flottants un ou plusieurs caches ´ une virtualisation de la memoire (MMU) etc. 21
- 22. ´ Principe d’execution ´ ´ ´ schematiquement, l’execution d’un programme se deroule ainsi ` ´ un registre ($pc) contient l’adresse de l’instruction a executer ` on lit les 4 (ou 8) octets a cette adresse (fetch) ` on interprete ces bits comme une instruction (decode) ´ on execute l’instruction (execute) ` on modifie le registre $pc pour passer a l’instruction suivante ` (typiquement celle se trouvant juste apres, sauf en cas de saut) 22
- 23. ´ Principe d’execution RAM CPU $pc 0000052 $a0 0000012 $a1 0000040 $a2 0000022 $a3 0000000 $v0 0000000 ... instruction : 000000 00001 00010 0000000000001010 ´ decodage : add $a1 $a2 10 ´ i.e. ajouter 10 au registre $a1 et stocker le resultat dans le registre $a2 23
- 24. ´ Principe d’execution ` ´ ´ la encore la realite est bien plus complexe pipelines ´ ´ ` plusieurs instructions sont executees en parallele ´ prediction de branchement ´ pour optimiser le pipeline, on tente de predire les sauts conditionnels 24
- 25. Quelle architecture pour ce cours ? deux grandes familles de microprocesseurs CISC (Complex Instruction Set) beaucoup d’instructions beaucoup de modes d’adressage ´ ´ beaucoup d’instructions lisent / ecrivent en memoire peu de registres exemples : VAX, PDP-11, Motorola 68xxx, Intel x86 RISC (Reduced Instruction Set) ´ ` peu d’instructions, regulieres ` ´ ´ tres peu d’instructions lisent / ecrivent en memoire beaucoup de registres, uniformes exemples : Alpha, Sparc, MIPS, ARM on choisit MIPS pour ce cours (les TD et le projet) 25
- 26. L’architecture MIPS ` 32 registres, r0 a r31 r0 contient toujours 0 ` utilisables sous d’autres noms, correspondant a des conventions (zero, at, v0–v1, a0–a3, t0–t9, s0–s7, k0–k1, gp, sp, fp, ra) trois types d’instructions ´ instructions de transfert, entre registres et memoire instructions de calcul instructions de saut documentation : sur le site du cours 26
- 27. Simulateurs MIPS en pratique, on utilisera un simulateur MIPS, MARS (ou SPIM) en ligne de commande java -jar Mars 4 2.jar file.s en mode graphique et interactif java -jar Mars 4 2.jar charger le fichier et l’assembler ` ´ mode pas a pas, visualisation des registres, de la memoire, etc. documentation : sur le site du cours 27
- 28. Jeu d’instructions : constantes, adresses et copies ´ chargement d’une constante (16 bits signee) dans un registre li lui $a0, 42 $a0, 42 # a0 <- 42 # a0 <- 42 * 2^16 copie d’un registre dans un autre move $a0, $a1 # copie a1 dans a0 ! 28
- 29. ´ Jeu d’instructions : arithmetique addition de deux registres add add $a0, $a1, $a2 $a2, $a2, $t5 # a0 <- a1 + a2 # a2 <- a2 + t5 ˆ de meme, sub, mul, div addition d’un registre et d’une constante addi $a0, $a1, 42 # a0 <- a1 + 42 (mais pas subi, muli ou divi !) ´ negation neg $a0, $a1 # a0 <- -a1 $a0, $a1 # a0 <- |a1| valeur absolue abs 29
- 30. ´ Jeu d’instructions : operations sur les bits NON logique (not(1001112 ) = 0110002 ) not $a0, $a1 # a0 <- not(a1) ET logique (and(1001112 , 1010012 ) = 1000012 ) and $a0, $a1, $a2 # a0 <- and(a1, a2) andi $a0, $a1, 0x3f # a0 <- and(a1, 0...0111111) OU logique (or(1001112 , 1010012 ) = 1011112 ) or ori $a0, $a1, $a2 $a0, $a1, 42 # a0 <- or(a1, a2) # a0 <- or(a1, 0...0101010) 30
- 31. ´ Jeu d’instructions : decalages ´ ` ´ decalage a gauche (insertion de zeros) sll $a0, $a1, 2 sllv $a1, $a2, $a3 # a0 <- a1 * 4 # a1 <- a2 * 2^a3 ´ ` ´ decalage a droite arithmetique (copie du bit de signe) sra $a0, $a1, 2 # a0 <- a1 / 4 ´ ` ´ decalage a droite logique (insertion de zeros) srl $a0, $a1, 2 rol ror $a0, $a1, 2 $a0, $a1, 3 rotation 31
- 32. Jeu d’instructions : tests comparaison de deux registres slt $a0, $a1, $a2 # a0 <- 1 si a1 < a2 # 0 sinon ou d’un registre et d’une constante slti $a0, $a1, 42 ´ variantes : sltu (comparaison non signee), sltiu ˆ de meme : sle, sleu / sgt, sgtu / sge, sgeu ´ ´ egalite : seq, sne 32
- 33. Jeu d’instructions : transfert (lecture) ´ lire un mot (32 bits) en memoire lw $a0, 42($a1) # a0 <- mem[a1 + 42] ´ ´ ´ l’adresse est donnee par un registre et un decalage sur 16 bits signes ´ variantes pour lire 8 ou 16 bits, signes ou non (lb, lh, lbu, lhu) 33
- 34. ´ Jeu d’instructions : transfert (ecriture) ´ ´ ecrire un mot (32 bits) en memoire sw $a0, 42($a1) # mem[a1 + 42] <- a0 # attention au sens ! ´ ´ ´ l’adresse est donnee par un registre et un decalage sur 16 bits signes ´ variantes pour ecrire 8 ou 16 bits (sb, sh) 34
- 35. Jeu d’instructions : branchements et sauts on distingue branchement : typiquement un saut conditionnel, dont le ´ ´ ´ ` deplacement est stocke sur 16 bits signes (-32768 a 32767 instructions) ´ saut : saut inconditionnel, dont l’adresse de destination est stockee sur 26 bits 35
- 36. Jeu d’instructions : branchements branchement conditionnel beq $a0, $a1, label # si a0 = a1 saute ` label a # ne fait rien sinon ´ variantes : bne, blt, ble, bgt, bge (et comparaisons non signees) variantes : beqz, bnez, bgez, bgtz, bltz, blez 36
- 37. Jeu d’instructions : sauts saut inconditionnel ` a une adresse (jump) j label avec sauvegarde de l’adresse de l’instruction suivante dans $ra jal label # jump and link ` a une adresse contenue dans un registre jr $a0 avec l’adresse contenue dans $a0 et sauvegarde dans $a1 jalr $a0, $a1 37
- 38. ` Jeu d’instructions : appel systeme ` ´ quelques appels systeme fournis par une instruction speciale syscall ˆ le code de l’instruction doit etre dans $v0, les arguments dans $a0–$a3 ; ´ ´ ´ le resultat eventuel sera place dans $v0 ` exemple : appel systeme print int pour afficher un entier li $v0, 1 li $a0, 42 syscall # code de print_int # valeur ` afficher a ˆ de meme read int, print string, etc. (voir la documentation) 38
- 39. Assembleur MIPS on ne programme pas en langage machine mais en assembleur ´ l’assembleur fourni un certain nombre de facilites : ´ etiquettes symboliques ´ allocation de donnees globales pseudo-instructions 39
- 40. Assembleur MIPS la directive .text 7FFFFFFC16 → indique que des instructions suivent, et la directive . . . .data ´ indique que des donnees suivent ´ ` le code sera charge a partir de l’adresse 0x400000 ´ ` et les donnees a partir de l’adresse 0x10000000 donn´es e 1000000016 → code 40000016 → (r´serv´) e e ´ une etiquette symbolique est introduite par label: ´ ˆ ´ et l’adresse qu’elle represente peut etre chargee dans un registre la $a0, label 40
- 41. Exemple : hello world main: hw: .text li la syscall li syscall .data .asciiz $v0, 4 $a0, hw $v0, 10 # # # # code de print_string adresse de la cha^ne ı appel syst`me e exit "hello worldn" ´ (.asciiz est une facilite pour .byte 104, 101, ... 0) 41
- 42. ´ Le defi de la compilation c’est de traduire un programme d’un langage de haut niveau vers ce jeu d’instructions en particulier, il faut ˆ traduire les structures de controle (tests, boucles, exceptions, etc.) traduire les appels de fonctions ´ traduire les structures de donnees complexes (tableaux, ˆ enregistrements, objets, clotures, etc.) ´ allouer de la memoire dynamiquement 42
- 43. Appels de fonctions ˆ ´ constat : les appels de fonctions peuvent etre arbitrairement imbriques ` ⇒ les registres ne peuvent suffire pour les parametres / variables locales ´ ⇒ il faut allouer de la memoire pour cela ` ` les fonctions procedent selon un mode last-in first-out, c’est-a-dire de pile 43
- 44. La pile pile ↓ ´ la pile est stockee tout en haut, et croˆt dans le ı ´ sens des adresses decroissantes ; $sp pointe sur le sommet de la pile ↑ donn´es e dynamiques (tas) donn´es e statiques ´ les donnees dynamiques (survivant aux appels de ´ ´ fonctions) sont allouees sur le tas (eventuellement ´ par un GC), en bas de la zone de donnees, juste au ´ statiques dessus des donnees code ainsi, on ne se marche pas sur les pieds 44
- 45. Appel de fonction lorsqu’une fonction f (l’appelant ou caller ) souhaite appeler une fonction g ´ ´ (l’appele ou callee), elle execute jal g ´ ´ ˆ et lorsque l’appele en a termine, il lui rend le controle avec jr $ra ` probleme : ˆ ´ ´ si g appelle elle-meme une fonction, $ra sera ecrase ˆ ´ de meme, tout registre utilise par g sera perdu pour f ` il existe de multiples manieres de s’en sortir, ´ ´ mais en general on s’accorde sur des conventions d’appel 45
- 46. Conventions d’appel utilisation des registres ´ ´ ` $at, $k0 et $k1 sont reserves a l’assembleur et l’OS ´ $a0–$a3 sont utilises pour passer les quatre premiers arguments (les ´ ´ autres sont passes sur la pile) et $v0–$v1 pour renvoyer le resultat $t0–$t9 sont des registres caller-saved i.e. l’appelant doit les ´ sauvegarder si besoin ; on y met donc typiquement des donnees qui n’ont pas besoin de survivre aux appels ´ $s0–$s7 sont des registres callee-saved i.e. l’appele doit les ´ ´ sauvegarder ; on y met donc des donnees de duree de vie longue, ayant besoin de survivre aux appels $sp est le pointeur de pile, $fp le pointeur de frame $ra contient l’adresse de retour ´ $gp pointe au milieu de la zone de donnees statiques (1000800016 ) 46
- 47. L’appel, en quatre temps il y a quatre temps dans un appel de fonction 1 pour l’appelant, juste avant l’appel 2 ´ ´ pour l’appele, au debut de l’appel 3 ´ ` pour l’appele, a la fin de l’appel 4 ` pour l’appelant, juste apres l’appel ´ ´ s’organisent autour d’un segment situe au sommet de la pile appele le ´ tableau d’activation, en anglais stack frame, situe entre $fp et $sp 47
- 48. L’appelant, juste avant l’appel 1 passe les arguments dans $a0–$a3, les autres sur la pile s’il y en a plus de 4 2 ` sauvegarde les registres $t0–$t9 qu’il compte utiliser apres l’appel (dans son propre tableau d’activation) 3 ´ execute jal appel´ e 48
- 49. ´ ´ L’appele, au debut de l’appel 1 alloue son tableau d’activation, par exemple addi 2 $sp, $sp, -28 $fp→ registres sauv´s e sauvegarde $fp puis le positionne, par exemple sw addi variables locales $fp, 24($sp) $fp, $sp, 24 $sp→ 3 sauvegarde $s0–$s7 et $ra si besoin ... argument 5 argument 6 ↓ $fp permet d’atteindre facilement les arguments et variables locales, avec ´ ´ un decalage fixe quel que soit l’etat de la pile 49
- 50. ´ ` L’appele, a la fin de l’appel 1 ´ place le resultat dans $v0 (voire $v1) 2 ´ restaure les registres sauvegardes 3 ´ depile son tableau d’activation, par exemple addi $sp, $sp, 28 4 ´ execute jr $ra 50
- 51. ` L’appelant, juste apres l’appel 1 ´ ´ depile les eventuels arguments 5, 6, ... 2 restaure les registres caller-saved 51
- 52. Exercice exercice : programmer la fonction factorielle 52
- 53. ´ Recapitulation une machine fournit ´ ` un jeu limite d’instructions, tres primitives ` ` ´ des registres efficaces, un acces couteux a la memoire ˆ ´ ´ ´ la memoire est decoupee en ´ ´ code / donnees statiques / tas (donnees dynamiques) / pile les appels de fonctions s’articulent autour d’une notion de tableau d’activation de conventions d’appel 53
- 54. Un exemple de compilation t(a,b,c){int d=0,e=a&~b&~c,f=1;if(a) for(f=0;d=(e-=d)&-e;f+=t(a-d,(b+d)*2, (c+d)/2));return f;}main(q){scanf("%d", &q);printf("%dn",t(~(~0<<q),0,0));} 54
- 55. Clarification int t(int a, int b, int c) { int d=0, e=a&~b&~c, f=1; if (a) for (f=0; d=(e-=d)&-e; f+=t(a-d, (b+d)*2, (c+d)/2)); return f; } int main() { int q; scanf("%d", &q); printf("%dn", t(~(~0<<q), 0, 0)); } 55
- 56. Clarification (suite) int t(int a, int b, int c) { int f=1; if (a) { int d, e=a&~b&~c; f = 0; while (d=e&-e) { f += t(a-d, (b+d)*2, (c+d)/2); e -= d; } } return f; } int main() { int q; scanf("%d", &q); printf("%dn", t(~(~0<<q), 0, 0)); } ce programme calcule le nombre de solutions ` du probleme dit des n reines q q q q q q q q 56
- 57. Comment ca marche ? ¸ recherche par force brute (backtracking) ´ entiers utilises comme des ensembles : par ex. 13 = 0 · · · 011012 = {0, 2, 3} entiers 0 a&b a+b a-b ~a a&-a ~(~0<<n) a*2 a/2 ensembles ∅ a∩b a ∪ b, quand a ∩ b = ∅ a b, quand b ⊆ a a min(a), quand a = ∅ {0, 1, . . . , n − 1} ´ {i + 1 | i ∈ a}, note S(a) ´ {i − 1 | i ∈ a ∧ i = 0}, note P (a) 57
- 58. Clarification : version ensembliste int t(a, b, c) f ←1 if a = ∅ e ← (ab)c f ←0 while e = ∅ d ← min(e) f ← f + t(a{d}, S(b ∪ {d}), P (c ∪ {d})) e ← e{d} return f int queens(n) return t({0, 1, . . . , n − 1}, ∅, ∅) 58
- 59. Signification de a, b et c q q q ? ? ? ? ? ? ? ? 59
- 60. Signification de a, b et c q qqq q q q q ` a = colonnes a remplir = 111001012 59
- 61. Signification de a, b et c q qq q q q ` b = positions interdites a cause de diagonales vers la gauche = 011010002 59
- 62. Signification de a, b et c q q q q q ` c = positions interdites a cause de diagonales vers la droite = 000010012 59
- 63. Signification de a, b et c q q q q q ` a&~b&~c = positions a essayer = 100001002 59
- 64. ´ ˆ Interet de ce programme pour la compilation int t(int a, int b, int c) { int f=1; if (a) { int d, e=a&~b&~c; f = 0; while (d=e&-e) { f += t(a-d,(b+d)*2,(c+d)/2); e -= d; } } return f; } int main() { int q; scanf("%d", &q); printf("%dn", t(~(~0<<q), 0, 0)); } court, mais contient un test (if) une boucle (while) ´ une fonction recursive quelques calculs c’est aussi une excellente solution ` au probleme des n reines 60
- 65. Compilation ´ commencons par la fonction recursive t ; il faut ¸ allouer les registres compiler le test la boucle ´ l’appel recursif ´ les differents calculs 61
- 66. Allocation de registres ´ a, b et c sont passes dans $a0, $a1 et $a2 ´ ´ le resultat est renvoye dans $v0 ` les parametres a, b, c, tout comme les variables locales d, e, f, ont ˆ ´ ´ ` ´ besoin d’etre sauvegardes, car ils sont utilises apres l’appel recursif ⇒ on va utiliser des registres callee-save a b c d e f $s0 $s1 $s2 $s3 $s4 $s5 il faut donc allouer 7 mots sur la pile pour sauvegarder l’adresse de retour $ra et ces 6 registres 62
- 67. Sauvegarde / restauration des registres t: addi sw sw sw sw sw sw sw ... lw lw lw lw lw lw lw addi jr $ra $sp, $ra, $s0, $s1, $s2, $s3, $s4, $s5, $sp, -28 24($sp) 20($sp) 16($sp) 12($sp) 8($sp) 4($sp) 0($sp) # allocation de 7 mots # sauvegarde des registres $ra, $s0, $s1, $s2, $s3, $s4, $s5, $sp, 24($sp) 20($sp) 16($sp) 12($sp) 8($sp) 4($sp) 0($sp) $sp, 28 # restauration des registres # d´sallocation e 63
- 68. Compilation du test int t(int a, int b, int c) { int f=1; if (a) { ... } return f; } li beqz ... t return: move $s5, 1 $a0, t return $v0, $s5 64
- 69. ´ ´ Cas general (a = 0) if (a) { int d, e=a&~b&~c; f = 0; while ... } move move move move not and not and li $s0, $s1, $s2, $s4, $t0, $s4, $t0, $s4, $s5, $a0 # sauvegarde $a1 $a2 $s0 # e=a&~b&~c $s1 $s4, $t0 $s2 $s4, $t0 0 # f = 0 ´ noter l’utilisation d’un registre temporaire $t0 non sauvegarde 65
- 70. Compilation de la boucle L1: while (test) { body } L2: ... ... calcul de test dans $t0 ... beqz $t0, L2 ... body ... j L1 ... 66
- 71. Compilation de la boucle il existe cependant une meilleure solution L1: while (test) { body } L2: ... j L2 ... body ... ... test ... bnez $t0, L1 ainsi on fait seulement un seul branchement par tour de boucle ` ` (mis a part la toute premiere fois) 67
- 72. Compilation de la boucle j test sub add sll add srl jal add sub $a0, $a1, $a1, $a2, $a2, t $s5, $s4, body: while (d=e&-e) { f += t(a-d, (b+d)*2, (c+d)/2); e -= d; } $s0, $s1, $a1, $s2, $a2, $s3 # a-d $s3 # (b+d)*2 1 $s3 # (c+d)/2 1 $s5, $v0 $s4, $s3 # e -= d test: neg $t0, $s4 # d=e&-e and $s3, $s4, $t0 bnez $s3, body t return: ... 68
- 73. Programme principal main: li $v0, syscall li $a0, not $a0, sllv $a0, not $a0, int main() { li $a1, int q; li $a2, scanf("%d", &q); jal t printf("%dn", move $a0, t(~(~0<<q), 0, 0)); li $v0, } syscall li $v0, la $a0, syscall li $v0, syscall 5 # read_int 0 # t(...) $a0 $a0, $v0 $a0 0 0 $v0 # printf 1 4 newline 10 # exit 69
- 74. Optimisation ce code n’est pas optimal par exemple, dans le cas a = 0, on sauve/restaure inutilement les registres (y compris $ra), alors qu’on pourrait se contenter de li jr $v0, 1 $ra 70
- 75. Lecon ¸ ´ produire du code assembleur efficace n’est pas chose aisee (observer le code produit avec gcc -S -fverbose-asm ou encore ocamlopt -S) maintenant il va falloir automatiser tout ce processus 71
- 76. La semaine prochaine TD ´ ´ ´ generation de code pour un mini-langage d’expressions arithmetiques Cours analyse lexicale 72