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

18 octobre 2007 Cours de compilation 7 - Intranet 1

Cours de compilationCours de compilation

Génération de codeGénération de code

Optimisation de codeOptimisation de code

Les grandes lignes du coursLes grandes lignes du cours

•Définitions de baseDéfinitions de base•Composition de compilateursComposition de compilateurs•L’environnement d’un compilateurL’environnement d’un compilateur•Evaluation partielle et compilationEvaluation partielle et compilation•Analyses lexicales et syntaxiquesAnalyses lexicales et syntaxiques•Techniques d’analyse descendantesTechniques d’analyse descendantes•Techniques d’analyse ascendantesTechniques d’analyse ascendantes•YACCYACC•Analyse sémantiqueAnalyse sémantique•Environnement d’exécutionEnvironnement d’exécution•Génération de codeGénération de code•Optimisation de codeOptimisation de code

I N T R O D U C T I O NI N T R O D U C T I O N

Génération de codeGénération de code----------------------------------------------------------------------------------------------------------------------------

----• Nous pouvons,Nous pouvons,

– soit, réécrire l’arbre de syntaxe abstraite dans soit, réécrire l’arbre de syntaxe abstraite dans un autre langage évolué,un autre langage évolué,

– soit, écrire un code de type assembleur, plus soit, écrire un code de type assembleur, plus précisément un codeprécisément un code

• pour une machine à pile (virtuelle),pour une machine à pile (virtuelle),• ou pour un processeur donné.ou pour un processeur donné.

– soit, écrire un code de type assembleur, plus soit, écrire un code de type assembleur, plus précisément un codeprécisément un code

• pour une machine à pile (virtuelle),pour une machine à pile (virtuelle),• ou pour un processeur donné.ou pour un processeur donné.

M A C H I N EM A C H I N E

P I L EP I L E

Machine à pileMachine à pile----------------------------------------------------------------------------------------------------------------------------

----• Nous utilisons typiquement une notation post-Nous utilisons typiquement une notation post-

fixée.fixée.

Exemple :Exemple :

fixée.fixée.

Exemple :Exemple :

push @xpush @x

fixée.fixée.

Exemple :Exemple :

push @xpush @xpush ypush y

fixée.fixée.

Exemple :Exemple :

push @xpush @xpush ypush ypush zpush z

fixée.fixée.

Exemple :Exemple :

push @xpush @xpush ypush ypush zpush zpush xpush x

fixée.fixée.

Exemple :Exemple :

push @xpush @xpush ypush ypush zpush zpush xpush xmultmult

fixée.fixée.

Exemple :Exemple :

push @xpush @xpush ypush ypush zpush zpush xpush xmultmultaddadd

fixée.fixée.

Exemple :Exemple :

push @xpush @xpush ypush ypush zpush zpush xpush xmultmultaddaddsetset

----• Voici les opérations et leurs effets sur la pile.Voici les opérations et leurs effets sur la pile.

– push xpush x . . .. . .

. . .. . .

xxdevientdevient

– push xpush x

– addadd

. . .. . .

aabb a + ba + b

devientdevient

– push xpush x

– addadd

– setset. . .. . .

. . .. . .

aabb a + ba + b

valvaladradr

devientdevient

devientdevient + affectation+ affectation

----• Détaillons quelques opérations de génération de Détaillons quelques opérations de génération de

code.code.

calcul_:= calcul_adr ( lhs )calcul_:= calcul_adr ( lhs )

calcul_val ( rhs )calcul_val ( rhs )

gencode ( « set » )gencode ( « set » )

code.code.

calcul_adr ( lhs )calcul_adr ( lhs )

si lhs = var gencode ( « push » , @var )si lhs = var gencode ( « push » , @var )

code.code.

calcul_adr ( lhs )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 » )

code.code.

si rhs = cste gencode ( « push » , rhs )si rhs = cste gencode ( « push » , rhs )

code.code.

si lhs = var gencode ( « push » , var )si lhs = var gencode ( « push » , var )

code.code.

si lhs = var [ind] calcul_adr ( lhs )si lhs = var [ind] calcul_adr ( lhs )

gencode ( « fetch » )gencode ( « fetch » )

code.code.

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 » )

----• Bilan :Bilan :

– La génération de code est très simple!La génération de code est très simple!

– Le code est portable à cause de la machine Le code est portable à cause de la machine virtuelle !virtuelle !

– Ce n’est pas très efficace, car :Ce n’est pas très efficace, car :

• Le code est interprété !Le code est interprété !

