- Unité Centrale de Traitement (UCT) :

- UAL : Unité arithmétique et logique

- UC : Unité de contrôle
- Bus internes

- Catégories de mémoire :
- Registres : type de mémoire à capacité réduite présente dans l’UCT
- Mémoire cache : mémoire intermédiaire accessible directement par le microprocesseur
- Mémoire centrale : mémoire accessible via le bus
- Mméoire de masse : accessible via les dispositifs d’entrée-sortie avec un temps d’accès
plus long

- Structure de la mémoire :
- Composée de cases mémoires (cellule élémentaire d’un octet) de taille fixe (généralement
1 octet = 8 bits)
- Information codée sur plusieurs octets se stocke sur plusieurs cases mémoire consécutives

- Localisation de case mémoire : par adresse mémoire unique

- Mot = 2 octets, stocké dans 2 cases mémoires consécutives.

Sens de stockage d’information :

- Mode little-endian : octet de poids faible avant

octet de poids fort
- Intérêt : accélérer les opérations nécessitant de
regarder en premier les bits de poids forts
(exemple : addition).
- Mode big-endian :octet de poids fort avant octet de
poids faible
- Intérêt : accélérer les opérations nécessitant de
regarder en premier les bits de poids forts (exemple :
recherche de signe, comparaison de deux entiers).

- Donc un octet c’est 8 bits et donc deux nombres hexadécimaux, exemple : 0D.

BUS de taille n :
- Ensemble de fils électriques
- 1 fil conducteur = 1 signal binaire transporté
- Informations de 0 à 2n-1

Type de Bus :
- Bus de données : bidir
- Bus de commande :
- Bus d’adresse :

Type de bus Direction Fonction

Véhicule les données entre le microprocesseur et un composant
Bus de données Bidirectionnel
(lecture écriture)
Bus de Le microprocesseur synchronise et commande les boîtiers
Unidirectionnel
commande mémoire et entrée/sortie
Véhicule l'adresse d'une brique élémentaire de la mémoire du
Bus d'adresse Unidirectionnel
microprocesseur vers les autres composants

H
- Processeur n bits = taille de ses registres.

- Bus d’adresse 16 bits ⇒ 2^16 = 65,536 adresse possibles = 65,536 octets / 1024 = 64 ko

- Bus d’adresse 20 bits ⇒ 2^20 = 1 048 576 adresse possibles = 1 048 576 octets / (1024*1024) =
1 MO
-Séquences d’instructions d’un programme : par l’UCT

Registres :
- Intégrés directement à l’UCT
- Types :
- IR : Registre d’instruction :
- Contient l’instruction en cours d’exécution par l’unité de traitement
- Instruction en amont décodée par l’unité de contrôle
- CO : compteur ordinal :
- Appelé « compteur programme »
- En anglais : CP ou IP « Instruction Pointer »
- Contient l’adresse de la prochaine instruction que doit exécuter l’unité de traitement
- Registre d’état :
- Mémorise l’état de l’UAL à l’issue d’une opération.
- Registre formé de bits « drapeaux » ou indicateurs
- Registres tampons :
- Mémorise l’état des registres de données et d’adresse
- Des registres d’interface avec les bus de données et d’adresse
- Registres généraux :
- Stocker temporairement les données manipulées par l’UCT, dont :
- Les opérandes de l’UAL
- Les résultats de l’opération réalisée par l’UAL

UNITÉ ARITHMÉTIQUE ET LOGIQUE : réalise :

- Opérations arithmétiques : addition, soustraction, multiplication, divison..
- Opérations logiques : ET, OU, NON …
- Opérations sur les bits : décalage de bits dans les registres
FLAGS : bits regroupés dans le registre d’état à la sortie de l’UAL, mis à jour dès un changement ou opération
logique/arithmétique effectuée, les principaux :
- CF (Carry Flag) :

Type d'arithmétique Armé si Désarmé si

- Retenue générée sur le bit Pas de retenue sur le bit de poids
Signée
de poids fort fort
- Retenue générée sur le bit - Pas de retenue sur le bit de poids
Non signée de poids fort fort
- Débordement - Pas de débordement

- PF (Parity Flag = Drapeau de parité) : armé si l’octet de poids faible du résultat généré d’une opération
arithmétique contient un nombre pair de bits à 1 , désarmé sinon.
- ZF (Zero Flag = Drapeau zéro) : armé si résultat d’opération arithmétique vaut zéro, désarmé sinon.
- SF (Sign Flag = Drapeau de signe) :
- Armé si le résultat d’opération arithmétique possède un bit de poids fort à 1 (indiquant ainsi un nombre
signé)
- Désarmé dans les autres cas (indiquant possiblement résultat non signé, c-à-d positif)

UNITÉ DE COMMANDE OU DE CONTRÔLE :

étapes chronologiques qui décrivent le fonctionnement de l'unité de contrôle (UC) dans un processeur :
1. Contrôle des éléments de l'Unité Centrale de Traitement (UCT) : L'UC gère les signaux de contrôle à
travers le processeur, orchestrant les interactions entre les composants électroniques de l'UCT.
1. Décodage de l'instruction courante : L'UC décode l'instruction actuelle du Registre d'Instruction (RI),
déterminant ainsi l'opération à effectuer et les registres ou zones de mémoire impliqués.
2. Génération de signaux de commande : Suite au décodage, l'UC génère des micro-instructions sous forme
de signaux de commande, qui orientent le fonctionnement des autres composants du processeur.
3. Initialisation des registres généraux : L'UC envoie des signaux aux registres généraux pour charger les
opérandes appropriés en préparation de l'opération à venir.
4. Chargement de l'opération dans l'Unité Arithmétique et Logique (UAL) : Une fois les opérandes
chargés dans les registres, l'UC sélectionne et charge l'opération adéquate dans l'UAL, qui exécute alors
l'opération.
- En somme, l'unité de contrôle sert d'intermédiaire entre les instructions logicielles et les circuits électroniques de
l'UCT, assurant le bon déroulement des opérations et l'exécution précise des instructions.
- Instruction 0 : l’UCT exécute chaque instruction du programme en commençant par l’instruction 0

INSTRUCTIONS ET CYCLE D’INSTRUCTION :

