Cours Langages de programmation et compilation en PDF

Langages de programmation et compilation : Ce qu'il faut savoir. Discipline qui étudie la traduction automatisée de programmes d'un langage source vers un langage cible, en assurant correction, détection d'erreurs et optimisation du code produit. Ce domaine articule théorie (syntaxe, sémantique, automates) et ingénierie (génération de code, assembleur, optimisation), et reste central pour produire des exécutables efficaces et fiables. Le cours aborde aussi les représentations intermédiaires (IR) comme le three‑address code et la forme SSA, ainsi que les techniques d'optimisation locale, globale et interprocédurale. PDF disponible en lecture et téléchargement gratuit.

🎯 Ce que vous allez apprendre

• Phases classiques d'un compilateur (analyse et synthèse) — identification claire des étapes : lexing, parsing, construction d'un arbre de syntaxe abstraite (AST) et analyse sémantique jusqu'à la table des symboles. Vous saurez repérer où sont détectées les erreurs de syntaxe, de portée et de typage, et comment ces informations alimentent la génération de code, notamment via une IR (three‑address code/SSA) servant d'intermédiaire pour les passes d'optimisation.
• Représentation des données au niveau machine — étude des entiers non signés et signés en complément à deux, opérations bit à bit et décalages. Connaître ces représentations permet d'anticiper comportements de conversion, débordements et optimisations à l'échelle du registre lors de la production de code assembleur, en tenant compte de l'endianness et des règles de représentation des flottants (IEEE‑754) lorsque pertinent.
• Architecture cible MIPS et modèles d'exécution — conventions de registres, principe du fetch/decode/execute, pipeline et prédiction de branchement. Vous serez capable de concevoir une génération de code adaptée à une architecture RISC (MIPS) et d'évaluer l'impact des choix de code sur le pipeline et la latence, en tenant compte des conventions d'appel (caller/callee‑saved), de l'organisation de la pile et des éventuels delay slots.
• Génération de code et toolchain — passage de la syntaxe abstraite à l'assembleur, utilisation d'un assembleur et d'un éditeur de liens, et notions de langage machine. Vous comprendrez les transformations intermédiaires (IR), saurez lire/expliquer un extrait assembleur ou machine et une instruction comme addi $a2 $a1 10, et connaîtrez les éléments de la toolchain (assembleur/as, linker/ld, formats objets comme ELF).
• Qualité d'un compilateur et optimisation — critères de correction, efficacité du code produit et performance du compilateur lui‑même. Vous saurez distinguer optimisations sûres des transformations dangereuses, mesurer leurs gains sur le code cible et comprendre les approches formelles pour garantir la préservation de la sémantique lors des transformations.
• Travaux dirigés et projet pratique avec exercices corrigés — exercices basés sur MIPS et études d'exemples en C/assembleur présents dans le document, incluant un projet de traduction et d'optimisations. Les exercices corrigés facilitent la validation des méthodes d'analyse et de génération de code.

📑 Sommaire du document

• Compilation : définition, historique et rôle du compilateur dans le cycle de vie du logiciel.
• Différence entre compilateur et interprète : comparaison des modèles d'exécution, coûts d'exécution et cas d'usage.
• Qualité d’un compilateur : critères de correction, robustesse, performance et tests de validation.
• Phases d’un compilateur : présentation détaillée des étapes classiques depuis l'analyse lexicale jusqu'à la génération de code.
• Phase d’analyse : lexing, parsing, construction d'AST, analyse sémantique et gestion de la table des symboles.
• Phase de synthèse : génération d'un code intermédiaire, optimisation et traduction vers l'assembleur/objet.
• Un peu d’arithmétique des ordinateurs : représentations binaires, complément à deux, débordements et opérations au niveau machine.
• Quelle architecture pour ce cours ? : choix de MIPS comme cible pédagogique, conventions d'appel et contraintes matérielles influençant la génération de code.

💡 Pourquoi choisir ce cours ?

Ces notes, issues d'un enseignement à l'École Normale Supérieure et rédigées par Jean-Christophe Filliâtre, réunissent théorie formelle et considérations pratiques autour de MIPS et de la génération de code. Le polycopié alterne exposé conceptuel (AST, table des symboles, complément à deux) et exercices/TD orientés implémentation, ce qui facilite l'assimilation des transformations intermédiaires. Le document se distingue par son équilibre entre rigueur sur la correction des traductions et application concrète via des exemples en C et en assembleur. Il met également en perspective les compromis entre optimisation locale, optimisation globale et coûts de compilation.

👤 À qui s'adresse ce cours ?

• Public cible : étudiants en informatique de niveau licence supérieure / master, ingénieurs logiciel souhaitant approfondir la compilation bas‑niveau, et développeurs systèmes travaillant sur génération de code ou backends de compilateur.
• Prérequis : maîtrise des bases du langage C (syntaxe, fonctions, boucles), notions d'algorithmes et structures de données, et compréhension élémentaire de l'architecture matérielle (registres, mémoire, représentation binaire). Une familiarité avec un environnement UNIX (utilisation du shell, gcc/make) et des notions de complexité algorithmique (notations O) sont un plus pour tirer pleinement parti des TD.

❓ Foire Aux Questions (FAQ)

Comment l'AST est-il utilisé pour l'analyse sémantique et la génération de code ?

L'AST représente la structure syntaxique épurée et sert de support pour l'enrichissement sémantique (vérification de types, annotations pour la table des symboles). Une fois annoté, l'AST permet d'itérer sur les nœuds pour produire des séquences d'instructions intermédiaires puis assembler des motifs optimisés pour la cible. Dans la pratique, l'AST est souvent transformé en une IR (three‑address code ou SSA) qui facilite les passes d'analyse (liveness, allocation de registres) et d'optimisation.

Quelles contraintes matérielles influencent la génération de code pour MIPS ?

Les contraintes incluent le jeu de registres limité, les opérations atomiques disponibles, le coût d'accès mémoire et le pipeline (hazards, prédiction de branchement). Ces éléments guident le choix d'allocation de registres, l'ordonnancement d'instructions et les optimisations adaptées à une architecture RISC.

Conclusion : ce polycopié fournit un tutoriel et des exercices corrigés pour progresser en compilation et génération de code. Téléchargez le PDF gratuit pour consulter l'intégralité des exposés, des TD et du projet pratique et commencer les exercices immédiatement.