⚙️ Pipeline de compilation

Le code à trois adresses (TAC) est une représentation intermédiaire où chaque instruction comporte au plus un opérateur et trois opérandes (deux sources et une destination) : par exemple t1 = a * b ; t2 = t1 + c. Cette structure simple et uniforme facilite l'analyse de flux de données — chaque temporaire est défini une seule fois, ce qui facilite la forme SSA (Static Single Assignment). La plupart des compilateurs modernes (GCC, LLVM) utilisent une forme de TAC en interne avant de descendre vers l'assembleur ; la RI de LLVM en est un exemple bien connu et lisible par l'humain.

La propagation de constantes (constant folding) est une optimisation qui évalue les sous-expressions constantes au moment de la compilation plutôt que de générer du code pour les calculer à l'exécution. Par exemple, 2 * 3 + 1 devient 7 sans aucun coût à l'exécution. Les compilateurs modernes propagent aussi les constantes à travers les affectations de variables (propagation de constantes), permettent d'autres simplifications comme l'élimination de code mort, et évaluent même les appels de fonctions pures dont tous les arguments sont constants. L'effet combiné peut réduire considérablement le nombre d'instructions dans du code comportant de nombreux calculs littéraux.

Un compilateur traduit le code source en une représentation cible à l'avance (AOT, ahead-of-time), produisant un artefact — un binaire, du bytecode, ou une RI — pouvant s'exécuter indépendamment du compilateur. Un interpréteur lit le source (ou le bytecode) et l'exécute directement, instruction par instruction, au moment de l'exécution. De nombreux systèmes modernes combinent les deux : Python compile vers du bytecode (.pyc) que l'interpréteur CPython exécute ensuite, et les moteurs JavaScript compilent vers du code machine à l'aide de la compilation à la volée (JIT) pour les chemins de code fréquemment exécutés.

Une grammaire formelle est un ensemble de règles de production qui définissent quelles chaînes de tokens sont valides dans un langage. Les grammaires hors contexte (CFG), décrites en forme de Backus-Naur (BNF) ou BNF étendue, sont utilisées pour la plupart des langages de programmation. Un analyseur syntaxique vérifie que l'entrée est conforme à la grammaire et construit l'AST. La célèbre hiérarchie de Chomsky classe les grammaires par pouvoir expressif ; les grammaires hors contexte sont suffisamment puissantes pour décrire des structures imbriquées comme des parenthèses équilibrées, ce que les expressions régulières ne peuvent pas faire.

L'analyse sémantique vérifie des contraintes que la grammaire ne peut pas exprimer : vérification de types (ajoute-t-on un entier à une chaîne ?), résolution de portée (cette variable est-elle déclarée avant utilisation ?), et détection d'utilisation avant initialisation. Dans les langages à typage statique, cette phase construit une table des symboles associant les identifiants à leurs types et intègre des annotations de type dans l'AST. Les erreurs à ce stade produisent les fameux messages « incompatibilité de type » ou « variable non déclarée » qui apparaissent après une analyse syntaxique réussie.

Les compilateurs modernes appliquent des dizaines de passes d'optimisation : l'élimination de code mort supprime les instructions dont les résultats ne sont jamais utilisés ; le déroulement de boucle réduit le coût des branchements ; l'inlining substitue les sites d'appel de fonction par le corps de la fonction pour éliminer le coût d'appel ; l'élimination de sous-expressions communes (CSE) évite de recalculer des expressions identiques ; et l'auto-vectorisation réécrit les boucles scalaires pour utiliser les instructions CPU SIMD (Single Instruction, Multiple Data). Le pipeline d'optimisation de LLVM applique environ 60 passes au niveau -O2, et les gains de performance obtenus vont couramment de 2x à 10x par rapport au code non optimisé.

Un compilateur JIT compile le code au moment de l'exécution, généralement après avoir observé qu'il s'exécute fréquemment (« chemins chauds »). Le moteur V8 (utilisé dans Chrome et Node.js) commence par interpréter le bytecode JavaScript, profile les fonctions les plus appelées, puis les compile en code machine natif optimisé. Si une hypothèse faite précédemment (par exemple qu'une variable contient toujours un entier) est ensuite violée, V8 « désoptimise » et revient à l'exécution interprétée. Le JavaScript compilé en JIT peut s'exécuter à 2-3 fois la vitesse du code C équivalent pour de nombreuses charges de travail.