1. Instructions : Les instructions sont un ensemble de commandes transmises au processeur qui spécifient
l'opération à effectuer. Elles sont formulées dans un format binaire pour être exécutées par l'Unité Centrale
de Traitement (UCT).
2. Langage mnémonique : Les instructions sont écrites par le développeur en utilisant des mnémoniques,
également appelées langage assembleur. Ces mnémoniques rendent le code plus compréhensible pour le
 développeur. Par exemple, "MOV dst,src" indique que la valeur de "src" doit être placée dans "dst", et
"ADD dst,src" signifie qu'il faut additionner "src" à "dst" et stocker le résultat dans "dst".
3. Assembleur : Le langage mnémonique est transformé en code binaire à l'aide d'un logiciel d'assemblage,
aussi appelé "assembleur".
4. Stockage des instructions :
- Avant l'exécution d'un programme : l'ensemble des instructions machines (binaires) qui le constituent
est stocké dans une mémoire de masse.
- Lors du lancement du programme : ces instructions sont transférées dans la mémoire principale pour un
accès plus rapide par l'UCT.
5. Format d'une instruction binaire : Une instruction binaire est une séquence de bits de taille variable
(généralement de 1 à 4 octets). Elle comprend deux parties principales :
• Le code d'opération (CODOP) : Ce code indique l'opération spécifique que l'UCT doit effectuer. Il
détermine également comment les opérandes doivent être interprétés.
• Les opérandes : Ce sont les valeurs ou les adresses de mémoire sur lesquelles l'opération doit être
effectuée.

DU LOGICIEL AU MATÉRIEL :
- Langage machine : L'ensemble des instructions disponibles pour un processeur donné constitue le langage
machine. Chaque instruction logicielle correspond à une séquence de micro-instructions matérielles.
- Exécutable : ensemble d’instructions machines constituant un programme
- Langage assembleur : traduit chaque instruction binaire en un code plus compréhensible et intuitif, généralement
une abréviation d'un mot anglais, appelé mnémonique.
 PROCESSEUR 8086 :

- Premier processeur de la famille des processeurs Intel, allant de 8086 à Pentium

- Contient 29000 transistors, cadencé à une fréquence allant de 4,77 MHz à 10 MHz

- Particularité :
- Bus d’adresse de 20 bits (5 symboles hexa) = 1 Mo adressable
- Bus de données de 16 bits (4 symboles hexa)
- Registres de 16 bits (y compris registre d’adresse)
- Mécanisme d’adressage particulier :
- Pour adresser les 2^20 adresses possibles
- L’adresse est décomposée et stockée en deux parties dans deux registres
- Données stockées en mode little endian

ARCHITECTURE INTERNE DU 8086 :

- Unité d'Exécution (UE) : Réalise les opérations arithmétiques/logiques et gère les registres de données.
- Unité d'Interface avec le Bus (UIB) : Assure la communication entre le processeur et les autres
composants du système via le bus système.

- Traitement Pipeline : Technique d'optimisation permettant le traitement simultané de plusieurs

instructions à différents stades. Dans le contexte du 8086, pendant qu'une instruction est traitée par l'UE,
l'UIB précharge les instructions suivantes.
 SEGMENTATION DE LA MÉMOIRE 8086 :

- Paragraphes en mémoire : La mémoire est divisée en paragraphes, chaque paragraphe étant un ensemble
de 16 adresses consécutives dont la première est un multiple de 16. Les paragraphes sont repérés par les
chiffres hexadécimaux de poids forts (16 premiers bits) d’une adresse.

- Bus d'adresse et registres : Le bus d'adresse de 20 bits permet d'adresser 2^20 adresses physiques, mais
les registres ne peuvent stocker que des adresses sur 16 bits
- Adresses logiques : Chaque adresse physique est décomposée en un couple de valeurs : numéro de
segment / déplacement dans le segment (offset). Ce couple est désigné sous le terme adresse logique.

- Segments : Un segment est un ensemble de 64 Ko consécutifs, dont le premier élément coïncide avec le
début d'un paragraphe. Le déplacement (offset) spécifie un octet particulier dans un segment.

- Relation entre adresse physique et logique : La relation entre adresse physique et adresse logique est :
adresse physique = 16 x segment + déplacement. Ainsi, à chaque adresse physique peut correspondre
plusieurs couples segment/déplacement. En effet, chaque adresse physique peut correspondre à 4096
adresses logiques différentes.

- Segments utilisés par un programme : Lors de son exécution, un programme utilise plusieurs segments
mémoire, Ces trois segments peuvent se situer n'importe où en mémoire et peuvent même se recouvrir
partiellement. :
• Le segment de code , qui contient les instructions du programme.
• Le segment de données , qui contient les données du programme.
• Le segment de pile , qui contient la pile du programme.
 LES REGISTRES DU 8086 :