• Il est simulé !Il est simulé !

• Il n’est pas pipeliné, . . . !Il n’est pas pipeliné, . . . !

U NU N

P R O C E S S E U RP R O C E S S E U R

E TE T

U NU N

O / SO / S

Processeur donnéProcesseur donné----------------------------------------------------------------------------------------------------------------------------

----• Commentaire :Commentaire :

– Le code est n’est plus portable !Le code est n’est plus portable !

– Il est (très) effiace ! ! !Il est (très) effiace ! ! !

– C’est plus difficile, car :C’est plus difficile, car :

• Nous tenons compte d’un jeu d’instruction Nous tenons compte d’un jeu d’instruction donné !donné !

• Nous devons considérer le nombre de registres !Nous devons considérer le nombre de registres !

• Nous devons prendre en compte les primitives Nous devons prendre en compte les primitives et caractéristiques du système d’exploitation !et caractéristiques du système d’exploitation !

----• Nous décomposons la traduction :Nous décomposons la traduction :

Syntaxe abstraiteSyntaxe abstraite

Code intermédiaireCode intermédiaire

Code processeur optimiséCode processeur optimisé

Syntaxe abstraiteSyntaxe abstraite

Code intermédiaireCode intermédiaire

Code processeur optimiséCode processeur optimisé

-- Proche du processeur Proche du processeur final !final !

-- Suffisamment générale Suffisamment générale pourpour permettre des permettre des optimisations !optimisations !

Code 3Code 3--adressesadresses----------------------------------------------------------------------------------------------------------------------------

----• Code intermédiaire 3-adresses ( parfois 2- ) , Code intermédiaire 3-adresses ( parfois 2- ) ,

syntaxe :syntaxe :

(1) x <- y <op> z(1) x <- y <op> z

(2) x <- <op> y(2) x <- <op> y

(3) x <- y(3) x <- y

syntaxe :syntaxe :

(1) x <- y <op> z(1) x <- y <op> z

(2) x <- <op> y(2) x <- <op> y

(3) x <- y(3) x <- y

(4) goto L(4) goto L

(5) if x <op> y goto L(5) if x <op> y goto L

syntaxe :syntaxe :

(1) x <- y <op> z(1) x <- y <op> z

(2) x <- <op> y(2) x <- <op> y

(3) x <- y(3) x <- y

(4) goto L(4) goto L

(5) if x <op> y goto L(5) if x <op> y goto L

(6) param a_1(6) param a_1

. . .. . .

param a_kparam a_k

call f , kcall f , k

(7) return(7) return

syntaxe :syntaxe :

(1) x <- y <op> z (1) x <- y <op> z (8) x <- y [ z ](8) x <- y [ z ]

(2) x <- <op> y (2) x <- <op> y (9) x [ y ] <- z(9) x [ y ] <- z

(3) x <- y (3) x <- y (10) x <- &y(10) x <- &y

(4) goto L (4) goto L

(5) if x <op> y goto L (5) if x <op> y goto L

. . .. . .

param a_kparam a_k

syntaxe :syntaxe :

(1) x <- y <op> z (8) x <- y [ z ](1) x <- y <op> z (8) x <- y [ z ]

(2) x <- <op> y (9) x [ y ] <- z(2) x <- <op> y (9) x [ y ] <- z

(3) x <- y (10) x <- &y(3) x <- y (10) x <- &y

(4) goto L (4) goto L (11) x <- *y(11) x <- *y

(5) if x <op> y goto L (5) if x <op> y goto L (12) *x <- y(12) *x <- y

. . .. . .

param a_kparam a_k

syntaxe :syntaxe :

(2) x <- <op> y (9) x [ y ] <- z(2) x <- <op> y (9) x [ y ] <- z

(3) x <- y (10) x <- &y(3) x <- y (10) x <- &y

(4) goto L (11) x <- *y(4) goto L (11) x <- *y

(5) if x <op> y goto L (12) *x <- y(5) if x <op> y goto L (12) *x <- y

. . .. . .

param a_kparam a_k

Les instructions complexesLes instructions complexesdeviennent une séquencedeviennent une séquenced’instructions 3-adressesd’instructions 3-adressesqui utilisent des variablesqui utilisent des variablestemporaires.temporaires.

syntaxe :syntaxe :

(2) x <- <op> y (9) x [ y ] <- z(2) x <- <op> y (9) x [ y ] <- z

(3) x <- y (10) x <- &y(3) x <- y (10) x <- &y

(4) goto L (11) x <- *y(4) goto L (11) x <- *y

