18 octobre 2007Cours de compilation 7 - Intranet1 Cours de compilation Génération de code Optimisation de code.

Présentation au sujet: "18 octobre 2007Cours de compilation 7 - Intranet1 Cours de compilation Génération de code Optimisation de code."— Transcription de la présentation:

1 18 octobre 2007Cours de compilation 7 - Intranet1 Cours de compilation Génération de code Optimisation de code

2 18 octobre 2007Cours de compilation 7 - Intranet2 Les grandes lignes du cours Définitions de base Définitions de base Composition de compilateurs Composition de compilateurs Lenvironnement dun compilateur Lenvironnement dun compilateur Evaluation partielle et compilation Evaluation partielle et compilation Analyses lexicales et syntaxiques Analyses lexicales et syntaxiques Techniques danalyse descendantes Techniques danalyse descendantes Techniques danalyse ascendantes Techniques danalyse ascendantes YACC YACC Analyse sémantique Analyse sémantique Environnement dexécution Environnement dexécution Génération de code Génération de code Optimisation de code Optimisation de code

3 18 octobre 2007Cours de compilation 7 - Intranet3 Génération de code ---------------------------------------------------------------- Nous pouvons,Nous pouvons, –soit, réécrire larbre de syntaxe abstraite dans un autre langage évolué, –soit, écrire un code de type assembleur, plus précisément un code pour une machine à pile (virtuelle),pour une machine à pile (virtuelle), ou pour un processeur donné.ou pour un processeur donné.

4 18 octobre 2007Cours de compilation 7 - Intranet4 Machine à pile ---------------------------------------------------------------- Nous utilisons typiquement une notation post-fixée.Nous utilisons typiquement une notation post-fixée. Exemple : Exemple : := x+ *y xz push @x push y push z push x multaddset

5 18 octobre 2007Cours de compilation 7 - Intranet5 Machine à pile ---------------------------------------------------------------- Voici les opérations et leurs effets sur la pile.Voici les opérations et leurs effets sur la pile. –push x –add –set... x a b a + b val adr devient devient devient + affectation

6 18 octobre 2007Cours de compilation 7 - Intranet6 Machine à pile ---------------------------------------------------------------- Détaillons quelques opérations de génération de code.Détaillons quelques opérations de génération de code. calcul_:= calcul_adr ( lhs ) calcul_val ( rhs ) calcul_val ( rhs ) gencode ( « set » ) gencode ( « set » ) calcul_adr ( lhs ) si lhs = var gencode ( « push », @var ) si lhs = var gencode ( « push », @var ) si lhs = var [ind] calcul_val ( ind ) si lhs = var [ind] calcul_val ( ind ) calcul_adr ( var ) calcul_adr ( var ) gencode ( « add » ) gencode ( « add » )

7 18 octobre 2007Cours de compilation 7 - Intranet7 Machine à pile ---------------------------------------------------------------- Détaillons quelques opérations de génération de code.Détaillons quelques opérations de génération de code. calcul_val ( rhs ) si rhs = cste gencode ( « push », rhs ) si rhs = cste gencode ( « push », rhs ) si lhs = var gencode ( « push », var ) si lhs = var gencode ( « push », var ) si lhs = var [ind] calcul_adr ( lhs ) si lhs = var [ind] calcul_adr ( lhs ) gencode ( « fetch » ) gencode ( « fetch » ) si rhs = a op b calcul_val ( b ) si rhs = a op b calcul_val ( b ) calcul_val ( a ) calcul_val ( a ) gencode ( « add » ) gencode ( « add » )

8 18 octobre 2007Cours de compilation 7 - Intranet8 Machine à pile ---------------------------------------------------------------- Bilan :Bilan : –La génération de code est très simple! –Le code est portable à cause de la machine virtuelle ! –Ce nest pas très efficace, car : Le code est interprété !Le code est interprété ! Il est simulé !Il est simulé ! Il nest pas pipeliné,... !Il nest pas pipeliné,... !

