Aller au contenu
Encyclopédie informatique Édition 2026

Compilation et interprétation

Un processeur ne comprend qu’une chose : une suite de nombres, les instructions du code machine. Or personne n’écrit de programmes en nombres : on les écrit dans des langages lisibles, comme le C, Python ou Rust. Entre les deux, il faut un traducteur. Il en existe deux grandes familles : le compilateur, qui traduit tout le programme à l’avance, et l’interpréteur, qui le lit et l’exécute pas à pas. Entre elles, des solutions hybrides (code intermédiaire, machine virtuelle, compilation à la volée) sont aujourd’hui les plus courantes. Cet article explique ce que fait un compilateur étape par étape, comment fonctionne un interpréteur, pourquoi la frontière entre les deux est floue, comment on passe d’un programme à un exécutable, et quelles conséquences cela a sur la vitesse, la portabilité, le débogage et la sécurité.

Rubrique
Développement
Niveau
Débutant à avancé
Lecture
24 min (essentiel)
26 min (complet)
Révision
3 novembre 2026
Niveau de lecture :

En bref

  • Un compilateur traduit tout un programme en code machine avant son exécution ; un interpréteur l’exécute instruction après instruction.
  • Un compilateur procède par étapes : analyse du texte, représentation intermédiaire, optimisation, génération du code, puis édition des liens.
  • Aujourd’hui, beaucoup de langages sont hybrides : compilés vers un bytecode (code intermédiaire) exécuté par une machine virtuelle, avec compilation à la volée des passages chauds.
  • On ne dit pas qu’un langage est compilé ou interprété : c’est son implémentation qui l’est.
  • Le choix a des conséquences : vitesse, portabilité, détection d’erreurs, taille et même sécurité du programme obtenu.

Prérequis conseillés : Le binaire · Les langages de programmation

1Le problème : parler à un processeur

Un processeur (voir le processeur) est un circuit électronique qui sait exécuter un petit nombre d’opérations très simples : additionner deux nombres, déplacer une valeur d’un endroit à un autre, comparer, sauter à une autre instruction. Chacune de ces opérations est désignée par un nombre, que l’on appelle une instruction machine, et une suite d’instructions forme le code machine (voir la représentation binaire). Un processeur d’ordinateur personnel et celui d’un téléphone n’utilisent pas le même répertoire d’instructions : on parle de familles d’architectures (x86-64 pour la plupart des ordinateurs, ARM pour les téléphones et de plus en plus d’ordinateurs, RISC-V pour une famille ouverte plus récente).

Écrire directement en code machine est possible, mais pénible et sujet aux erreurs. Imaginez demander l’addition de deux prix en écrivant des suites comme 48 01 d8. Dès les années 1950, on a donc inventé des langages plus proches de la pensée humaine : on y écrit total = prix + taxe, et un programme se charge de traduire. Ce programme traducteur est au cœur de l’informatique, et il peut prendre deux formes : le compilateur et l’interpréteur.

1.1Une analogie : le livre traduit et l’interprète

Pour comprendre la différence, pensez à un discours dans une langue étrangère. Vous pouvez en faire faire une traduction écrite : un traducteur lit tout le texte, le traduit en entier, et vous remettez le document traduit à chaque auditeur, qui le lit autant de fois qu’il veut sans plus avoir besoin du traducteur. C’est le compilateur : un travail fait une fois, à l’avance, dont le résultat (l’exécutable) se réutilise. Ou bien vous faites venir un interprète qui traduit à l’oral, phrase après phrase, pendant que l’orateur parle : il faut sa présence à chaque fois, et il refait la même traduction à chaque discours. C’est l’interpréteur : pas d’attente avant de commencer, mais un travail répété à chaque exécution.

Chaque approche a des avantages évidents. La traduction écrite est rapide à utiliser, car tout est déjà prêt, et le traducteur a pu relire l’ensemble pour détecter les contresens. L’interprète permet de commencer tout de suite, de modifier le discours au dernier moment, et de s’adapter à l’auditoire. Les deux cohabitent aujourd’hui, et la plupart des langages modernes combinent les deux idées.

1.2Un peu d’histoire

Le premier compilateur est généralement attribué à l’Américaine Grace Hopper, qui crée en 1952 le programme A-0 pour l’ordinateur UNIVAC I. À l’époque, beaucoup jugeaient impossible qu’un ordinateur produise lui-même un code efficace ; en 1957, l’équipe de John Backus chez IBM livre le compilateur FORTRAN, dont le code est assez rapide pour convaincre la profession. L’interpréteur naît quasi en même temps : le langage LISP (1958) est conçu pour être interprété, ce qui permet de saisir des expressions et d’en voir immédiatement le résultat. Depuis, l’histoire des langages est aussi celle des compromis entre ces deux approches (voir les langages de programmation).

2Le compilateur