(5) if x <op> y goto L (12) *x <- y(5) if x <op> y goto L (12) *x <- y

. . .. . .

param a_kparam a_k

x = ( x + y ) * z =>x = ( x + y ) * z =>

t <- x + yt <- x + y

t’ <- t * zt’ <- t * z

x <- t’x <- t’

G E N E R A T I O NG E N E R A T I O N

D ED E

C O D EC O D E

I N T E R M E D I A I R EI N T E R M E D I A I R E

Génération de code intermédiaireGé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.code qui est le code qui calcule E ,– E.place qui est l’endroit où nous trouvons le E.place qui est l’endroit où nous trouvons le

résultat !résultat !

• Pour une instruction S , nous n’aurons que Pour une instruction S , nous n’aurons que S.place !S.place !

• Pour une instruction S , nous n’aurons que S.place !Pour une instruction S , nous n’aurons que S.place !

Si E = id : Si E = id : E.place = id.placeE.place = id.place

E.code = E.code =

– E.code qui est le code qui calcule E ,E.code qui est le code qui calcule E ,– E.place qui est l’endroit où nous trouvons le résultat !E.place qui est l’endroit où nous trouvons le résultat !

E.code = E.code =

Si E = E op E :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 )

E.code = E.code =

Si E = E op E :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 )

Si S qui est id := E :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 qui est id := E :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 :Si S est S ; S :

S.code = S .code ; S .codeS.code = S .code ; S .code

Si S est while E do S :Si S est while E do S :

Soient Soient S.begin = newlabel ()S.begin = newlabel () et et S.after = newlabel ()S.after = newlabel ()

S.code = S.code =

gencode ( « S.begin: » ) ; E.code ;gencode ( « S.begin: » ) ; E.code ;

S.code = S.code =

gencode ( « if » E.place « =0 goto » S.after ) ;gencode ( « if » E.place « =0 goto » S.after ) ;

S.code = S.code =

S .code ;S .code ;

gencodegencode ( « goto » S.begin ) ;( « goto » S.begin ) ;

S.code = S.code =

S .code ;S .code ;

gencode ( « goto » S.begin ) ;gencode ( « goto » S.begin ) ;

gencode ( « S.after: » ) ;gencode ( « S.after: » ) ;

• Cette générationCette génération

– utilise beaucoup de temporaires,utilise beaucoup de temporaires,– utilise beaucoup de copies de variable à variable !utilise beaucoup de copies de variable à variable !

• Cette générationCette génération

– utilise beaucoup de temporaires,utilise beaucoup de temporaires,– utilise beaucoup de copies de variable à variable !utilise beaucoup de copies de variable à variable !

• Nous nous en occuperont dans la suite !Nous nous en occuperont dans la suite !

• Pour l’instant, nous avons un code correct ! ! !Pour l’instant, nous avons un code correct ! ! !

O P T I M I S A T I O NO P T I M I S A T I O N

D UD U

C O D EC O D E

I N T E R M E D I A I R EI N T E R M E D I A I R E

Optimisation du code intermédiaireOptimisation du code intermédiaire----------------------------------------------------------------------------------------------------------------------------

----• Il fautIl faut

– tenir compte du nombre de registres,tenir compte du nombre de registres,– veiller à garder le pipeline plein !veiller à garder le pipeline plein !

• L’optimisation du code intermédiaireL’optimisation du code intermédiaire

– redresse les imperfections du code intermédiaire,redresse les imperfections du code intermédiaire,– redresse les imperfections du code utilisateur !redresse les imperfections du code utilisateur !

• La suite des instructions est découpée en de La suite des instructions est découpée en de séquences appelées « blocs fondamentaux » !séquences appelées « blocs fondamentaux » !

• Un « bloc fondamental » correspond à une séquence Un « bloc fondamental » correspond à une séquence d’instructions exécutées de la première à la dernière d’instructions exécutées de la première à la dernière sans interruption !sans interruption !

Le bloc fondamentalLe bloc fondamental----------------------------------------------------------------------------------------------------------------------------

----• Il faut d’abord identifier les « têtes de bloc ». Ce Il faut d’abord identifier les « têtes de bloc ». Ce

sont :sont :

– la première instruction du programme,la première instruction du programme,– toute instruction atteinte par un « goto » ,toute instruction atteinte par un « goto » ,– toute instruction suivant un « goto » ,toute instruction suivant un « goto » ,– sachant que les fonctions et procédures sont sachant que les fonctions et procédures sont

assimilées à des « goto » !assimilées à des « goto » !

