Assembleur Intel 8086 : Maîtriser les Bases — Cours PDF (Débutant)

Téléchargez un cours assembleur 8086 PDF gratuit pour apprendre, pas à pas, les bases de l'architecture (architecture x86), du langage machine et de la programmation en assembleur de ce microprocesseur emblématique.

Introduction au langage assembleur 8086

Introduction au langage assembleur 8086 : ce module présente les principes fondamentaux, la représentation des données, les registres et les modes d'adressage, ainsi que les outils pour assembler, lier et déboguer du code. Apprendre l'assembleur permet un contrôle direct du CPU et une maîtrise totale du système. Les mnémoniques x86 sont expliqués avec des exemples concrets et des TP guidés pour débuter rapidement.

Point clé — Jürgen Harms : « Ce cours privilégie une approche pratique centrée sur la compréhension des registres, de l'adressage et du jeu d'instructions pour écrire un code assembleur clair et efficace. »

🎯 Ce que vous allez apprendre

• Introduction : Vue d'ensemble du cours et objectifs pédagogiques.
• L’architecture du CPU Intel 8086 : Composants, segments et organisation interne.
• Architecture et registres du microprocesseur 8086 : Registres généraux et registres de segment.
• Jeu d’instructions (Instruction Set) : Instructions de base et syntaxe (MOV, PUSH, POP, etc.).
• Variables et expressions : Gestion des données et conventions en assembleur.
• Aspects méta-assembleur : Directives, macros et sections de données/texte.
• Procédures et macros : Organisation modulaire du code et réutilisabilité.
• Microprocesseur 8088 et compatibilité : Différences et implications pratiques.

Pourquoi apprendre l'assembleur 8086 aujourd'hui ?

Étudier l'assembleur 8086 permet de comprendre des principes fondamentaux toujours présents dans les architectures modernes : gestion des registres, segmentation mémoire, modes d'adressage et traduction vers le langage machine. Ces connaissances facilitent le diagnostic bas‑niveau, l'optimisation des performances et l'interprétation des dumps binaires — compétences utiles en rétro‑ingénierie, électronique embarquée et systèmes industriels. Ce cours permet un contrôle direct du CPU, atout pour concevoir et optimiser des routines critiques.

Maîtriser le contrôle direct du CPU

Maîtriser le contrôle direct du CPU implique l'utilisation précise des registres, du pointeur d'instruction et des interruptions pour orchestrer l'exécution et l'I/O. Les laboratoires incluent des exercices sur la manipulation des flags, la gestion de la pile et l'appel de services BIOS via interruptions, afin d'acquérir une compréhension pratique des effets de chaque instruction sur l'état processeur et la mémoire.

Architecture et registres du microprocesseur 8086

Le 8086 dispose d'une organisation en segments et d'un ensemble de registres destinés aux opérations arithmétiques, au calcul d'adresses et au contrôle d'exécution. Le cours détaille l'utilisation opérationnelle de ces registres et leur rôle dans l'adressage mémoire et la génération d'instructions machine.

• AX — Registre accumulateur (opérations arithmétiques et I/O).
• BX — Registre base (adressage et stockage temporaire).
• CX — Registre compteur (boucles et opérations répétitives).
• DX — Registre données (I/O et opérations 32/16 bits).
• SP — Stack Pointer (pile).
• BP — Base Pointer (accès aux paramètres et variables locales).
• SI / DI — Source / Destination Index (opérations sur les chaînes).
• CS / DS / ES / SS — Registres de segment (code, données, extra, pile).
• IP — Instruction Pointer (compteur d'instructions).
• Flags — Registre d'état (indicateurs d'arithmétique et de contrôle).

Compatibilité 8088 : le 8088 conserve le jeu d'instructions mais possède un bus de données externe 8 bits (au lieu de 16 pour le 8086), ce qui impacte les performances et certains choix matériels. Le cours compare ces différences pour guider le développement et l'émulation.

Syntaxe et jeu d'instructions de base

Le cours présente la syntaxe standard des mnémoniques x86 et les modes d'adressage courants. Les instructions fondamentales couvertes incluent MOV, PUSH/POP, CALL/RET, ainsi que les opérations arithmétiques et logiques de base.

• Instructions de transfert : MOV, PUSH, POP — transfert de données entre registres, pile et mémoire.
• Instructions arithmétiques : ADD, SUB — opérations sur registres et mémoire avec gestion des flags.
• Instructions logiques : AND, OR, XOR — opérations bit à bit pour masquage et tests.

