Compilateur

Un article de Wikipédia, l'encyclopédie libre.

Pour les articles homonymes, voir Compilation.

Un compilateur est un programme informatique qui traduit un langage, le langage source, en un autre, appelé le langage cible, en préservant la signification du texte source. Ce schéma général décrit un grand nombre de programmes différents ; et ce que l'on entend par « signification du texte source » dépend du rôle du compilateur. Lorsque l'on parle de compilateur, on suppose aussi en général que le langage source est, pour l'application envisagée, de plus haut niveau que le langage cible, c'est-à-dire qu'il présente un niveau d'abstraction supérieur.

En pratique, un compilateur sert le plus souvent à traduire un code source écrit dans un langage de programmation en un autre langage, habituellement un langage d'assemblage ou un langage machine. Le programme en langage machine produit par un compilateur est appelé code objet.

Le premier compilateur a été écrit par Grace Hopper.

[modifier] Structure d'un compilateur

La tâche principale d'un compilateur est de produire du code objet correct. La plupart des compilateurs permettent d'optimiser le code (le code objet optimisé s'exécutera plus rapidement, ou aura une occupation mémoire moindre).

Un compilateur fonctionne par analyse-synthèse, c'est-à-dire qu'au lieu de remplacer chaque construction du langage source par une suite équivalente de constructions du langage cible, il commence par analyser le texte source pour en construire une représentation intermédiaire qu'il traduit à son tour en langage cible.

Il est donc naturel de séparer — au moins conceptuellement, mais aussi en pratique — le compilateur en une partie avant (ou frontale), parfois appelée « souche », qui lit le texte source et produit la représentation intermédiaire, et une partie arrière (ou finale), qui parcourt cette représentation pour produire le texte cible. Dans un compilateur idéal, la partie avant est indépendante du langage cible, tandis que la partie arrière est indépendante du langage source. Certains compilateurs effectuent de plus sur la forme intermédiaire des traitements substantiels, que l'on peut regrouper en une partie centrale, indépendante à la fois du langage source et de la machine cible. On peut ainsi écrire des compilateurs pour toute une gamme de langages et d'architectures en partageant la partie centrale, à laquelle on attache une partie avant par langage et une partie arrière par architecture.

Les étapes de la compilation incluent

le découpage du programme en lexèmes (analyse lexicale) ;
la vérification de la correction de la syntaxe du programme (analyse syntaxique) ;
l'analyse des structures de données (analyse sémantique) ;
la transformation du code source en code intermédiaire ;
l'application de techniques d'optimisation sur le code intermédiaire ;
l'allocation de registres et la traduction du code intermédiaire en code objet, avec éventuellement l'insertion de données de débogage et d'analyse de l'exécution ;
et enfin l'édition des liens.

Ces différentes étapes expliquent que les compilateurs fassent toujours l'objet de recherches, particulièrement dans le domaine de l'optimisation du code produit.

La plupart (mais pas tous) des compilateurs traduisent un fichier source d'un programme écrit dans un langage de programmation en un fichier objet (ou un exécutable, ou un fichier en assembleur, ou même en un autre langage).

Une implémentation (réalisation concrète) d'un langage de programmation peut être interprétée ou compilée. C'est cette réalisation qui est un compilateur ou un interpréteur, et un langage de programmation (spécification plus ou moins théorique et formalisée de sa syntaxe et de sa sémantique) peut avoir une implémentation compilée, et une autre interprétée.

Les techniques de compilation sont très complexes. Pour simplifier la réalisation d'un compilateur, on peut utiliser pour les parties avant et arrière des outils qui simplifient le travail :

analyse lexicale : lex, flex, etc...
analyse syntaxique : yacc, bison, etc...
génération de code (transformation du code intermédiaire en code objet, avec optimisation) : Low Level Virtual Machine, Architecture description language, etc...

[modifier] Compilateurs particuliers

[modifier] Compilateur croisé

Un compilateur croisé (en anglais cross compiler) est un programme capable de traduire un code source en code objet ayant un environnement d'exécution (architecture matérielle, système d'exploitation) différent de celui où la compilation est effectuée. Ces compilateurs sont principalement utilisés en informatique industrielle.

[modifier] Byte code ou code octet

Certains compilateurs traduisent un langage source en langage machine virtuel, c'est-à-dire en un code (généralement une suite d'octets) exécuté par une machine virtuelle : un programme émulant les principales fonctionnalités d'un ordinateur. Le portage d'un programme ne requiert ainsi que le portage de la machine virtuelle. C'est le cas du compilateur Java, qui traduit du code Java en bytecode Java (code objet). Une machine virtuelle DotNet peut exécuter du bytecode MSIL produit par les langages de Microsoft C#, Visual Basic ou autres.

[modifier] Autres compilateurs

Si la plupart des compilateurs traduisent un code d'un langage de programmation vers un autre, ce n'est pas le cas de tous les compilateurs. Par exemple, le logiciel LaTeX compile un code écrit dans le langage de formatage de texte LaTeX, pour le convertir en un autre langage, par exemple DVI, HTML, PostScript...

Certains compilateurs traduisent, de façon incrémentale ou interactive, le programme source (tapé par l'utilisateur) en du code machine. Par exemple, certaines implémentations de Common Lisp (comme SBCL) traduisent un bout de programme en du code machine (en mémoire).

Les compilateurs Just In Time (juste à temps) traduisent une représentation intermédiaire (souvent du code octet) en du code machine, de manière progressive.

[modifier] Le problème de l'amorçage (bootstrap)

Les premiers compilateurs étaient écrits directement en langage assembleur, un langage symbolique élémentaire correspondant aux instructions du processeur cible et quelques structures de contrôle légèrement plus évoluées. Ce langage symbolique doit être assemblé (et non compilé) et lié pour obtenir une version exécutable. En raison de sa simplicité, un programme simple suffit à le convertir en instructions machines.

Les compilateurs actuels sont généralement écrits dans le langage qu'ils doivent compiler ; par exemple un compilateur C est écrit en C, SmallTalk en SmallTalk, Lisp en Lisp, etc. Dans la réalisation d'un compilateur, une étape décisive est franchie lorsque le compilateur pour le langage X est suffisamment complet pour se compiler lui-même : il ne dépend alors plus d'un autre langage (fut-ce de l'assembleur) pour être produit.

Les bugs des compilateurs sont parfois très complexes à détecter. Si un compilateur de langage C comporte un bug, les programmeurs en langage C auront naturellement tendance à mettre en cause leur propre code source, non pas le compilateur.

Pire, si ce compilateur buggé (version V1) compile un compilateur (version V2) non buggé, l'exécutable compilé (par V1) du compilateur V2 sera buggé. Pourtant son code source est bon. Le bootstrap oblige donc les programmeurs de compilateurs à contourner les bugs des compilateurs existants.