19 septembre 2007cours de compilation 1 - intranet1 marc gengler [email protected] cours...

19 septembre 2007 Cours de compilation 1 - Intranet 1

Marc GenglerMarc Gengler

[email protected]@esil.univmed.fr

Cours de compilationCours de compilation

18h de cours18h de coursavec un peu de avec un peu de

TDTDun projet de 32hun projet de 32h

. . . et un . . . et un examenexamen


Marc GenglerMarc Gengler

[email protected]@esil.univ-mrs.fr

Cours de compilationCours de compilation

18h de cours18h de coursavec un peu de avec un peu de

TDTDun projet de 32hun projet de 32h

. . . et un . . . et un examenexamen


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


BibliographieBibliographie

•Tout ce qui contientTout ce qui contient– compilation, compilateur, compiler.compilation, compilateur, compiler.

•InternetInternet– souvent, c’est trop simplifié ou trop dense,souvent, c’est trop simplifié ou trop dense,

– et pas toujours correct.et pas toujours correct.

•Mes choixMes choix– Principles of Compiler Design, Aho & Ullman.Principles of Compiler Design, Aho & Ullman.

« The green dragon book » (1977)« The green dragon book » (1977)

– Compilers: Principles, Techniques, and Tools,Compilers: Principles, Techniques, and Tools,

Aho, Sethi & Ullman.Aho, Sethi & Ullman.

« The red dragon book » (1986)« The red dragon book » (1986)

– Lex & Yacc, Levine.Lex & Yacc, Levine.


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 descendantes etTechniques d’analyse descendantes et ascendantesascendantes•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


Définition de baseDéfinition de base----------------------------------------------------------------------------------------------------------------------------

----• Un compilateur est un TRADUCTEURUn compilateur est un TRADUCTEUR

d’un « texte » écrit en langage source Ld’un « texte » écrit en langage source L

vers le « même texte » écrit en langage vers le « même texte » écrit en langage cible C.cible C.






CompilateurCompilateurCC ASMASM