9 18 octobre 2007Cours de compilation 7 - Intranet9 Processeur donné ---------------------------------------------------------------- Commentaire :Commentaire : –Le code est nest plus portable ! –Il est (très) effiace ! ! ! –Cest plus difficile, car : Nous tenons compte dun jeu dinstruction donné !Nous tenons compte dun jeu dinstruction donné ! Nous devons considérer le nombre de registres !Nous devons considérer le nombre de registres ! Nous devons prendre en compte les primitives et caractéristiques du système dexploitation !Nous devons prendre en compte les primitives et caractéristiques du système dexploitation !

10 18 octobre 2007Cours de compilation 7 - Intranet10 Processeur donné ---------------------------------------------------------------- Nous décomposons la traduction :Nous décomposons la traduction : Syntaxe abstraite Code intermédiaire Code processeur optimisé - Proche du processeur final ! - Suffisamment générale pour permettre des optimisations ! permettre des optimisations !

11 18 octobre 2007Cours de compilation 7 - Intranet11 Code 3 - adresses ---------------------------------------------------------------- Code intermédiaire 3-adresses ( parfois 2- ), syntaxe :Code intermédiaire 3-adresses ( parfois 2- ), syntaxe : (1) x z (8) x z (8) x <- y [ z ] (2) x y (9) x [ y ] y (9) x [ y ] <- z (3) x <- y (10) x <- &y (4) goto L (11) x <- *y (5) if x y goto L (12) *x y goto L (12) *x <- y (6) param a_1...... param a_k param a_k call f, k call f, k (7) return Les instructions complexes deviennent une séquence dinstructions 3-adresses qui utilisent des variables temporaires.

12 18 octobre 2007Cours de compilation 7 - Intranet12 Code 3 - adresses ---------------------------------------------------------------- Code intermédiaire 3-adresses ( parfois 2- ), syntaxe :Code intermédiaire 3-adresses ( parfois 2- ), syntaxe : (1) x z (8) x z (8) x <- y [ z ] (2) x y (9) x [ y ] y (9) x [ y ] <- z (3) x <- y (10) x <- &y (4) goto L (11) x <- *y (5) if x y goto L (12) *x y goto L (12) *x <- y (6) param a_1...... param a_k param a_k call f, k call f, k (7) return x = ( x + y ) * z => t <- x + y t <- t * z x <- t

13 18 octobre 2007Cours de compilation 7 - Intranet13 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si E = id : E.place = id.place E.code = E.code = Si E = E op E : E.place = newtemp () E.place = newtemp () E.code = E.code ; E.code ; E.code = E.code ; E.code ; gencode ( E.place « <- » gencode ( E.place « <- » E.place op E.place ) E.place op E.place ) 1 1 2 2 1 2

14 18 octobre 2007Cours de compilation 7 - Intranet14 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si S qui est id := E : S.code = E.code ; S.code = E.code ; gencode ( id.place « <- » E.place ) gencode ( id.place « <- » E.place ) Si S est S ; S : S.code = S.code ; S.code S.code = S.code ; S.code 12 2 1

15 18 octobre 2007Cours de compilation 7 - Intranet15 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Si S est while E do S : Soient S.begin = newlabel () et S.after = newlabel () S.code = S.code = gencode ( « S.begin: » ) ; E.code ; gencode ( « S.begin: » ) ; E.code ; gencode ( « if » E.place « =0 goto » S.after ) ; gencode ( « if » E.place « =0 goto » S.after ) ; S.code ; S.code ; gencode ( « goto » S.begin ) ; gencode ( « goto » S.begin ) ; gencode ( « S.after: » ) ; gencode ( « S.after: » ) ; 1 1

16 18 octobre 2007Cours de compilation 7 - Intranet16 Génération de code intermédiaire ---------------------------------------------------------------- Pour toute expression E, nous auronsPour toute expression E, nous aurons –E.code qui est le code qui calcule E, –E.place qui est lendroit où nous trouvons le résultat ! Pour une instruction S, nous naurons que S.place !Pour une instruction S, nous naurons que S.place ! Cette générationCette génération –utilise beaucoup de temporaires, –utilise beaucoup de copies de variable à variable ! Nous nous en occuperont dans la suite !Nous nous en occuperont dans la suite ! Pour linstant, nous avons un code correct ! ! !Pour linstant, nous avons un code correct ! ! !

