Qu’est-ce qu’un compilateur ?

Un compilateur est un programme informatique qui convertit le code d’un langage de programmation (le langage source) vers un autre langage de programmation (le langage cible).

Les compilateurs sont utilisés pour transformer le code source de haut niveau en code cible de bas niveau (comme le langage assembleur, le code objet ou le code machine), tout en préservant les fonctionnalités du programme.

Outil essentiel pour la programmation informatique moderne et pratique, les compilateurs permettent aux programmeurs de travailler dans un code de haut niveau lisible par l'homme, puis de convertir leur code source en code cible exécutable. Les compilateurs aident également les développeurs de logiciels à créer des programmes exécutables efficaces, avec de meilleures performances en matière de sécurité, de stabilité et de portabilité. En effet, les compilateurs facilitent l'identification et la correction des erreurs, créant ainsi des applications exécutables portables. 

Si tous les compilateurs convertissent le code de haut niveau en code de bas niveau exécutable, le choix du compilateur dépendra du langage de programmation et de l’application. Par exemple, les compilateurs croisés permettent de produire le code d’une unité centrale de traitement ou d’un système d’exploitation autres que ceux sur lesquels il s’exécute.

Si le compilateur idéal n’est pas disponible ou n’a pas encore été créé, un compilateur Bootstrap temporaire permet de compiler un compilateur plus permanent et mieux adapté pour compiler un langage de programmation donné.

Voici une brève liste des logiciels connexes :

• À l’inverse des compilateurs, les décompilateurs convertissent le code de bas niveau en langage de haut niveau.
• Les compilateurs source à source (ou transpileurs) convertissent le code de haut niveau en d’autres langages de haut niveau.
• Les réécrivains de langage transforment les expressions formelles du code en différentes formes sans modifier le langage.
• Les générateurs de compilateurs permettent de créer des compilateurs génériques et réutilisables, ou des composants de compilateurs qui peuvent être incorporés à des fins bien précises du projet.  

En pratique, pour utiliser un compilateur, il suffit de saisir une commande sur la ligne de commande d’un système Linux (ou équivalent), en spécifiant le fichier exécutable du compilateur et les fichiers sources à compiler. Cette commande demande au système de traiter le code source afin de le compiler dans un code machine cible et d’obtenir les fichiers objets nécessaires à la production d’un programme exécutable. 

Des compilateurs open source comme GNU Compiler Collection (GCC) (un ensemble de compilateurs C robustes, couramment utilisés pour compiler le code C en programmes C) ou Clang sont disponibles dans des référentiels tels que GitHub. D’autres compilateurs peuvent être installés librement, ou achetés auprès d’un large éventail de distributeurs. Ils peuvent également être intégrés dans les environnements de développement intégrés (IDE) les plus connus, qui regroupent divers utilitaires pour le développement logiciel (par exemple, éditeurs de texte, documentation API et outils de débogage).     

Quel que soit le compilateur utilisé, le processus de compilation consiste à soumettre le code source à différents niveaux d’analyse, d’optimisation et, pour finir, de production. Le code source est soumis aux différentes couches analytiques de manière séquentielle pour être évalué à chaque étape du processus.

Si le compilateur détecte un problème lié au code source, il renvoie un message d’erreur invitant les développeurs à corriger les erreurs identifiées avant de poursuivre la compilation. En général, les compilateurs suivent les étapes suivantes :

1. Analyse lexicale : la première étape du processus de compilation fait passer le code source par le lexeur du compilateur. Il s’agit d’un programme qui transforme les caractères en unités de langage significatives comme les mots-clés, les identifiants et les opérateurs. Ces unités sont collectivement appelées « tokens ». Cette étape consiste essentiellement à préparer le code source pour la suite, en convertissant les éléments significatifs et importants du code source en tokens que le compilateur pourra traiter. 
2. Analyse syntaxique : lors de la deuxième étape du processus de compilation, les tokens sont envoyés du lexeur vers l’analyseur syntaxique du compilateur. L’analyseur syntaxique est un programme qui vérifie que le code ne contient pas d’erreur de syntaxe et que le code source suit correctement les règles du langage source. Si l’analyseur ne détecte aucune erreur lors de l’analyse, il génère une représentation abstraite de la structure globale du code, appelée « arbre de syntaxe abstraite » (AST).
3. Analyse sémantique : après avoir vérifié la syntaxe du code, le compilateur procède à une analyse sémantique du code pour déduire la fonction prévue du code source. Au cours de cette étape, le compilateur vérifie la présence d’erreurs de logique telles que les variables non déclarées ou une utilisation incorrecte des opérateurs.
4. Optimisation : bien que non indispensable pour pour produire un code fonctionnel, l’optimisation est une étape facultative proposée par de nombreux compilateurs pour améliorer la performance globale du code compilé. L’optimisation permet d’identifier et de supprimer le code inutile pour obtenir des programmes plus rapides, plus efficaces et plus stables, en plus d’écourter le processus de débogage final. 
5. Production de code : lors de la dernière étape du processus, le compilateur convertit l’AST en code lisible par une machine. La sortie finale est un code de langage d’assemblage qui peut ensuite être converti en code binaire et exécuté par le système informatique. 

Tous les compilateurs ne respectent pas strictement la structure précédente. Si certains compilateurs contiennent plus ou moins d’étapes, toutes les phases de compilation peuvent être attribuées à l’une des trois étapes suivantes : un front-end, un middle-end et un back-end.