void main ()void main () {int x;{int x; if …if …

load A , #13load A , #13add A , B , Cadd A , B , C……







CompilateurCompilateur ’’PascalPascal CC


Compilation >< InterprétationCompilation >< Interprétation----------------------------------------------------------------------------------------------------------------------------

----

• Un compilateurUn compilateur

– lit tout le texte source,lit tout le texte source,



----


– lit tout le texte source,lit tout le texte source,– le comprend (vérifie)le comprend (vérifie)



----


– lit tout le texte source,lit tout le texte source,– le comprend (vérifie)le comprend (vérifie)– et le traduit en un texte équivalent.et le traduit en un texte équivalent.



----


– lit tout le texte source,lit tout le texte source,– le comprend (vérifie)le comprend (vérifie)– et le traduit en un texte équivalent.et le traduit en un texte équivalent.

Il n’exécute pas le programme !Il n’exécute pas le programme !



----

• Un interprèteUn interprète

– lit une instruction source,lit une instruction source,



----


– lit une instruction source,lit une instruction source,– la comprend (vérifie),la comprend (vérifie),



----


– lit une instruction source,lit une instruction source,– la comprend (vérifie),la comprend (vérifie),– l’exécutel’exécute



----


– lit une instruction source,lit une instruction source,– la comprend (vérifie),la comprend (vérifie),– l’exécutel’exécute– et passe à l’instruction suivante.et passe à l’instruction suivante.



----



Il exécute le programme !Il exécute le programme !



----



Il exécute le programme !Il exécute le programme !

Un processeur est un interprète de son byte-code !Un processeur est un interprète de son byte-code !


C H A I N A G EC H A I N A G E

D ED E

C O M P I L A T E U R SC O M P I L A T E U R S


Chaînage de compilateursChaînage de compilateurs----------------------------------------------------------------------------------------------------------------------------

----

C1C1



----

C1C1 C2C2



----

C1C1 C2C2

Ils peuvent être vus comme un seul compilateur !Ils peuvent être vus comme un seul compilateur !



----

C1C1 C2C2

En termes de langages :En termes de langages :

C1C1 C2C2SourceSource CibleCibleIntermédiaireIntermédiaire



----

C1C1 C2C2

En termes de langages :En termes de langages :

C1C1 C2C2SourceSource CibleCibleIntermédiaireIntermédiaire

Fréquent dans la pratique :Fréquent dans la pratique :

C1C1 C2C2SourceSource ASM optimiséASM optimiséASMASMcorrectcorrect



----

C1C1 C2C2

Nous pouvons partager un FRONT-END :Nous pouvons partager un FRONT-END :

C1C1

C2C2

SourceSource

ASM X86ASM X86

ASM virtuelASM virtuel

C3C3 ASM MipsASM Mips



----

C1C1 C2C2

Nous pouvons partager un BACK-END :Nous pouvons partager un BACK-END :

C3C3

C1C1

ASMASM

PascalPascal

IntermédiaireIntermédiaire

C2C2ModulaModula



----

C1C1 C2C2

Et nous combinons (gcc et g++ par exemple) :Et nous combinons (gcc et g++ par exemple) :

C1C1CC

IntermédiaireIntermédiaire

C++C++

C3C3 ASM X86ASM X86

C4C4 ASM MipsASM MipsC2C2


L E SL E S

L A N G A G E SL A N G A G E S

D A N S U ND A N S U N

C O M P I L A T E U RC O M P I L A T E U R


Un compilateur et sa réalisationUn compilateur et sa réalisation----------------------------------------------------------------------------------------------------------------------------

----


– traduit du langage S vers le langage C,traduit du langage S vers le langage C,

– est lui-même écrit en un langage I.est lui-même écrit en un langage I.



----




CompCompS S --> C> C

II



----




CompComp

ou encore, par le « diagramme en T » :ou encore, par le « diagramme en T » :

S CS C

S S --> C> C

II

IIS CS C

II



----

• Appelons une « M-machine » ou « M-Appelons une « M-machine » ou « M-interprète » une machine dont le processeur interprète » une machine dont le processeur interprète M !interprète M !



----


• Un compilateur de L , autonome sur la M-Un compilateur de L , autonome sur la M-machine, est :machine, est :

L ML M

MM



----



L ML M

MM

SourceSourceLL



----



L ML M

MM

SourceSourceLL CibleCible

MM



----



L ML M

MM


MM

M-machineM-machineLe supportLe supportd’exécutiond’exécution

M-machineM-machine



----• Appelons une « M-machine » ou « M-interprète » une Appelons une « M-machine » ou « M-interprète » une

machine dont le processeur interprète M !machine dont le processeur interprète M !

• Un compilateur de L , autonome sur la M-machine, est :Un compilateur de L , autonome sur la M-machine, est :

• La compilation et l’exécution du code compilé peuvent La compilation et l’exécution du code compilé peuvent se faire sur la M-machine ! ! !se faire sur la M-machine ! ! !

L ML M

MM


MM

M-machineM-machineLe supportLe supportd’exécutiond’exécution

M-machineM-machine


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

D ED E

N O U V E A U XN O U V E A U X

C O M P I L A T E U R SC O M P I L A T E U R S


Génération de nouveaux compilateursGénération de nouveaux compilateurs----------------------------------------------------------------------------------------------------------------------------

----• Nous disposons d’un compilateur de L , autonome Nous disposons d’un compilateur de L , autonome

sur M !sur M !L ML M

MM



----• Nous disposons d’un compilateur de L , autonome Nous disposons d’un compilateur de L , autonome

sur M !sur M !

• Nous voulons un compilateur de Nous voulons un compilateur de XX , autonome sur M , autonome sur M !!

L ML M

MM

XX M M

MM



----• Nous disposons d’un compilateur de L , autonome sur Nous disposons d’un compilateur de L , autonome sur

M !M !

• Nous voulons un compilateur de Nous voulons un compilateur de XX , autonome sur M ! , autonome sur M !

• Nous voulons un compilateur de L , autonome sur Nous voulons un compilateur de L , autonome sur NN ! !

L ML M

MM

XX M M

MM

L L NN

NN



----• Un bon compilateur travaille Un bon compilateur travaille vitevite et et bienbien ! !




– La compilation est rapide !La compilation est rapide !

– Le code compilé est rapide, efficace en Le code compilé est rapide, efficace en mémoire, . . . !mémoire, . . . !






• Indiquons l’inefficacité par * ! ! !Indiquons l’inefficacité par * ! ! !







L M*L M*MM

Ce compilateur est rapide, mais le code produit n’est pas bon !Ce compilateur est rapide, mais le code produit n’est pas bon !







L M*L M*MM

L ML MM*M*

L M*L M*M*M*

L ML MMM







L M*L M*MM

L ML MM*M*

L M*L M*M*M*

L ML MMM

Il est lent, mais produit un bon résultat !Il est lent, mais produit un bon résultat !







L M*L M*MM

L ML MM*M*

L M*L M*M*M*

L ML MMM

Il est lent et mauvais !Il est lent et mauvais !







L M*L M*MM

L ML MM*M*

L M*L M*M*M*

L ML MMM

Il est bon !Il est bon !


C H A N G E RC H A N G E R

D ED E

L A N G A G EL A N G A G E



----• Sur la M-machine, construisons un bon Sur la M-machine, construisons un bon

compilateur pour le nouveau langage X !compilateur pour le nouveau langage X !





• Ecrire directement est très Ecrire directement est très difficile !difficile !

X X M M

MM






– Faire une bonne traduction de X vers M est Faire une bonne traduction de X vers M est difficile !difficile !

– La réaliser de surcroît en M ne facilite rien ! ! !La réaliser de surcroît en M ne facilite rien ! ! !

X X M M

MM



----• Nous allons devoir combiner des Nous allons devoir combiner des

compilateurs !compilateurs !





• Ecrire est très facile !Ecrire est très facile !X X L L

LL





• Ecrire est très facile !Ecrire est très facile !

– La traduction entre les langages évolués X et L La traduction entre les langages évolués X et L est très facile.est très facile.

– La réaliser de surcroît en L rend la chose La réaliser de surcroît en L rend la chose aisée ! ! !aisée ! ! !

X X L L

LL



----• D’abord nous compilons le nouveau compilateur D’abord nous compilons le nouveau compilateur

!!




!!

L ML M

MM

M-machineM-machine




!!

L ML M

MM

M-machineM-machine

X LX LLL




!!

L ML M

MM

M-machineM-machine

X LX LLL

X LX LMM

Nous gardons un compilateur de X vers L !Nous gardons un compilateur de X vers L !Mais, il est maintenant écrit en M !Mais, il est maintenant écrit en M !




!!

L ML M

MM

M-machineM-machine

En diagramme T !En diagramme T !

X LX L

LL

X LX L

MM




!!

L ML M

MM

M-machineM-machine

En diagramme T !En diagramme T !

X LX L

LL

X LX L

MM

Nous l’avons rendu exécutable sur la M-machine ! ! !Nous l’avons rendu exécutable sur la M-machine ! ! !



----• Maintenant, nous chaînons les deux Maintenant, nous chaînons les deux




----

X LX L

MM

• Maintenant, nous chaînons les deux Maintenant, nous chaînons les deux compilateurs !compilateurs !



----

L ML M

MM

X LX L

MM




----

L ML M

MM

X LX L

MM

M-machineM-machine




----

L ML M

MM

X LX L

MM

M-machineM-machine

X M*X M*

MM




----• La meilleure solution est la suivante !La meilleure solution est la suivante !




• Ecrire est d’une difficulté Ecrire est d’une difficulté raisonnable !raisonnable !

X X MM

LL





– La traduction de X vers M est difficile, sans plus.La traduction de X vers M est difficile, sans plus.

– La réaliser dans le langage L est raisonnable ! ! !La réaliser dans le langage L est raisonnable ! ! !

X X MM

LL



----• Il suffit de compiler le nouveau compilateur !Il suffit de compiler le nouveau compilateur !



----

L ML M

MM

M-machineM-machine

• Il suffit de compiler le nouveau compilateur !Il suffit de compiler le nouveau compilateur !



----

L ML M

MM

M-machineM-machine

X X MM

LL




----

L ML M

MM

M-machineM-machine

X X MM

LL

X X MM

MM




----• Il suffit de compiler le nouveau compilateur !Il suffit de compiler le nouveau compilateur !

L ML M

MM

M-machineM-machine

X X MM

LL

X X MM

MM

Ce compilateur est bon !Ce compilateur est bon !


C H A N G E RC H A N G E R

D ED E

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



----• Pour le langage L , autonome sur M , nous Pour le langage L , autonome sur M , nous

voulons construire un bon compilateur sur voulons construire un bon compilateur sur une nouvelle machine N !une nouvelle machine N !






L L N N

NN







L L N N

NN

L L N N

LL



----• Nous compilons le nouveau compilateur !Nous compilons le nouveau compilateur !




L ML M

MM

M-machineM-machine




L ML M

MM

M-machineM-machine

L L N N

LL




L ML M

MM

M-machineM-machine

L L N N

LL

L L N N

MM




• Nous obtenons un « cross-compilateur » :Nous obtenons un « cross-compilateur » :

L ML M

MM

M-machineM-machine

L L N N

LL

L L N N

MM





– qui s’exécute sur l’ancienne machine Mqui s’exécute sur l’ancienne machine M

L ML M

MM

M-machineM-machine

L L N N

LL

L L N N

MM





– qui s’exécute sur l’ancienne machine Mqui s’exécute sur l’ancienne machine M

– et produit du code pour la nouvelle machine N .et produit du code pour la nouvelle machine N .

L ML M

MM

M-machineM-machine

L L N N

LL

L L N N

MM



----• Nous recompilons le nouveau compilateur, à Nous recompilons le nouveau compilateur, à

l’aide du cross-compilateur !l’aide du cross-compilateur !





M-machineM-machine

L L N N

MM





M-machineM-machine

L L N N

MM

L L N N

LL



----• Nous recompilons le nouveau compilateur, à l’aide du Nous recompilons le nouveau compilateur, à l’aide du

cross-compilateur !cross-compilateur !

• Nous obtenons un bon compilateur pour L et Nous obtenons un bon compilateur pour L et autonome sur la machine N !autonome sur la machine N !

M-machineM-machine

L L N N

MM

L L N N

LL

L L N N

NN


L EL E

T A B L E A UT A B L E A U

C O M P L E TC O M P L E T



----• Le tableau complet !Le tableau complet !




L ML M

MM

M-machineM-machine

Le matérielLe matérielLe compilateur initialLe compilateur initial




L L N N

LL L ML M

MM

M-machineM-machine


Le fichier sourceLe fichier source




L L N N

MM

L L N N

LL L ML M

MM

M-machineM-machine


Le fichier sourceLe fichier sourceLe cross-compilateur crééLe cross-compilateur créé




L L N N

LL L ML M

MM

M-machineM-machine

L L N N

LL



Le mêmeLe mêmefichier !fichier !

L L N N

MM




L L N N

LL L ML M

MM

M-machineM-machine

L L N N

LL



Le compilateur de L sur NLe compilateur de L sur N

L L N N

NN


L L N N

MM




L L N N

LL

L L N N

NN

L ML M

MM

M-machineM-machine

L L N N

LL

N-machineN-machine Le matérielLe matérielLe compilateur initialLe compilateur initial




L L N N

MM




L L N N

LL

L L N N

NN

L ML M

MM

M-machineM-machine

L L N N

LL

L L N N

LL





L L N N

MM




L L N N

LL

L L N N

NN

L ML M

MM

M-machineM-machine

L L N N

LL

L L N N

LL




Le mêmeLe mêmefichier !fichier ! L L N N

NN

L L N N

MM




L L N N

LL

L L N N

NN

L ML M

MM

M-machineM-machine

L L N N

LL

L L N N

LL




Le mêmeLe mêmefichier !fichier ! L L N N

NN

Le test de régression :Le test de régression :

Le mêmeLe mêmeexécutable !exécutable !

L L N N

MM




L L N N

NN

L L N N

LL




L L N N

NN






L L N N

NN

L L N N

LL




L L N N

NN



Nous avons :Nous avons :

un compilateur opérationnel,un compilateur opérationnel,




L L N N

NN

L L N N

LL




L L N N

NN





son fichier source,son fichier source,




L L N N

NN

L L N N

LL




L L N N

NN






nous savons regénérer l’exécutablenous savons regénérer l’exécutable..




L L N N

NN

L L N N

LL




L L N N

NN






nous savons regénérer l’exécutable.nous savons regénérer l’exécutable.


E NE N

R E S U M ER E S U M E



----• Construire un nouveau compilateur revient, Construire un nouveau compilateur revient,

dans la pratique, à écrire :dans la pratique, à écrire :

X X M M

LL



----• Construire un nouveau compilateur revient, Construire un nouveau compilateur revient,

dans la pratique, à écrire :dans la pratique, à écrire :

• Nous sommes obligés de décrire la Nous sommes obligés de décrire la traduction du langage évolué X vers le traduction du langage évolué X vers le langage de bas niveau M !langage de bas niveau M !

X X M M

LL



----• Construire un nouveau compilateur revient, dans la Construire un nouveau compilateur revient, dans la

pratique, à écrire :pratique, à écrire :

• Nous sommes obligés de décrire la traduction du Nous sommes obligés de décrire la traduction du langage évolué X vers le langage de bas niveau langage évolué X vers le langage de bas niveau M !M !

• Cette traduction peut être décrite à l’aide du Cette traduction peut être décrite à l’aide du langage de haut niveau L !langage de haut niveau L !

X X M M

LL


L ‘ E N V I R O N N E M E N TL ‘ E N V I R O N N E M E N T

D ED E

C O M P I L A T I O NC O M P I L A T I O N


L’environnement de compilationL’environnement de compilation----------------------------------------------------------------------------------------------------------------------------

----

CompilationCompilation gccgcc



----


PréprocessingPréprocessing cppcpp

Nous nous occupons duNous nous occupons dusucre syntaxique :sucre syntaxique :

#include#include

#define#define

#ifdef#ifdef

. . .. . .

Nous réduisons ainsi la complexité du compilateur !Nous réduisons ainsi la complexité du compilateur !



----


PréprocessingPréprocessing

EditionEdition

cppcpp

emacsemacs

Les éditeurs comprennent déjà le langage et nousLes éditeurs comprennent déjà le langage et nousaident à éviter les fautes les plus grossières !aident à éviter les fautes les plus grossières !



----



EditionEdition

cppcpp

emacsemacs

AssemblageAssemblage asmasm

Traduction d’un langage assembleur symbolique versTraduction d’un langage assembleur symbolique versle byte-code, insertion des bibliothèques statiques, . . . !le byte-code, insertion des bibliothèques statiques, . . . !



----



EditionEdition

cppcpp

emacsemacs

AssemblageAssemblage

ChargementChargement

asmasm

ldld

Installation en mémoire, allocation des zones mémoire,Installation en mémoire, allocation des zones mémoire,édition des liens et bibliothèques dynamiques, . . . !édition des liens et bibliothèques dynamiques, . . . !



----



EditionEdition

cppcpp

emacsemacs

AssemblageAssemblage

ChargementChargement

asmasm

ldld

SuccessionSuccessionchronologique !chronologique !



----• En plus :En plus :




– Des vérificateurs de syntaxe comme « lint » !Des vérificateurs de syntaxe comme « lint » !

• Plus exigeants que le compilateur (cast risqués, Plus exigeants que le compilateur (cast risqués, portabilité douteuse, code pas propre, . . . ) !portabilité douteuse, code pas propre, . . . ) !






– Des gestionnaires de versions comme « rcs » ou « cvs » Des gestionnaires de versions comme « rcs » ou « cvs » !!

• Ils gèrent les versions des sources et l’accès Ils gèrent les versions des sources et l’accès concurrent !concurrent !






– Des gestionnaires de versions comme « rcs » ou « cvs » !Des gestionnaires de versions comme « rcs » ou « cvs » !

• Ils gèrent les versions des sources et l’accès concurrent !Ils gèrent les versions des sources et l’accès concurrent !

– Des outils comme « make » ou « imake » !Des outils comme « make » ou « imake » !

• Ils automatisent les compilations séparées et partielles !Ils automatisent les compilations séparées et partielles !





• Plus exigeants que le compilateur (cast risqués, portabilité Plus exigeants que le compilateur (cast risqués, portabilité douteuse, code pas propre, . . . ) !douteuse, code pas propre, . . . ) !





– Des debuggers comme « gdb » !Des debuggers comme « gdb » !

• Ils contrôlent l’exécution, l’arrêt sur erreur, . . . !Ils contrôlent l’exécution, l’arrêt sur erreur, . . . !


RésuméRésumé----------------------------------------------------------------------------------------------------------------------------

----

•Définitions de baseDéfinitions de base

•Composition de compilateursComposition de compilateurs

•L’environnement d’un compilateurL’environnement d’un compilateur


C ’ e S t L a F i N ! C ’ e S t L a F i N ! ! !! !

b O n N eb O n N eJ o U r N é E ! ! !J o U r N é E ! ! !

19 septembre 2007cours de compilation 1 - intranet1 marc gengler [email protected] cours...

Documents