17 18 octobre 2007Cours de compilation 7 - Intranet17 Optimisation du code intermédiaire ---------------------------------------------------------------- Il fautIl faut –tenir compte du nombre de registres, –veiller à garder le pipeline plein ! Loptimisation du code intermédiaireLoptimisation du code intermédiaire –redresse les imperfections du code intermédiaire, –redresse les imperfections du code utilisateur ! La suite des instructions est découpée en de séquences appelées « blocs fondamentaux » !La suite des instructions est découpée en de séquences appelées « blocs fondamentaux » ! Un « bloc fondamental » correspond à une séquence dinstructions exécutées de la première à la dernière sans interruption !Un « bloc fondamental » correspond à une séquence dinstructions exécutées de la première à la dernière sans interruption !

18 18 octobre 2007Cours de compilation 7 - Intranet18 Le bloc fondamental ---------------------------------------------------------------- Il faut dabord identifier les « têtes de bloc ». Ce sont :Il faut dabord identifier les « têtes de bloc ». Ce sont : –la première instruction du programme, –toute instruction atteinte par un « goto », –toute instruction suivant un « goto », –sachant que les fonctions et procédures sont assimilées à des « goto » ! Un « bloc fondamental » estUn « bloc fondamental » est –une tête de bloc, –et toutes les instructions qui la suivent jusquà la fin du programme,la fin du programme, ou la prochaine tête de bloc, non incluse !ou la prochaine tête de bloc, non incluse !

19 18 octobre 2007Cours de compilation 7 - Intranet19 Le bloc fondamental ---------------------------------------------------------------- S.begin : if... goto S.after if... goto S.after goto S.begin goto S.begin S.after : Têtes de bloc ! Blocs !

20 18 octobre 2007Cours de compilation 7 - Intranet20 Le bloc fondamental ---------------------------------------------------------------- Le graphe de dépendance des blocs :Le graphe de dépendance des blocs : –Son objectif est de dire comment les blocs se suivent potentiellement ! –Cest un graphe orienté ! –Les sommets correspondent aux blocs ! –Les dépendances correspondent aux arcs ! Nous avons A - > B siNous avons A - > B si –la tête de B est atteinte par un goto depuis A, –B suit séquentiellement A et celui-ci se termine par un goto conditionnel !

21 18 octobre 2007Cours de compilation 7 - Intranet21 Le bloc fondamental ---------------------------------------------------------------- S.begin : if... goto S.after if... goto S.after goto S.begin goto S.begin S.after : 1 2 3

22 18 octobre 2007Cours de compilation 7 - Intranet22 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. a <- b + c b <- a – d c <- b + c d <- a - d a <- b + c b <- a – d c <- b + c d <- b La valeur de b change entre les deux expressions !

23 18 octobre 2007Cours de compilation 7 - Intranet23 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. –Elimination de code mort. Toute affectation de « variable du compilateur » ( temporaire ) qui nest pas utilisée dans la suite du bloc !Toute affectation de « variable du compilateur » ( temporaire ) qui nest pas utilisée dans la suite du bloc ! Toute « variable locale » dont on sait quelle nest pas utilisée dans la suite ( il faut plus dinformations ) !Toute « variable locale » dont on sait quelle nest pas utilisée dans la suite ( il faut plus dinformations ) !

24 18 octobre 2007Cours de compilation 7 - Intranet24 Le bloc fondamental ---------------------------------------------------------------- Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc : –Elimination de sous-expressions communes. –Elimination de code mort. –Renommage des variables temporaires, qui peuvent de ce fait devenir des registres. –Echange de lordre des calculs, si les dépendances entre les instructions le permettent. Ces transformations sont possibles parce que le bloc est exécuté intégralement et sans interruption !Ces transformations sont possibles parce que le bloc est exécuté intégralement et sans interruption !

25 18 octobre 2007Cours de compilation 7 - Intranet25 Durée de vie des variables ---------------------------------------------------------------- Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) !Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) ! –Pour les variables du compilateur cest facile à savoir ! –Pour les variables de lutilisateur qui sont locales, nous pourrons faire des choses ! –Pour les variables de lutilisateur qui sont globales, nous ne pouvons en gros rien faire !