Un compilateur est un programme qui lit un code source dans un langage (par exemple le C) et produit, dans un autre langage, un programme équivalent. Le plus souvent, le langage d’arrivée est le code machine d’une architecture précise. La compilation a lieu avant l’exécution : on compile une fois, puis on exécute autant de fois qu’on veut.

Un compilateur n’est pas un simple traducteur mot à mot : il doit comprendre le programme, vérifier qu’il a un sens, le transformer pour qu’il soit rapide, et enfin le traduire. Ce travail se fait par étapes, enchaînées comme sur une chaîne de montage, que résume la figure 1.

DU TEXTE AU CODE MACHINE : LES ÉTAPES D’UN COMPILATEUR Code source texte du programme total = prix + 2; 1. Lexicale découpe en mots (lexèmes) 2. Syntaxique vérifie la grammaire produit un arbre 3. Sémantique vérifie types et noms sens du programme le programme est compris : il reste à produire la machine 4. Forme intermédiaire neutre, sans machine précise 5. Optimiseur code plus rapide et plus petit 6. Générateur code machine d’une architecture 7. Éditeur de liens assemble avec les bibliothèques Exécutable fichier prêt à lancer Les étapes 1 à 3 lisent le programme ; les étapes 4 à 7 fabriquent le fichier qui s’exécute.
Figure 1. De la source à l’exécutable : les étapes d’un compilateur, du texte au code machine.

2.1Étape 1 : l’analyse lexicale

Le compilateur reçoit un texte brut. La première étape, l’analyse lexicale, le découpe en « mots » appelés lexèmes (en anglais tokens) : mots-clés du langage (if, while), noms choisis par le programmeur (total), nombres, opérateurs (+, ==), signes de ponctuation. Elle ignore les espaces et les commentaires, et signale les caractères qui ne veulent rien dire. La ligne total = prix + 2; donne ainsi cinq lexèmes : un nom, un signe égal, un nom, un plus, un nombre, plus le point-virgule final.

2.2Étape 2 : l’analyse syntaxique

L’analyse syntaxique vérifie que les lexèmes sont assemblés conformément à la grammaire du langage, comme on vérifie qu’une phrase française a un sujet et un verbe. Elle construit un arbre syntaxique, qui exprime la structure du programme. Dans l’expression 2 + 3 * 4, l’arbre indique que la multiplication s’applique à 3 et 4 avant l’addition, ce qui donne 14 et non 20. Quand le programmeur oublie une parenthèse ou un point-virgule, c’est cette étape qui produit l’erreur de syntaxe.

2.3Étape 3 : l’analyse sémantique

Une phrase peut être grammaticalement correcte et n’avoir aucun sens : « le triangle mange la mélodie ». L’analyse sémantique contrôle le sens du programme : une variable utilisée est-elle bien déclarée ? Additionne-t-on un nombre et un texte ? Appelle-t-on une fonction avec le bon nombre de paramètres ? Cette étape repose sur les types des données (entier, texte, booléen, voir les variables et types de données). Dans un langage à typage statique (C, Rust, Go, TypeScript), de nombreuses erreurs sont ainsi détectées avant même que le programme ne tourne, ce qui est un atout majeur.

2.4Étape 4 : la représentation intermédiaire

Une fois le programme compris, le compilateur le traduit en une représentation intermédiaire (RI) : un langage interne, plus simple que le source et indépendant de l’architecture. L’idée est d’une grande portée pratique. Si l’on veut compiler m langages pour n architectures, on n’écrit pas m × n compilateurs, mais m « façades » qui produisent la RI et n « arrières » qui la traduisent en code machine. C’est l’architecture de LLVM, projet né à l’université d’Illinois dans les années 2000 : Clang (pour le C et le C++), Rust, Swift, Zig et d’autres s’en servent, et c’est aussi celle de GCC, l’ancien compilateur de la communauté du logiciel libre.

2.5Étape 5 : l’optimisation

L’optimisation transforme la représentation intermédiaire pour obtenir un programme plus rapide ou plus petit, sans changer son résultat. Le compilateur y excelle, car il voit tout le programme. Quelques exemples de transformations :

  • Le calcul à l’avance : l’expression 60 * 60 * 24 est calculée une fois par le compilateur (86 400) au lieu de l’être à chaque exécution.
  • La suppression du code mort : un morceau qui ne sera jamais exécuté est retiré.
  • L’intégration de fonctions (inlining) : le corps d’une petite fonction remplace son appel, ce qui évite le coût de l’appel.
  • Le déroulage de boucles : on répète le corps d’une boucle plusieurs fois par tour pour réduire le coût de la gestion du compteur.
  • L’allocation de registres : on garde les valeurs les plus utilisées dans les registres, les cases de mémoire minuscules et ultra-rapides du processeur, plutôt que dans la mémoire vive (voir la mémoire vive).
  • La vectorisation : on remplace une boucle de calculs un par un par des instructions qui en traitent plusieurs d’un seul coup.