• Adressage immédiat : opérande littérale codée dans l'instruction (ex. MOV AX, 0x10).
• Adressage registre : opérandes situés dans des registres (ex. MOV BX, AX).
• Adressage direct : accès à une adresse mémoire fixe dans le segment de données.
• Adressage indirect : utilisation d'un registre pointeur pour référencer la mémoire (ex. MOV AX, [BX]).
• Adressage indexé / basé : combinaison base+index+offset pour calculer l'adresse effective (ex. MOV AX, [BP+SI+4]).

; Exemples simples commentés
; Charger une valeur immédiate dans AX
MOV AX, 0x1234    ; AX <- 0x1234

; Copier le contenu de AX dans BX
MOV BX, AX        ; BX <- AX

; Sauvegarder AX sur la pile
PUSH AX           ; SP <- SP - 2 ; [SS:SP] <- AX

; Restaurer dans CX depuis la pile
POP CX            ; CX <- [SS:SP] ; SP <- SP + 2

Une attention particulière est portée à la relation entre la syntaxe assembleur et le langage machine généré, ainsi qu'à l'utilisation des registres de segment pour un adressage sûr et efficace.

Tableau récapitulatif des modes d'adressage

Ce tableau synthétise les principaux modes d'adressage, leur utilisation courante et un exemple de mnémonique pour faciliter la lecture et la mise en pratique lors des exercices.

Référence rapide : l'usage combiné de registres indexés permet d'implémenter des structures de données et des boucles efficaces en assembleur.

Comprendre la segmentation mémoire du 8086

La segmentation mémoire du 8086 divise l'espace en segments de 64 Ko chacun. Chaque segment est référencé par un registre de segment (CS, DS, ES, SS) et un offset de 16 bits. L'adresse physique est calculée par la formule : adresse physique = (segment × 16) + offset. Cette limite de 64 Ko par segment impose des conventions d'organisation des données et du code, et explique l'importance du choix des registres de segment lors de l'adressage indexé et des accès mémoire.

Les interruptions et entrées/sorties en assembleur

Les interruptions constituent le mécanisme principal pour communiquer avec le système et les périphériques sur les environnements DOS ou émulateurs. Le 8086 déclenche une routine d'interruption via l'instruction INT, permettant d'appeler des services du BIOS ou du système d'exploitation. Les interruptions sont également utilisées pour gérer les entrées/sorties synchrones et asynchrones. Les TP incluent des exemples pratiques d'appel d'interruptions et d'analyse du contexte poussé.

Les interruptions logicielles (INT)

L'interruption logicielle la plus courante en environnement DOS est INT 21h. Elle regroupe de nombreux services : affichage à l'écran, lecture au clavier, gestion de fichiers, et terminaison de programmes. Pour appeler un service, on place le numéro de fonction dans AH puis on exécute INT 21h. Par exemple, MOV AH, 0x4C puis INT 21h termine le programme en renvoyant un code au système. L'étude pratique des interruptions est incluse dans les TP pour illustrer l'interaction entre code assembleur et services système.

Outils et environnement de développement

Pour pratiquer, le cours recommande l'utilisation d'émulateurs et d'environnements légers : DOSBox pour exécuter des programmes DOS sur des systèmes modernes, et EMU8086 pour l'édition, l'assemblage et le débogage pas à pas. DOSBox reproduit un environnement DOS complet, utile pour tester des binaires natifs. EMU8086 apporte un assembleur intégré, un moniteur mémoire et un simulateur d'interruptions, facilitant l'apprentissage des mnémoniques x86, de l'adressage indexé et des interactions I/O. Les chapitres pratiques incluent des instructions d'installation et des exemples de configuration pour ces outils.

Prérequis pour ce cours

Notions recommandées : logique binaire (bases 2 et 16), représentation hexadécimale, compréhension des concepts bit/byte, et notions générales en informatique (variables, boucles, et notion de pile). Ces prérequis facilitent l'assimilation des exemples et des TP, sans être strictement obligatoires.

Exercices et TP d'assembleur 8086 corrigés

Le support inclut des exercices et travaux pratiques corrigés avec solutions détaillées pour valider l'apprentissage des mnémoniques, des modes d'adressage et des routines d'interruption. Les corrigés fournissent des explications pas à pas et des suggestions d'optimisation pour chaque solution.

👤 À qui s'adresse ce cours ?

Destiné aux débutants en architecture et programmation bas‑niveau : étudiants en informatique, électronique, génie industriel et techniciens souhaitant comprendre le fonctionnement bas‑niveau des systèmes. Les exercices guidés et les exemples commentés facilitent l'acquisition progressive des compétences pratiques.