----• Il faut d’abord identifier les « têtes de bloc ». Ce sont :Il faut d’abord identifier les « têtes de bloc ». Ce sont :

– la première instruction du programme,la première instruction du programme,– toute instruction atteinte par un « goto » ,toute instruction atteinte par un « goto » ,– toute instruction suivant un « goto » ,toute instruction suivant un « goto » ,– sachant que les fonctions et procédures sont sachant que les fonctions et procédures sont

assimilées à des « goto » !assimilées à des « goto » !

• Un « bloc fondamental » estUn « bloc fondamental » est

– une tête de bloc,une tête de bloc,– et toutes les instructions qui la suivent jusqu’à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 !

----S.begin :S.begin :

if . . . goto S.afterif . . . goto S.after

goto S.begingoto S.begin

S.after : S.after :

S.after : S.after : Têtes de bloc !Têtes de bloc !

Blocs !Blocs !

----• Le graphe de dépendance des blocs :Le graphe de dépendance des blocs :

– Son objectif est de dire comment les blocs se Son objectif est de dire comment les blocs se suivent potentiellement !suivent potentiellement !

– C’est un graphe orienté !C’est un graphe orienté !– Les sommets correspondent aux blocs !Les sommets correspondent aux blocs !– Les dépendances correspondent aux arcs !Les dépendances correspondent aux arcs !

• Nous avons A Nous avons A --> B si> B si

– la tête de B est atteinte par un goto depuis A,la tête de B est atteinte par un goto depuis A,

– B suit séquentiellement A et celui-ci se termine B suit séquentiellement A et celui-ci se termine par un goto conditionnel !par un goto conditionnel !

S.after : S.after :

----• Quelques optimisations élémentaires dans un bloc :Quelques optimisations élémentaires dans un bloc :

– Elimination de sous-expressions communes.Elimination de sous-expressions communes.

a <- b + ca <- b + c

b <- a – db <- a – d

c <- b + cc <- b + c

d <- a - dd <- a - d

a <- b + ca <- b + c

b <- a – db <- a – d

c <- b + cc <- b + c

d <- a - dd <- a - d

a <- b + ca <- b + c

b <- a – db <- a – d

c <- b + cc <- b + c

d <- a - dd <- a - d

a <- b + ca <- b + c

b <- a – db <- a – d

c <- b + cc <- b + c

d <- d <- bb

a <- b + ca <- b + c

b <- a – db <- a – d

c <- b + cc <- b + c

d <- a - dd <- a - d

a <- b + ca <- b + c

b <- a – db <- a – d

c <- b + cc <- b + c

d <- d <- bb

La valeur de b change entre les deux expressions !La valeur de b change entre les deux expressions !

– Elimination de code mort.Elimination de code mort.

• Toute affectation de « variable du Toute affectation de « variable du compilateur » ( temporaire ) qui n’est pas compilateur » ( temporaire ) qui n’est pas utilisée dans la suite du bloc !utilisée dans la suite du bloc !

• Toute « variable locale » dont on sait qu’elle Toute « variable locale » dont on sait qu’elle n’est pas utilisée dans la suite ( il faut plus n’est pas utilisée dans la suite ( il faut plus d’informations ) !d’informations ) !

– Renommage des variables temporaires, qui Renommage des variables temporaires, qui peuvent de ce fait devenir des registres.peuvent de ce fait devenir des registres.

– Renommage des variables temporaires, qui Renommage des variables temporaires, qui peuvent de ce fait devenir des registres. peuvent de ce fait devenir des registres.

– Echange de l’ordre des calculs, si les Echange de l’ordre des calculs, si les dépendances entre les instructions le dépendances entre les instructions le permettent.permettent.

– Renommage des variables temporaires, qui Renommage des variables temporaires, qui peuvent de ce fait devenir des registres. peuvent de ce fait devenir des registres.

– Echange de l’ordre des calculs, si les Echange de l’ordre des calculs, si les dépendances entre les instructions le permettent.dépendances entre les instructions le permettent.

• Ces transformations sont possibles parce que le bloc Ces transformations sont possibles parce que le bloc est exécuté intégralement et sans interruption !est exécuté intégralement et sans interruption !

A N A L Y S EA N A L Y S E

D E L AD E L A

D U R E E D ED U R E E D E

V I E D E SV I E D E S

V A R I A B L E SV A R I A B L E S

Durée de vie des variablesDurée de vie des variables----------------------------------------------------------------------------------------------------------------------------

----• Il est important de savoir à partir de quand une Il est important de savoir à partir de quand une