Cette structure en trois étapes permet aux compilateurs d’adopter une approche modulaire. Elle permet de combiner plusieurs front-ends pour différents langages avec des back-ends pour différentes unités centrales de traitement, tout en partageant les capacités d’optimisation des différents middle-ends applicables.

Les trois étapes du compilateur impliquent la distribution suivante :

1. Front-end : le front-end du compilateur comprend des aspects de l’analyse lexicale, de l’analyse syntaxique et de l’analyse sémantique. Cette étape consiste à vérifier la syntaxe et la sémantique selon les règles du language source et permet d’identifier et de localiser les erreurs dans le code source. Si aucune erreur n’est trouvée, le front-end du compilateur convertit le code source en représentation intermédiaire (IR), c’est-à-dire une conversion temporaire de niveau inférieur du code source, pour le middle-end. 
2. Middle-end : le middle-end du compilateur procède à diverses optimisations de code sur l’IR, quelle que soit l’architecture CPU visée par le processus de compilation. En optimisant le code source indépendamment du code machine cible, le compilateur peut appliquer des optimisations généralisées pour améliorer la performance du code sur plusieurs versions. Ces améliorations peuvent être apportées quels que soient le langage et l’architecture matérielle pris en charge. 
3. Back-end : l’étape back-end utilise la sortie de l’étape middle-end et peut effectuer d’autres optimisations et conversions spécifiques à l’unité centrale de traitement. Au cours de cette dernière étape du processus de compilation, le compilateur produit un code d’assemblage dépendant de la cible, y compris les allocations de registres et la planification des instructions. L’étape back-end aboutit généralement à un code machine adapté au matériel et aux systèmes d’exploitation cibles. 

Si, en théorie, les compilateurs ne sont pas indispensables pour produire un code exploitable, la diversité et la complexité des langages de programmation et des environnements machines les rendent en pratique nécessaires pour créer des logiciels exécutables. Voici les quatre principaux avantages qu’offrent les compilateurs logiciels.

Alors que le compilateur permet de convertir le code source en code machine exécutable, l’interpréteur est un type de programme qui propose des fonctionnalités similaires par le biais d’un mécanisme différent.

Au lieu de convertir le code source, les interpréteurs l’exécutent directement ou utilisent un code intermédiaire appelé « bytecode », une représentation de bas niveau du code source, indépendante de la plateforme. Le bytecode sert d’intermédiaire entre le code source lisible par l’homme et le code machine, conçu pour être exécuté par une machine virtuelle (VM) et non directement sur le matériel de l’ordinateur. 

En théorie, tout langage de programmation peut être exécuté à l’aide d’un compilateur ou d’un interprète. Chaque langage de programmation est toutefois particulièrement adapté soit à la compilation, soit à l’interprétation.

En pratique, la distinction entre un langage de compilation et un langage d’interprétation peut parfois être floue, tout comme celle entre un compilateur et un interprète, car les fonctionnalités de ces deux types de programmes peuvent se chevaucher. Si certains langages sont généralement compilés, et d’autres interprétés, il est possible d’écrire un compilateur pour un langage couramment interprété, et inversement.

Les langages de haut niveau sont généralement créés en tenant compte de l’un des types de conversion (compilation ou interprétation), mais il s’agit davantage de suggestions que de limitations strictes. Par exemple, on considère que BASIC est un langage interprété et C, un langage compilé, mais il existe des compilateurs pour BASIC tout comme il y a des interpréteurs C. 

La principale différence entre les interprètes et les compilateurs réside dans le timing et l’optimisation. Les deux types de programmes visent à convertir le code source en code cible, qui est d’abord fonctionnel puis optimisé.

Le choix du code, à savoir compilé ou interprété, dépendra de l’environnement d’exploitation (capacité matérielle, mémoire et stockage). Selon les contraintes du programme, de l’application ou du matériel, on peut choisir la compilation, l’interprétation, ou les deux. 

En tant que telle, l’interprétation ne peut pas se substituer entièrement à la compilation, mais elle peut déplacer les tâches de compilation en l’arrière-plan grâce à un processus de conversion progressif. Les compilateurs suivent une stratégie de conversion anticipée (AOT), qui consiste à convertir entièrement le code source en code cible avant de créer un fichier exécutable.

Les interpréteurs, quant à eux, exécutent le code directement lorsqu’une application l’exige, ou utilisent le bytecode comme intermédiaire pour produire le code source exécutable de la machine virtuelle. Si les interprètes assurent un certain niveau d’accélération ou de flexibilité, un jeu d’instructions machine exécutées directement doit toutefois être fourni vers la fin de la pile d’exécution.

Dans certains cas, lorsque la légèreté est une priorité, les interprètes spéciaux sont préférés aux compilateurs pour leur capacité à effectuer une conversion juste à temps (JIT). La stratégie JIT consiste à compiler des éléments du code source en code cible dans un tampon de mémoire pour une exécution immédiate. L’interprétation JIT compile le code à la demande, alliant l’efficacité des compilateurs traditionnels, qui assurent une compilation ponctuelle, à la liberté d’exécuter le code de manière répétée, souvent plus rapidement qu’un interpréteur bytecode classique.

Cependant, à mesure que les tendances modernes vers la compilation JIT se développent parallèlement à l'interprétation du bytecode en fonction de la situation, de nombreux compilateurs sont conçus pour offrir à la fois des fonctionnalités de compilation et d'interprétation. Ce phénomène brouille davantage les frontières entre ces deux catégories.