26 18 octobre 2007Cours de compilation 7 - Intranet26 Durée de vie des variables ---------------------------------------------------------------- Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) !Il est important de savoir à partir de quand une variable nest plus utilisée ( noccupe donc plus de registre,... ) ! –Pour les variables du compilateur cest facile à savoir ! –Pour les variables de lutilisateur qui sont locales, nous pourrons faire des choses ! –Pour les variables de lutilisateur qui sont globales, nous ne pouvons en gros rien faire ! Nous voulons savoirNous voulons savoir –« qui définit quoi ? », –« qui utilise quoi ? » !

27 18 octobre 2007Cours de compilation 7 - Intranet27 Durée de vie des variables ---------------------------------------------------------------- A titre dillustration, nous associons à une variableA titre dillustration, nous associons à une variable –live ou live –no-use ou un numéro dinstruction Nous initialisons les états de variables et nous parcourons le programme à lenvers !Nous initialisons les états de variables et nous parcourons le programme à lenvers ! Initialisation :Initialisation : –Toutes les variables : no-use –Les variables globales : live –Les variables locales et temporaires : live, si elles sont lues dans un bloc successeur, live, si elles sont lues dans un bloc successeur, live, sinon. live, sinon.

28 18 octobre 2007Cours de compilation 7 - Intranet28 Durée de vie des variables ---------------------------------------------------------------- A titre dillustration, nous associons à une variableA titre dillustration, nous associons à une variable –live ou live –no-use ou un numéro dinstruction Nous initialisons les états de variables et nous parcourons le programme à lenvers !Nous initialisons les états de variables et nous parcourons le programme à lenvers ! Pour toute instruction i : x < - y op zPour toute instruction i : x < - y op z –Nous attachons à i les informations sur x, y et z. –x devient live et no-use. –y et z deviennent live et de numéro i. Attention à lordre, car la variable x pourrait être identique à y ou z !

29 18 octobre 2007Cours de compilation 7 - Intranet29 Durée de vie des variables ---------------------------------------------------------------- Une illustration, avec t temporaire locale au bloc :Une illustration, avec t temporaire locale au bloc : ( 1 ) x <- y + t ( 2 ) y <- x + y ( 3 ) x <- y - z live : x, y, z live : t x, y, z, t : no-use live : y, z live : x, t x, t : no-use y, z : 3 live : x, y, z live : t t : no-use x, y : 2 z : 3 live : y, z, t live : x x : no-use y, t : 1 z : 3 Pour t :

30 18 octobre 2007Cours de compilation 7 - Intranet30 Durée de vie des variables ---------------------------------------------------------------- Nous pouvons affiner les informations par une analyse qui englobe plusieurs blocs ( inter-bloc ) !Nous pouvons affiner les informations par une analyse qui englobe plusieurs blocs ( inter-bloc ) ! –Nous supposons, par défaut, que les variables doivent être vivantes ! –Nous essayons ensuite de montrer que certaines variables sont en fait inutiles ! –Souvent lanalyse est obtenu par itérations jusquà atteindre un point-fixe ! –Ceci veut dire que nous nous arrêtons seulement lorsque la dernière itération na plus apporté de modifications !

31 18 octobre 2007Cours de compilation 7 - Intranet31 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y)

32 18 octobre 2007Cours de compilation 7 - Intranet32 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) PROBLEME

33 18 octobre 2007Cours de compilation 7 - Intranet33 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) Itération 2 :

34 18 octobre 2007Cours de compilation 7 - Intranet34 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) Itération 2 : Itération 3 :

35 18 octobre 2007Cours de compilation 7 - Intranet35 Durée de vie des variables ---------------------------------------------------------------- y <- 3 x <- 5 si x = 0 goto FIN FIN : y <- x+1 Les flèches donnent les dépendances ! L(x) L(y) Par hypothèse, les variables sont vivantes! x <- x-1 y <- x Itération 1 : L(x) L(y) L(x) L(y) L(x) L(y) Itération 2 : Itération 3 :

36 18 octobre 2007Cours de compilation 7 - Intranet36 Durée de vie des variables ---------------------------------------------------------------- x <- 5 si x = 0 goto FIN FIN : y <- x+1 x <- x-1