1. Registres de segment : Ils stockent les numéros de segments de mémoire. Chaque registre a un rôle
précis :
• CS (Code Segment) : Stocke le numéro de segment où se trouve le programme en cours d'exécution.
• DS (Data Segment) : Stocke le numéro de segment où sont stockées les données. Doit être initialisé
dans le programme.
• SS (Stack Segment) : Stocke le numéro de segment où est stockée la pile.
• ES (Extra Segment) : Stocke un numéro de segment supplémentaire pour l'adressage de données.
2. Registres généraux : Ils servent à stocker des données. Ils sont subdivisés en registres de 8 bits (haute et
basse) :
• AX, BX, CX, DX : Registres généraux. Ils se décomposent en registres de 8 bits : AH/AL, BH/BL,
CH/CL, DH/DL.
• SI (Source Index) et DI (Destination Index) : Ils contiennent le déplacement dans le segment de
données et sont généralement utilisés pour le transfert d'un ensemble d'octets dans la mémoire.
• SP (Stack Pointer) et BP (Base Pointer) : Ils gèrent la pile et sont associés par défaut à SS.
• SP est le pointeur de pile qui contient le déplacement dans le segment de pile de l'adresse de
la case mémoire courante de la pile (change constamment à mesure que des éléments sont
poussés et retirés de la pile.) .
• BP permet d'adresser une case mémoire particulière de la pile. (souvent utilisé pour accéder à
des éléments spécifiques sur la pile, comme les arguments de fonction et les variables locales,
qui sont à des positions fixes par rapport à BP)
3. Registres spéciaux : spéciaux en ce sens qu'ils ne sont pas accessibles pour une manipulation directe par
les instructions standard, mais leur contenu peut être modifié indirectement par certaines instructions.
• FLAG (Registre d'état) : Il contient les drapeaux indiquant l'état de l'Unité Arithmétique et Logique
(UAL) après une opération. Ces drapeaux peuvent être utilisés par des instructions de branchement
conditionnel.
• IP (Instruction Pointer) : Il spécifie le déplacement dans le segment de code de l'adresse mémoire
de la prochaine instruction à exécuter. L'adresse mémoire spécifiée par CS:IP pointe sur la case
mémoire contenant la prochaine instruction à exécuter.
Détails sur le registre d'état (FLAG) :
• CF (Carry Flag) :

Type
Armé si Désarmé si
d'arithmétique
- Retenue générée sur Pas de retenue sur le bit de
Signée
le bit de poids fort poids fort
- Retenue générée sur - Pas de retenue sur le bit
Non signée le bit de poids fort de poids fort
- Débordement - Pas de débordement

• PF (Parity Flag) : armé si l’octet de poids faible du résultat généré d’une opération arithmétique
contient un nombre pair de bits à 1 , désarmé sinon.
• AF (Auxiliary Flag) : Indique une demi-retenue (retenue est générée en sortie du quarter de poids
faible (4 bits de poids faible) sur le quarter de poids fort (4 bits de poids fort)
• ZF (Zero Flag) : Indique que le résultat de l'opération est zéro.
• SF (Sign Flag) : Indique le signe du résultat pour les opérations sur des entiers signés.
• OF (Overflow Flag) : Indique un débordement arithmétique sur entiers signés
• DF (Direction Flag) : Indique la direction pour les instructions de manipulation de chaînes de
caractères.
• IF (Interrupt Flag) : Autorise la prise en compte des interruptions externes.
• TF (Trap Flag) : Autorise l'exécution en mode pas à pas du programme.

MODES D’ADRESSAGE DU 8086 :

1. Adressage immédiat : Dans ce mode, l'opérande est directement donnée dans l'instruction elle-
même. Par exemple, dans l'instruction MOV AX, 8, 8 est une valeur immédiate. Le processeur
prend simplement cette valeur et la met dans le registre AX.
1. Adressage registre : Ici, l'opérande est un registre du processeur. Par exemple, dans MOV AX, BX,
le contenu du registre BX est copié dans le registre AX.
2. Adressage direct : Dans ce mode, l'adresse de la mémoire où se trouve l'opérande est spécifiée
directement dans l'instruction. Par exemple, dans MOV AL, [0008], l'opérande est à l'adresse
mémoire 0008. Le processeur va à cette adresse, récupère la valeur stockée là-bas et la place dans le
registre AL.
MOV AL, [0008]
MOV AX, DS :1999
MOV AX, Variable ; (variable étant une étiquette)
3. Adressage indirect : Dans ce mode, l'adresse de l'opérande est stockée dans un registre. Par
exemple, dans MOV AX, [BX], l'adresse de l'opérande est stockée dans le registre BX. Le
processeur va à l'adresse spécifiée par BX, récupère la valeur stockée à cette adresse et la place dans
AX. Ce mode a plusieurs variantes :
• Adressage basé : L'adresse est déterminée par le contenu d'un registre de base. Par exemple,
MOV AX,[BP] utilise le contenu de BP comme adresse.
• Adressage indexé : L'adresse est déterminée par le contenu d'un registre d'index additionné à
une valeur constante. Par exemple, MOV AX,[SI +123h] utilise le contenu de SI plus la
constante hexadécimale 123h comme adresse.
• Adressage basé indexé : L'adresse est déterminée en additionnant le contenu de deux
registres. Par exemple, MOV AX,[BP + SI + 123h] utilise le contenu de BP plus le
contenu de SI plus la constante hexadécimale 123h comme adresse.
 STRUCTURE D’UN PROGRAMME 8086 :

Directives : Les directives sont des instructions spéciales que vous donnez à l'assembleur. Elles ne sont pas
traduites en code machine mais servent à contrôler le processus d'assemblage.
• SEGMENT : Cette directive indique le début d'un segment. Un segment peut être un segment de
code, un segment de données ou un segment de pile.
• ENDS : Cette directive indique la fin d'un segment.
• END : Cette directive indique la fin du programme. Elle doit être suivie de l'étiquette du point
d'entrée du programme.
• Assume : permet de spécifier quelle partie du programme constitue le code (étiquette associée à CS)
et quelle partie du programme est associée aux données (étiquette associée à DS)
Etiquette :
- Les étiquettes peuvent être nommées de façon arbitraire (au choix du programmeur).
- Une étiquette est une manière symbolique de représenter une adresse en mémoire.
- Etiquette main : spécifie le point d’entrée du programme

DÉCLARATION DE VARIABLES :

J
- Variable de type WORD
N1 dw 25h //Variable de type WORD initialisée à 25 (en héxa)
N2 dw 4 //Variable de type WORD initialisée à 4 (en décimal)
Prod dw ? //Varibale de type WORD non initialisée.

- Tableau de type WORD :

Table dw 10,20,30,40,50 //Tableau (suite) de WORD initialisé à 10 … 50 (en décimal)
TabVide dw 100 dup(?) //Tableau de 100 WORD non initialisé
Tab dw 50 dup(1b) //Tableau de 50 WORD initialisés à 1 (en binaire)
INTRODUCITON GROUPES D’INSTRUCTIONS :

- Instructions arithmétiques et logiques : Ces instructions sont utilisées pour effectuer des opérations arithmétiques
et logiques sur des valeurs. Par exemple, l'instruction ADD AX, BX ajoute le contenu du registre BX à celui du
registre AX. Les opérations arithmétiques courantes incluent l'addition, la soustraction, la multiplication, la division,
etc. Les opérations logiques courantes incluent les opérations ET, OU, NON, etc.
- Instructions de transfert : Ces instructions permettent de déplacer des données entre les registres, la mémoire et le
processeur. Par exemple, l'instruction MOV AX, [BX] copie le contenu de l'adresse mémoire pointée par BX dans
le registre AX.
- Permettant de copier le contenu d’une (variable, registre, case mémoire) dans une autre (variable, registre, case
mémoire).
Exemple : MOV, XCHG, LEA, PUSH, POP, PUSHA, POPA
- Instructions de test : Ces instructions permettent de comparer des valeurs et de modifier l'état des drapeaux du
processeur en conséquence. Par exemple, l'instruction CMP AX, BX compare les valeurs des registres AX et BX et
définit les drapeaux ZF (Zero Flag), SF (Sign Flag) et CF (Carry Flag) en fonction du résultat.
- Instructions de modification de séquence : Ces instructions permettent de changer l'ordre d'exécution des
instructions en modifiant la valeur du registre d'instruction du processeur (IP - Instruction Pointer). Par exemple,
l'instruction JMP label fait un saut inconditionnel à l'instruction marquée par label, tandis que JE label fait
un saut à label seulement si le drapeau ZF (Zero Flag) est défini, c'est-à-dire si la dernière opération de
comparaison a donné un résultat égal à zéro.

INSTRUCTION MOV :

• Prend deux opérandes : MOV dest, src

• Pas possible de charger une case mémoire du contenu d’une autre case mémoire directement
• Les opérandes sont :
◦ Soit deux registres
◦ Soit un registre, une cellule mémoire
• Pas possible : adressage immédiat dans un registre segment
◦ C’est pourquoi un programme assembleur initialise DS ainsi :
mov AX, data
mov DS, AX
• Les opérandes doivent être de même taille (8 ou 16 bits)
• En cas d’écriture de valeurs immédiates, il peut être nécessaire de spécifier la taille de l’opération pour lever
des ambiguités
MOV byte ptr [BX], 0
MOV word ptr [BX], 0
• L’exécution d’une instruction MOV ne modifie pas les flags d’état du microprocesseur (car ce n’est pas une
opération arithmétique ou logique).
• Dest et src peuvent être:
• MOV reg_dest, reg_src
◦ Charger registre destination par contenu de registre source
◦ Les deux registres doivent être de même taille
◦ Exemple :
▪ mov AX, BX
▪ mov CL, AH
 ◦ Adressage registre

• MOV mem, regen

◦ Charger cellule mémoire du contenu d’un registre général source (écriture en mémoire)
◦ On peut désigner la cellule mémoire par :
▪ Son adresse
▪ Nom de variable associée à cette cellule mémoire
◦ L’information sera copiée en mémoire sur le nombre d’octets correspondant à la taille du registre.
◦ Exemple :
▪ mov DS:[0002], DX
▪ mov var1 AL //var1 déclarée avec DB (8 bits)
▪ mov [var1], AL
▪ mov [var2], BX
▪ mov var2, BX //var2 déclarée avec DW (16 bits)
◦ Adressage direct

• MOV regen, memcell

◦ Charger registre général du contenu d’une cellule mémoire (écriture mémoire)
◦ On peut désigner la cellule mémoire par :
▪ Son adresse
▪ Nom de variable associée à cette cellule mémoire
◦ Exemples :
▪ mov DX, DS:[0002]
▪ mov AL, var1 //var1 déclarée avec DB (8 bits)
▪ mov AL, [var1]
▪ mov BX, [var2]
▪ mov BX, var2 //var2 déclarée avec DW (16 bits)
◦ Adressage direct

• MOV memcell, immediate data

◦ Charge cellule mémoire d’une valeur immédiate (constante).
◦ On peut désigner la cellule mémoire par :
▪ Son adresse
▪ Nom de variable associée à cette cellule mémoire
◦ Valeur de la constante adéquate avec zone mémoire.
◦ Exemples :
▪ mov DS:[0002], 2
▪ mov var1, 223 //var1 déclaré avec DB
▪ mov [var1], 223
▪ mov [var2], 260
▪ mov var2, 260 //var2 déclaré avec DW

• MOV regen, immediate data

◦ Charger registre général d’une valeur immédiate (constante)
◦ Valeur de la constante adéquate avec taille du registre.
◦ Exemples :
▪ mov AL, 10011111b //8 bits , ça passe
▪ mov CX, 223 // sous 512 ça passe
▪ mov AX, data //une étiquette de segment est une constante
• MOV ax/al, mem
• MOV mem, ax/al
 • MOV segreg, val16mem
◦ Charger un registre segment d’une valeur 16 bits en mémoire
◦ CS n’est jamais utilisé comme registre de destination ici
◦ Exemples :
▪ mov ES, DS:[0004]
▪ mov ES, var1 //var1 déclarée en DW

• MOV segreg, regen16

◦ Charger un registre segment du contenu d’un registre général 16 bits
◦ CS jamais utilisé comme registre de destination
◦ Exemples :
▪ mov DS, AX
▪ mov ES, SI

• MOV val16mem, segreg

◦ Charger une cellule mémoire 16 bits du contenu d’un registre segment
◦ L'emplacement mémoire peut être désigné par son adresse ou par un nom de variable associée
◦ Exemples :
▪ mov DS:[0004], ES
▪ mov var1, ES //var1 déclaré en DW

• MOV regen16, segreg

◦ Charger registre général 16 bits du contenu d’un registre segment
◦ Exemples :
▪ mov AX, DS
▪ mov SI, ES

INSTRUCTION XCHG :

• Prend deux opérandes : XCHG opérande1, opérande 2

• Échange le contenu des deux opérandes
• Doivent être de même taille (8 ou 16 bits)
• Opérandes peuvent désigner des registres ou emplacements mémoire

INSTRUCTION LEA :

• LEA dest, source

• LEA reg16, mem
• LEA : Load Effective Address
• Charger le registre destinataire (nécessairement de 16 bits) de l’adresse effective (partie offset de l’adresse
logique) de la case mémoire spécifiée par source
• Exemples :
◦ lea SI, DS:[0006] //équivaut à mov SI, 6
◦ lea SI, var1 //var déclaré en dw
◦ lea AX, DS:1234h //AX obtient 1234h
◦ lea AX, [BX] //AX obtient l’offset actuel de BX
◦ lea BX, [BX+3] //BX chargé de l’offset actuel de BX+3
◦ lea BX, [BP+SI+4] //BX chargé des offsets actuels de BP+SI+4
INSTRUCTIONS ARITHMÉTIQUES ET LOGIQUES :

• Opérations mathématiques (addition, soustraction, multiplication, division, …) et d’opérations booléennes

(ET, OU, NOT, XOR, …) opérées sur des bits.
• Les nombres manipulés par ces opérations sont exprimés en notation complément à 2
• Peuvent changer les valeurs de certains drapeaux d’état du microprocesseur
• Résultat placé dans le premier opérande

• Quelques intructions :
◦ ADD : ajoute op2 à op1
◦ SUB : soustrait op2 de op1
◦ CMP : Idem à SUB mais pour les flags uniquement
◦ AND : compare par ET logique, tous les bits des deux ops
◦ TEST : Idem à AND mais pour les flags uniquement
◦ OR : effectue OU logique entre tous les bits des deux ops
◦ XOR : effectue OU exclusif entre tous les bits des deux ops

• Les deux ops peuvent être :

◦ REG REG
◦ REG MEM
◦ MEM REG
◦ MEM IMM
◦ REG IMM

• Registres utilisables par ces opérations :

◦ AX, BX, CX, DX
◦ AH, AL, BH, BL, CH, CL, DH, DL
◦ DI, SI, BP, SP

• Exemples :
◦ Mise à 0 du bit 3 de AX en laissant le reste intact : AND AL, F7h
◦ Mise à 1 du but 3 de AX en laissant le reste intact : OR AL, 08h

• Opérations logiques :
◦ AND/OR/XOR registre ou variable, registre
◦ AND/OR/XOR registre, registre ou variable
◦ AND/OR/XOR registre ou variable, constante
◦ AND/OR/XOR registre ou variable, nombre
◦ NOT registre ou variable
• Exemples :
◦ MOV AL, 01100001b
◦ AND AL, 11011111b ; --> donne 01000001b
◦ OR AL, 01110110b ; --> donne 01110111b
◦ NOT AL ; --> donne 10001000b
◦ XOR AL, 01010101b ; --> donne 11011101b
◦ XOR BX, BX ; --> donne 0000000000000000b
◦ XOR AL, AL ; --> donne 000000000b
OPÉRATIONS DE DÉCALAGE :

• Sur nombres signés ou non signés

• Décalage arithmétique : SAL, SAR
• Décalage normal : SHL, SHR
• CF charge le bit expulsé
• SAR garde le bit de signe MSB
• Nombre de bits de décalage indiqué dans la seconde opérande
• Plus rapides à exécuter que multiplication ou divison par 2
• Exemples :
◦ MOV AL, 11110000b
◦ SHL AL, 1 ; --> donne 11100000b
◦ SAL AL, 1 ; --> donne 11000000b
◦ SAR AL, 1 ; --> donne 11100000b
◦ SHR AL, 1 ; --> donne 01110000b

OPÉRATIONS DE ROTATION :

• Rotation normale :
◦ CF charge le bit expulsé, pas intermédiaire
◦ ROL, ROR
◦ Bits expulsés remis classiquement dans les trous formés par décalage
• Rotation CF intermédiaire :
◦ CF remplit le trou avec son contenu actuel
◦ CF chargé du bit expulsé
◦ RCL, RCR
• Nombre de bits de décalage indiqué dans la seconde opérande
• Exemples :
◦ MOV AL, 11110000b
◦ ROL AL, 1 ; --> donne 11100001b en supposant que CF=0
◦ RCL AL, 1 ; --> donne 11000010b et CF = 1
◦ RCR AL, 1 ; --> donne 11100001b et CF = 0
◦ ROR AL, 1 ; --> donne 01111000b

OPÉRATIONS ARITHMÉTIQUES :

• ADD et SUB :
◦ Pour une addition ou soustraction codées sur 16 bits ⇒ résultat codé sur 16+1 bits de résultat et bit de
retenue (bit CF)
◦ Tient pas compte de l’état initial du bit CF
◦ bit CF peut être modifié à l’issue de l’opération
◦ Addition ADD:
▪ ADD registre, registre ou variable
▪ ADD registre ou variable, registre
▪ ADD registre ou variable, constante
◦ Substracion SUB :
▪ SUB registre, registre ou variable
▪ SUB registre ou variable, registre
▪ SUB registre ou variable, constante
• ADC et SBB
◦ Permettent d’effectuer addition/soustraction sur 32 bits, 48 bits, 64 bits
◦ Tiennent compte du flag CF provenant de l’ADD/SUB précédente.
◦ Exemple ADC (ADD with Carry) :
▪ Addition de deux nombres 32 bits, on les divise en parties de 16 bits :
▪ Nombre 1 : 12345678h , 1234h (partie haute), 5678h (partie basse)
▪ Nombre 2 : 90ABCDEFh , 90ABh (partie haute), CDEFh (partie basse)

MOV AX, 5678h ; partie basse du Nombre1

ADD AX, CDEFh ; partie basse du Nombre2
MOV BX, AX ; stocker le résultat de l'addition basse dans BX

MOV AX, 1234h ; partie haute du Nombre1

ADC AX, 90ABh ; partie haute du Nombre2, en tenant compte du drapeau CF
◦ Exemple SBB (Substract with Borrow) :
▪ Soustraction de deux nombres 32 bits, on les divise en parties de 16 bits :
▪ Nombre 1 : ABCD1234h , ABCDh (partie haute), 1234h (partie basse)
▪ Nombre 2 : 56789ABCh , 5678h (partie haute), 9ABCh (partie basse)

MOV AX, 1234h ; partie basse du Nombre1

SUB AX, 9ABCh ; partie basse du Nombre2
MOV BX, AX ; stocker le résultat de la soustraction basse dans BX

MOV AX, ABCDh ; partie haute du Nombre1

SBB AX, 5678h ; partie haute du Nombre2, en tenant compte du drapeau CF

• CMP
◦ Comparer valeurs données (registres ou variables)
◦ Soustrait la source de la destination sans stocker le résultat dans destination
◦ Modifie les flags pour servir aux instructions de branchement conditionnel :
◦

• INC, DEC
◦ INC :
▪ Incrémenter registre ou variable
▪ INC AX //mnémonique codop 1 octet
▪ Équivaut à ADD AX, 1 //mnémonique codop 3 octets
◦ DEC :
▪ Décrémenter registre ou variable
▪ DEC BX // mnémonique codop 1 octet
▪ Équivaut à SUB BX, 1 //mnémonique codop 3 octets
• Multiplicatoin et division :
◦ Prennent un seul opérande (registre ou mémoire)
◦ Registres utilisables
▪ AX, BX, CX, DX
▪ AH, AL, BH, BL, CH, CL, DH, DL
▪ DI, SI, BP, SP
◦ Multiplicatoin et divison non signés : MUL et DIV
▪ MUL :
• byte : AX 16 bits = AL 8 bits * OP2 DB
◦ Exemple :
MOV AL, OP1 DB
MUL OP2 DB

• word : DX:AX 32 bits= AX 16 bits * OP2 DW

◦ Exemple :
MOV AX, OP1 DW
MUL OP2 dW

▪ DIV :
• byte : AL = AX / opérande ; AH = reste (modulo)
◦ Exemple :
MOV AX, 0006h
DIV Operand1 DB

• word : AX = DX:AX / OP : DX = reste (modulo)

◦ Exemple :
▪ MOV DX, 0000h
▪ MOV AX, 0006h
▪ DIV OP DW

◦ Multiplicatoin et divison signés : IMUL et IDIV

▪ IMUL
▪ IDIV

• INSTRUCTIONS DE BRANCHEMENT :
◦ Modifient IP en fonction du résultat d’opération, trois types :
◦ SAUTS INCONDITIONNELS :
▪ myLabel: MOV AX, 10
JMP myLabel //myLabel est une étiquette
▪ Référencement relatif :
• L’assembleur calcule automatiquement l’adresse associée à l’étiquette
• Être insensible à des rajouts de ligne de code dans le programme
 ◦ SAUTS CONDITIONNELS :
▪ Testent un ou plusieurs flags du registre d’état
▪ Si test vérifié, effectuent un branchement, sinon, exécuter prochaine instruction dans programme
▪ Principales instructions de saut conditonnel :

Instruction Alias Opposé Condition Description

JC JB, JNAE JNC Carry = 1 Branche si une retenue est présente
JNC JNB, JAE JC Carry= 0 Branche si aucune retenue n'est présente
JZ JE JNZ Zéro = 1 Branchesi le résultat est zéro
JNZ JNE JZ Zéro = 0 Branchesi le résultat n'est pas zéro
JS - JNS Signe = 1 Branche si le résultat est négatif
JNS - JS Signe = 0 Branche si le résultat est positif ou zéro
JO - JNO Overflow = 1 Branche si un dépassement de capacité s'est produit
Branche si aucun dépassement de capacité ne s'est
JNO - JO Overflow = 0
produit
JP JPE JNP, JPO Parité = 1 Branche si le nombre de bits à 1 est pair
JNP JPO JP, JPE Parité = 0 Branche si le nombre de bits à 1 est impair

▪ Instructions comparaison sur nombres signés :

Instruction Alias Opposé Condition Description

JG JNLE JNG Signe = Overflow et Zéro = 0 Branche si le résultat est supérieur
Branche si le résultat est supérieur ou
JGE JNL JL Signe = Overflow
égal
JL JNGE JGE Signe ≠ Overflow Branche si le résultat est inférieur
Branche si le résultat est inférieur ou
JLE JNG JG Signe ≠ Overflow ou Zéro = 1
égal
JE JZ JNE Zéro = 1 Branche si le résultat est égal
JNE JNZ JE Zéro = 0 Branche si le résultat est différent

◦ APPELS DE SOUS PROGRAMMES :

Variables :
- Les registres généraux (AX, BX, CX, DX) peuvent être utilisés pour stocker des variables temporaires

Tests conditionnels :

Le programme compare deux valeurs et imprime un message en fonction du résultat de la comparaison.

data segment
; Définir les messages à afficher
msg1 db "Value1 is greater than Value2", '$'
msg2 db "Value2 is greater than or equal to Value1", '$'

; Définir les valeurs à comparer

value1 dw 10
value2 dw 20
data ends

code segment
start:
mov ax, data
mov ds, ax

; Comparer value1 et value2

mov ax, value1
cmp ax, value2 ; Compare les valeurs dans AX et value2

; Si value1 > value2, sauter à print_msg1

jg print_msg1

print_msg2:
; Si on est ici, cela signifie que value1 <= value2
; Afficher le message 2
mov ah, 9
lea dx, msg2
int 21h
jmp end_program

print_msg1:
; Si on est ici, cela signifie que value1 > value2
; Afficher le message 1
mov ah, 9
lea dx, msg1
int 21h

end_program:
; Terminer le programme
mov ax, 4c00h
int 21h
code ends

end start
Boucles :
- Nombre d’itération déteministe : fixé à l’avance
- Nombre d’itératoin conditionnel : dépendant d’une expressoin booléenne

Instructions conditionnelles utilisées :

- JNE : branche si résultat différent
- JMP : branche sans condition
- JG : branche si résultat supérieur
- JE : branche si égal

WHILE : nombre d’itération conditionnel

debut_boucle :
TEST
JUMP à fin_boucle si condition fausse
;instructions
JUMP debut_boucle pour tester encore
fin_boucle :
suite programme

DO_WHILE : nombre d’itération conditionnel + exécuter au moins une fois

debut_boucle :
;instructions
TEST
JUMP debut_boucle si condition vraie
fin_boucle :
suite programme

FOR : nombre d’itérations déterministe

mov CV, val_initiale

debut_boucle :
CMP CX, val_finale
JG fin_boucle; si on dépasse l’indice finale,
;si on dépasse pas indice final, instructions
INC CX
JMP debut_boucle pour tester encore
fin_boucle :
;suite programme
SOMME N ELEMENTS DU TABLEAU TAB :

MOV AX, 0 ; Pour stocker la somme dedans

MOV CX, 1 ; quantité de contrôle de la boucle
MOV SI, 0 ; indice tableau

debut_boucle :
CMP CX, N
JG fin_boucle
ADD AX, TAB[SI]
INC SI
INC CX
JMP debut_boucle
fin_boucle :
;suite programme

RECHERCHE ELEMENT DANS TABLEAU, DÉTERMINER SA POSITION :

MOV BX, element

MOV SI, 0 ;INDICE TABLEAU

debut_boucle :
CMP SI, N-1 ;BOUCLE FOR SANS CX
JF fin_boucle
CMP BX, TAB[SI]
JE fin_boucle
INC SI
JMP debut_boucle
fin_boucle :
CMP SI, N-1 ;CHECK SI ON A PARCOURU TOUT LE TABLEAU
JG fin_si

MOV AX, SI :COPIER LA POSITION DANS L’INDEX AX

fin_si :
;suite programme
INTERRUPTION :
• Signaler événement important, interne/externe à l’UCT
• Arrêter/modifier le fonctionnement programmé de la machine
• Signaler et prendre en compte événements extérieurs (clavier, souris, disque externe,..)
• 256 interrptions possibles en 8086
• Numéro d’interruption : spécifié sur 8 bits
• Mécanisme : suspendre le programme en cours d’exécution ⇒ exécuter une routine pour gérer l’événement
(gestionnaire) avant de revenir au fonctionnement normal
• Adresse logique de routine: segment:offset

• Deux grandes classes d’interruptions :

◦ Interruptions masquables (bit IF positionné à 0)
◦ Interruptions non masquables, dont l’occurence ne peut être cachée

• Indicateur d’interruption (IF) peut être positionné par ces deux instructions :
◦ L’instruction STI (set interrupt) qui positionne l’indicateur IF à 1 pour autoriser la prise en compte des
interrputions masquables
◦ L’instruction CLI (clear interrupt) qui met l’indicateur IF à 0 pour masquer les interruptions

• 2 sources de déclenchement d’interrpution :

◦ Interruption matérielle : sollicitation par matériel pour effectuer traitement (lecture clavier)
◦ Interruption logicielle : sollociation par le programme en cours d’exécution à l’aide d’instruction
particulière (ouverture fichier, envoi de sortie à l’écran)

• Instructions INTERNES non masquables :

◦ Interruption due à la division par zéro (Lors de DIV ou IDIV)
◦ Interruption n°4 : généré par l’appel à l’instruction INTO (interruption déclenchée si OF=1)
• Instructions INTERNES MASQUABLES :
◦ Interruption de trap (TF:trap flag), ou « pas à pas » permettant de déboguer.
• Interruption EXTERNE à l’UCT :
◦ Proviennent de périphériques matériel (de type matériel)

• Hiérarchie des interruptions :

•

• PIC (Programmable Interrupt Controller) :

◦ Dispositif matériel qui gère les interruptions matérielles,
◦ agit comme un pont entre périphériques matériels et le CPU
 ◦ Extension d’entrées IRQ :
▪ un PIC individuel dispose de 8 entrées IRQ
▪ Associer deux contrôleurs PIC : placer PIC2 (esclave) à l’entrée IRQ2 du PIC1 (maître).

• IRQ (Interrupt Request) :

◦ signal envoyé par périphérique matériel
◦ pour signaler qu’il a besoin de l’attention du CPU
◦ chaque IRQ est
▪ attribué à un périphérique particulier
▪ associé à une interruption spécifique
◦ Numérotation des IRQ :
▪ Chaque IRQ a un numéro propre au port auquel le matériel est connecté
▪ Numéro utilisé pour déterminer quelle routine d’interruption à exécuter si IRQ déclenché
• Sauvegarde des registres :
◦ Effectuée par PIC si interruption matétielle
◦ Mécanisme appelé « transparence des interruptions »
◦ Pour ensuite exécuter la routine

• 3 Lignes d’entrée au CPU pour les interruptions matérielles :

◦ Ligne RESET :
▪ Lorsque l'ordinateur démarre, cette ligne est activée,
▪ Réinitialise tous les registres du CPU à leur valeur par défaut (0000h), sauf CS=FFFFh.
◦ Ligne INTR :
▪ Ligne principale pour interruptions masquables
▪ Activée par PIC quand matériel demande interruption
▪ PIC peut masquer certaines interruptions (ignorer les demandes)
◦ Ligne NMI (Non masquable interrupt) : pour situation d’urgence

• Gestion des interruptions par PIC :

◦ PIC gère plusieurs demandes d’interruption et déterminer la priorité
◦ Demande d’IT arrive, PIC envoie signal au CPU sur ligne INTR
◦ Si CPU prêt à accepter l’IT (si IF=1), envoie signal de reconnaissance sur ligne INTA
◦ PIC envoie numéro IRQ (0 à 7) au CPU sur bus de données (numéro correspond à IT spécifique)
◦ CPU exécute routine d’IT correspondante
◦ CPU signale terminaison routine IT au PIC
◦ PIC passe à la prochaine IT en attente.

• BIOS :
◦ Ensemble de programmes stockés dans une puce de mémoire ROM de la carte mère.
◦ Programmes essentiels pour :
▪ Démarrage de l’ordinateur
▪ Communication entre CPU et périphériques matériels
 ◦ Interruptions logicielles du BIOS :
▪ Portes d’entrée vers fonctions du BIOS
▪ Chaque INT ⇒ associée à certaines fonctions (les sélectionner via AH)
◦ Fonctions du BIOS et registres CPU :
▪ Passage des paramètres des fonctions via registres CPU
▪ Renvoi du résultat via regisres CPU aussi
◦ Appel d’une fonction du BIOS : 3 étapes :
▪ 1- Initialiser registres CPU avec paramètres de fonction
▪ 2- Appel d’INT associée
▪ 3- Registres CPU reçoivent résultat de fonction

◦ Fonctions BIOS : Pour interaction entre l’OS et le matériel

◦ Groupes de fonctions BIOS : organisées en 4 principales INT, chacune représente un groupe de

fonctions qui gèrent un aspect spécifique du materiel
▪ 0x10 : Cette INT gère les fonctions d’affichage vidéo
▪ 0x13 : gère l'accès aux périphériques de stockage de masse
▪ 0x15 : gère les fonctions de la mémoire.
▪ 0x16 : gère les fonctions du clavier.

◦ Fonctions BIOS non génériques : pas universelles ou standardisées, varient en fonction du fabriquant.

◦ Exemples fonctions BIOS usuelles :

▪ Fonctions d'affichage (0x10) :
• AH = 1 : réglage du curseur //définir la forme (taille, rendre invisible) du curseur
• AH = 3 : définition de la position du curseur //déplacer le curseur sur l’écran, fournir
coordonnées
• AH = 0xE : affichage d'un caractère //à la position actuelle du curseur
• AH = 0x13 : affichage d'une chaîne de caractères //à la position actuelle du curseur
• Fonctions de saisie au clavier (0x16) :
• AH = 0 : lecture d'un caractère (fonction bloquante, attend un caractère) //arrête l’exécution du
programme jusqu’à lecture de caractère
• AH = 1 : lecture d'un caractère (fonction non bloquante, ne attend pas un caractère) //ne bloque
pas l’exécution du programme
• Fonctions du DOS : toutes accessibles via l’INT 21h
• 01h : Entrée d’un caractère avec sortie
• Lire caractère de l’entrée standard (clavier)
• Stocker caractère dans AL
• L’afficher à la sortie standard (écran)
• Attend jusqu’à lecture
MOV AH, 01h
INT 21h
• 07h : Entrée d’un caractère sans affichage à l'écran
• Similaire à 01h mais ne l’affiche pas à l’écran
• Stocker caractère dans AL
MOV AH, 07h
INT 21h
• 02h : Sortie d’un caractère
• Affiche caractère dans l’écran
• Mettre code du caractère ASCII dans DL
• MOV AH, 02h
MOV DL, 'A' ;Par exemple, pour afficher le caractère 'A'
INT 21h
• 09h : Sortie d’une chaîne de caractères
• Affiche chaine de caractères dans l’écran
• Chaîne nécessairement stockée en mémoire terminée par ‘$’
• Mettre l’adresse de la chaine dans DX via LEA
• MOV AH, 09h
LEA DX, STRING ; Ici, STRING est l'adresse de la chaîne de caractères en mémoire
INT 21h
• 0Ah : Entrée d’une chaîne de caractères
• à partir de l’entrée standard (clavier)
• Stocke la chaine dans un tampon (buffer)
• Entrée se termine quand touche Entrée (CR retour chariot de code 13d ou 0Dh) tapée
• Code de retour chariot 0Dh placé aussi dans buffer
• Mettre adresse tampon (buffer) dans DX
• Les 3 octets du tampon :
• 1er octet : nombre maximal de caractères attendu (y compris CR final)
• 2ème octet : nombre de caractères effectivement reçus (sans CR final)
• 3ème octet : les caractères s’inscrivent ici
• BUFFER DB 10, ?, 10 DUP(0) ;Préparation du tampon. Il peut contenir jusqu'à 10 caractères.
MOV AH, 0Ah
LEA DX, BUFFER ; BUFFER est l'adresse du tampon en mémoire
INT 21h
 • 4Ch : termine le programme en cours d’exécution
• MOV AH, 4Ch
MOV AL, 00h
INT 21h

• Numéro de vecteur d’interruption :

• Sert d’indice dans la table des vecteurs d’INT pour trouver @ routine
• La table des vecteurs INT se trouve à l’adresse 0000:0000 en mémoire
• Chaque vecteur (4 octets consécutifs), stocke l’@ de la routine d’INT à executer
• @ de routine : offset ensuite segment (little endian)
• 256 @s de routine, car 1024 octets (adresses mémoire) / 4 octets par @ routine

• Déroulement appel à une interruption :

• Sauvegarde de l’adresse de retour :
• Adresse de retour : celle de la prochaine instruction que CPU aurait executé
• Empiler (stocker dans pile), l’état actuel de :
• Registres d’état FLAGS (infos sur état actuel du CPU)
• Registre de segment CS (forme avec IP adresse retour)
• Compteur ordinal IP (forme avec CS adresse retour)
• Appel du vecteur d’INT n :
• Chaque entrée est de 4 octets, 2 pour segment, 2 pour offset
• CPU multiplie n°INT par 4 pour obtenir index d’entrée en table
• Exemple : n°INT : 9h
CPU regarde sur l’entrée 0000:0024 (9*4=36d=24h)
L’entrée 0000:0024 contient @routine d’INT demandée
CPU charge l’offset de @routine 0000:4*n dans IP
CPU charge le segment de @routine 0000:4*n+2 dans CS (+2 pour pointer à la partie
segment de @routine).
• Mise de IF=0 et TF=0 pour éviter autre interruption durant traitement
• CS:IP une fois chargé de @routine, CPU exécute la routine d’INT
• Exécution de la routine d’INT :
• Routine d’INT est un petit programme correspondant à l’INT
 • Exemple pour une interruption de clavier, lire la touche qui a été pressée et la mettre dans un
tampon.
• Conclure par exécuter IRET (Interruption RETurn)
• Retour d’INT (Instruction IRET) :
• Exécutée par la routine d’INT après avoir terminé son travail
• IRET indique au CPU de dépiler (récupérer depuis la pile) les valeurs IP, CS et FLAGS

• Gestionnaire par défaut : dans la table de vecteur d’INT :

• 32 premières entrées :
• Réservées pour les INTs générées par le matériel
• Gérés par BIOS
• Ex : pression sur touche clavier
• 32 entrées suivantes :
• Réservées pour interruptions logicielles
• Gérées par l’OS (DOS dans ce cas)
• Ex : erreur de division par 0
• 32 entrées suivantes :
• Utilisées par les programmes utilisateur
• Appeler INT manuellement dans un programme, via instruction INT suivie de n°INT
• Architecture d’une routine de traitement :
• L’instruction CLI désactive les interruptions IF=0 et TF=0 (éviter d’autres INTs)
• Sauvegarder état des registres
• Effectuer traitement nécessaire pour interruption
• Restaurer état des registres
 • L’instruction STI réactive les interruptions IF=1 et TF=1
• Exécuter IRET pour reprendre l’adresse retour
• Modification de la routine : modifier la table des vecteurs d’INT pour pointer vers sa propre routine
d’INT :
• Étape 1 :
• Sauvegarder l’@ de routine d’INT d’origine (pour la restaurer après)
• Fonction 35h : obtenir @routine d’origine
• MOV AL, [numéro de l'interruption]
MOV AH, 35h
INT 21h
• ES et BX contiendront @routine d’INT d’origine
• Étape 2 :
• Définir nouvelle @routine d’INT
• Fonction 25h : définir nouvelle adresse
• MOV DX, 5678h ;offset nouvelle routine
MOV DS, 1234h ;segment nouvelle routine

MOV AL, [numéro de l'interruption]

MOV AH, 25h
INT 21h
• En amont charger partie segment dans DS et partie offset dans DX.