On règle le niveau d’optimisation au moment de la compilation. Un niveau faible (souvent noté -O0) compile vite et garde le code proche du source, pratique pour déboguer ; un niveau élevé (-O2, -O3) produit un code plus rapide mais plus long à compiler et plus difficile à suivre pas à pas.

2.6Étape 6 : la génération du code machine

Le générateur de code traduit la représentation intermédiaire optimisée en instructions de l’architecture visée. Il choisit les instructions, organise la mémoire et applique les conventions qui permettent aux fonctions de s’appeler entre elles. Souvent, il produit d’abord du langage d’assembleur : une écriture textuelle lisible du code machine, où chaque instruction a un nom court (add, mov, jmp). Un autre programme, l’assembleur, transforme ce texte en nombres. Le résultat est un fichier objet : du code machine, mais incomplet.

2.7Étape 7 : l’édition des liens

Un programme est rarement écrit d’un seul bloc. Il se compose de plusieurs fichiers sources, chacun compilé séparément en un fichier objet, et il utilise des bibliothèques : du code déjà écrit par d’autres (afficher du texte, ouvrir un fichier, dessiner une fenêtre). Dans un fichier objet, les appels vers du code situé ailleurs sont laissés en blanc. L’éditeur de liens (linker) les remplit : il rassemble tous les fichiers objets et les bibliothèques, et il en fait un exécutable.

On distingue deux manières de lier. Avec l’édition statique, le code des bibliothèques est copié dans l’exécutable : le fichier est plus gros, mais il s’exécute seul, sans rien exiger de la machine. Avec l’édition dynamique, l’exécutable contient seulement une référence, et le système charge la bibliothèque (un fichier .so sous Linux, .dll sous Windows, .dylib sous macOS) au démarrage : le fichier est plus petit, la bibliothèque est partagée entre programmes et se met à jour sans recompiler, mais le programme dépend de ce qui est installé sur la machine. Ce choix, anodin en apparence, a des conséquences de sécurité (partie 9).

2.8Ce que le compilateur ne voit pas

La compilation est une vérification partielle. Elle détecte les erreurs de forme et, selon les langages, beaucoup d’erreurs de type. Elle ne peut pas détecter les erreurs de raisonnement : un programme qui calcule une moyenne en divisant par le mauvais nombre se compile sans problème. C’est pourquoi les tests (voir le génie logiciel) restent indispensables.

Pour s’exercer

Exercice 1 : compilateur ou interpréteur ?

Pour chaque situation, dites si elle relève plutôt d’un compilateur ou d’un interpréteur : (a) vous tapez 2 + 2 dans une console et obtenez 4 aussitôt ; (b) vous recevez un fichier .exe que vous lancez par double-clic ; (c) vous modifiez un script et relancez sans étape préalable.

Voir la réponse

(a) Interpréteur : l’instruction est exécutée au fur et à mesure. (b) Compilateur : l’exécutable est le résultat d’une traduction faite à l’avance. (c) Interpréteur, ou machine virtuelle qui compile en bytecode de façon transparente : l’absence d’étape visible est la marque de l’interprétation.

Exercice 2 : découper en lexèmes

Découpez la ligne if (age >= 18) { statut = "majeur"; } en lexèmes, et dites à quelle étape sont découvertes les erreurs de chacun de ces deux défauts : (1) une accolade manquante ; (2) une variable statut jamais déclarée dans un langage à typage statique.

Voir la réponse

Lexèmes : if, (, age, >=, 18, ), {, statut, =, "majeur", ;, }. (1) L’accolade manquante est détectée par l’analyse syntaxique, qui ne parvient pas à construire l’arbre. (2) La variable non déclarée est détectée par l’analyse sémantique.

Exercice 3 : une optimisation à la main

Le compilateur rencontre secondes = 60 * 60 * 24 * jours;. Quelle optimisation peut-il faire, et quel est le gain ?

Voir la réponse

Il peut effectuer à l’avance la partie constante du calcul : 60 × 60 × 24 = 86 400, de sorte que le programme exécute seulement secondes = 86400 * jours;, soit une multiplication au lieu de trois à chaque passage. Le gain est faible ici, mais s’accumule dans une boucle exécutée des millions de fois.

Exercice 4 : statique ou dynamique

Une bibliothèque de dessin est mise à jour pour corriger une faille. Que doit faire l’éditeur d’un logiciel qui l’a liée de façon statique ? Et si elle l’avait été de façon dynamique ?

Voir la réponse

En édition statique, la bibliothèque est copiée dans l’exécutable : l’éditeur doit recompiler et redistribuer son logiciel pour que la correction soit prise en compte. En édition dynamique, le système charge la version installée de la bibliothèque : la mise à jour de celle-ci suffit, sans toucher au logiciel, à condition que sa compatibilité soit préservée. Le prix de la dynamique est la dépendance à ce qui est installé sur la machine.