variable n’est plus utilisée ( n’occupe donc plus de variable n’est plus utilisée ( n’occupe donc plus de registre, . . . ) !registre, . . . ) !

– Pour les variables du compilateur c’est facile à Pour les variables du compilateur c’est facile à savoir !savoir !

– Pour les variables de l’utilisateur qui sont Pour les variables de l’utilisateur qui sont locales, nous pourrons faire des choses !locales, nous pourrons faire des choses !

– Pour les variables de l’utilisateur qui sont Pour les variables de l’utilisateur qui sont globales, nous ne pouvons en gros rien faire !globales, nous ne pouvons en gros rien faire !

----• Il est important de savoir à partir de quand une variable Il est important de savoir à partir de quand une variable

n’est plus utilisée ( n’occupe donc plus de n’est plus utilisée ( n’occupe donc plus de registre, . . . ) !registre, . . . ) !

– Pour les variables du compilateur c’est facile à savoir Pour les variables du compilateur c’est facile à savoir !!

– Pour les variables de l’utilisateur qui sont locales, Pour les variables de l’utilisateur qui sont locales, nous pourrons faire des choses !nous pourrons faire des choses !

– Pour les variables de l’utilisateur qui sont globales, Pour les variables de l’utilisateur qui sont globales, nous ne pouvons en gros rien faire !nous ne pouvons en gros rien faire !

• Nous voulons savoir Nous voulons savoir

– « qui définit quoi ? » ,« qui définit quoi ? » ,

– « qui utilise quoi ? » !« qui utilise quoi ? » !

----• Au niveau d’un bloc, nous pouvons définirAu niveau d’un bloc, nous pouvons définir

– use ( bloc ) , resp. def ( bloc ) , qui est use ( bloc ) , resp. def ( bloc ) , qui est l’ensemble des variables lues, resp. écrites, par l’ensemble des variables lues, resp. écrites, par ce bloc.ce bloc.

– Use ( bloc ) , resp. Def ( bloc ) , qui est Use ( bloc ) , resp. Def ( bloc ) , qui est l’ensemble des variables lues, resp. écrites, par l’ensemble des variables lues, resp. écrites, par ce bloc ou un de ses successeurs.ce bloc ou un de ses successeurs.

– use ( bloc ) , resp. def ( bloc ) , qui est l’ensemble use ( bloc ) , resp. def ( bloc ) , qui est l’ensemble des variables lues, resp. écrites, par ce bloc.des variables lues, resp. écrites, par ce bloc.

– Use ( bloc ) , resp. Def ( bloc ) , qui est Use ( bloc ) , resp. Def ( bloc ) , qui est l’ensemble des variables lues, resp. écrites, par ce l’ensemble des variables lues, resp. écrites, par ce bloc ou un de ses successeurs.bloc ou un de ses successeurs.

• Une autre idée : « next_use » .Une autre idée : « next_use » .

i : x <- . . .i : x <- . . .

x <- . . .x <- . . .

. . . <- . . . x . . .. . . <- . . . x . . .

j : . . . <- . . . x . . .j : . . . <- . . . x . . .next_use ( i ) = jnext_use ( i ) = j

----• A titre d’illustration, nous associons à une variableA titre d’illustration, nous associons à une variable

– live live ouou live live

– no-use no-use ouou un numéro d’instruction un numéro d’instruction

• Nous initialisons les états de variables et nous Nous initialisons les états de variables et nous parcourons le programme à l’envers !parcourons le programme à l’envers !

• Initialisation :Initialisation :

– Toutes les variables : no-useToutes les variables : no-use– Les variables globales : liveLes variables globales : live– Les variables locales et temporaires :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.

• Pour toute instruction i : x <Pour toute instruction i : x <-- y op z y op z

– Nous attachons à i les informations sur x , y et Nous attachons à i les informations sur x , y et z . z .

– x devient x devient live et no-use . live et no-use .

– x devient x devient live et no-use . live et no-use .– y et z deviennent live et de numéro i .y et z deviennent live et de numéro i .

– Nous attachons à i les informations sur x , y et z .Nous attachons à i les informations sur x , y et z .– x devient x devient live et no-use . live et no-use .– y et z deviennent live et de numéro i .y et z deviennent live et de numéro i .

Attention à l’ordre, car la variable x pourrait êtreAttention à l’ordre, car la variable x pourrait être

identique à y ou z !identique à y ou z !

----• Une illustration, avec t temporaire locale au bloc :Une illustration, avec t temporaire locale au bloc :