8086 Courspdf 2024

Microprocesseur
8086
Troisième partie
Dr. ZAHRAOUI
Contact: emsi.zahraoui@gmail.com
ÉVOLUTION DES PROCESSEURS INTEL
Processeurs multi-cœurs:
Core 2, i5, i7, .....

Pentium: I, II, III,
IV, V, ... 2006
Processeurs 80x : 8080, jusqu’à
1993-2005 aujourd’hui
8086, 8080, 80286, 80386,
80486, ......
1972 – 1992
Premier processeur
1971
4004
La majorité des microprocesseurs
4
Intel sont compatibles avec le 8086
ARCHITECTURE GÉNÉRALE DU 8086
INTRODUCTION
 Disponible depuis 1978, le processeur 8086 fut le premier
processeur 16 bits fabriqué par Intel.
 Il se présente sous forme d'un boîtier de 40 broches

alimenté par une alimentation unique de 5V.
AH AL Bus d’adresse Interne 20 bits
BH BL Calcul 20 bits
CX CH CL d’adresse Bus d’adresse
DX DH DL Interface
16 bits
BP CS IP avec Bus Bus de contrôle
SP DS
externes
SI SS 16 bits
DI ES Bus de données
Bus de données Interne 16 bits
RT RT
Codage
Contrôle
Séquencement
UAL File d’attente 6
octets de codes
instructions 7
4
Flags Architecture Générale du processeur 8086
Tous les registres du 8086 sont structurés en 16 bits.

V- Architecture interne du 8086
Bloc de commandes de l’unité d’exécution

Permet de générer les signaux de commandes
nécessaires au fonctionnement et à la synchronisation
des différents éléments du microprocesseur.
Bloc UAL (Unité Arithmétique-Logique)

Une partie de la machine chargée d'effectuer les calculs.
N
Largeur du bus
Unidirectionnel
Bidirectionnel
VI- Gestion de la mémoire

Segmentation de la mémoire:
 Bus d’adresse est de 20 bits ---> Mémoire totale adressable égale 220 octets = 1 Mo
 Taille des registres est de 16 bits ---> seuls 216 octets = 64 Ko peuvent être adressés
 La mémoire est donc divisée en pages de 64 Ko appelées segments
 Deux registres sont alors nécessaires pour adresser un emplacement mémoire:
• Registre pour adresser le segment (registre de segment) : CS, DS, SS, ES
• Registre pour adresser l'intérieur du segment (registre offset) : IP, SP, BP, SI, DI et BX
 Une adresse se présente sous la forme segment : offset

• Le segment localise le début d’une zone mémoire de 64 Ko
• L’offset précise l’adresse relative par rapport au début de segment.


REGISTRES
 Tous les registres du 8086 sont structurés en 16 bits.

REGISTRES DE SEGMENT
Registres Usage
CS : Code Définit le début de la mémoire programme dans laquelle sont
Segment
stockées les instructions du programme.
Les adresses des différentes instructions du programme sont
relatives à CS
DS : Data Définit le début de la mémoire de données dans laquelle sont

Segment stockées toutes les données traitées par le programme.
SS : Stack  Définit le début de la pile.

Segment  SP permet de gérer l’empilement et le dépilement.
ES : Extra  Définit le début d'un segment auxiliaire pour données

Segment 10
 Ces registres sont combinés avec les registres offset (par exemple IP) pour
former les adresses. Une case mémoire est repérée par une adresse de la
forme [Rseg :Roff]
 Le registre segment localise le début d’une zone mémoire de 64Ko

 Le registre offset précise l’adresse relative par rapport au début de
segment.
86
REGISTRES GÉNÉRAUX
Registres Usage
SP : Pointeur  Utilisé pour l'accès à la pile. Pointe sur la tête de

de Pile la pile
BP : Pointeur  Usage général

de Base  Adressage comme registre de base
SI : Registre Usage général

Adressage comme registre d’index de l'opérande
d'index (source)
source.
DI : Registre  Usage général

d'index Adressage comme registre d’index de l'opérande
12
(destination) destination
forme [Rseg :Roff]

segment.
SEGMENTATION DE LA MEMOIRE
SEGMENTATION DE LA MEMOIRE
Exemple
• Adresse logique CS: IP A000:5F00
• Adresse physique:

Exercice 1 : Trouver l’adresse logique, si:

• Adresse segment: CS=1005H
• Adresse de décalage (offset): IP=5555H
Segment : Offset
----------->
----------->
1005H : 5555H

Exercice 2: Calculer l’adresse physique, si:

• Adresse segment: CS=1005H
• Adresse de décalage (offset): IP=5555H
Adresse segment: 1005H -------> 0001 0000 0000 0101

Décalage à gauche de 4 positions ------> 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0
Adresse offset: 5555H

+
------>
16 bits
0101 0101 0101 0101
16 bits
Adresse physique: 155A5H <-----
= 0001 0101 0101 1010 0101
20 bits
Adresse Physique = Adresse de segment * 10H + Offset (adresse de décalage)


Exercice 3: Trouver l’adresse logique. Puis, calculer l’adresse physique, pour le cas:
• Adresse segment: CS=A000H
• Adresse offset : IP=5F00H
Adresse logique:
A000H : 5F00H
Adresse physique:
Adresse segment: (A000)H -----------> 1010 0000 0000 0000
Décalage à gauche de 4 positions : ------> 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

+
Adresse offset: (5F00)H -----------> 0101 1111 0000 0000
Adresse physique: (A5F00)H <------- 1 0 1 0 0 1 0 1 1 1 1 1 0 0 0 0 0 0 0 0
La limite inférieure de CS : CS*10H+ 0000H

La limite supérieure de CS : CS*10H+ FFFFH

Exercice 3: Trouver l’adresse logique. Puis, calculer l’adresse physique, pour le cas:
• Adresse segment: CS=A000H
• Adresse offset : IP=5F00H
Adresse logique:
A000H : 5F00H
Adresse physique:
Adresse segment: (A000)H -----------> 1010 0000 0000 0000
Décalage à gauche de 4 positions : ------> 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

+
Adresse offset: (5F00)H -----------> 0101 1111 0000 0000
Adresse physique: (A5F00)H <------- 1 0 1 0 0 1 0 1 1 1 1 1 0 0 0 0 0 0 0 0
La limite inférieure de CS : CS*10H+ 0000H

La limite supérieure de CS : CS*10H+ FFFFH
Préparation contrôle
CS = 0700h DS = 1000h
• Org 100h
Etat de la mémoire avant
• mov AH, 82h
exécution d programme
• mov CX, 45F2h
• mov [A011h], B2h RAM
• mov BX, 45E7h 11h A013h
• mov [BX], B211 h E9h A012h
• ADD [A011h], CX [] 6Ah A011h
• ADD AH,97h
• RET 89h A010h
43h A00Fh
• A-Expliquer ce que fait chaque instruction.
• B-Donner l’adresse logique et l’adresse physique de BX
• C-Donner à chaque fois le positionnement du registre FLAG après exécution des
instructions ADD
• D-Quel est l’adresse de la première instruction de ce programme? Donner l’adresse
logique et l’adresse physique de cette instruction.
• E-Suivant les représentations SVA, CA1 et CA2, quel est en décimal, l'entier signé codé
sur 8 bits représenté par 97h
• Exercice 1:
• Si CS=3499h et IP=2FACh , trouver:
• a- les limites du code segment CS (@ physique)
• b- l’adresse logique du registre IP
• c- l’adresse physique du registre IP
• (ensuite DS= 1296h et BX= AB49h) refaire le même
exercice
• Exercice 2:
• A-Une instruction à rechercher est dans l’adresse physique 519B2h et
CS=D140h,
• Est-ce que la bande du code segment l’inclut ou pas?
• Si c’est non, quelle valeur à donner à CS si IP=AC82h?
• B-Une instruction à rechercher est dans l’adresse physique 389F2h et
CS=2700H,
• Est-ce que la bande du code segment l’inclut ou pas?
• Si c’est non, quelle valeur à donner à CS si IP=1282h?
Solution Exercice 1
• Exercice 1:
• Si CS=3499H et IP=2500H , trouver:
• a- les limites du code segment CS
• (ensuite CS= 1296H et IP= 100H) refaire le même
exercice
• a- les limites du code segment CS
• Limite inférieur CS* 10h= 34990H
• Limite supérieur CS* 10h+FFFFh= 34990H+FFFFh=4498Fh
• CS:IP = 3499h: 2500h
• CS* 10h+IP = 34990H+2500h=36E90h
Exercice 3:
Une instruction à rechercher est dans l’adresse physique 389F2H

et CS=2700H,
•Est-ce que la bande du code segment l’inclut ou pas?
•Si c’est non, quelle valeur à donner à CS si
IP=1282H?
Solution Exercice 3

Solution de l’ exercice 5:
 Est-ce que la bande du code segment l’inclut ou pas?

Le segment code est compris entre les adresses :
Limite inférieure : 27000H 2700H:FFFFH
36FFFH
Limite supérieure : 36FFFH CS=2700H
27000H
2700H:0000H
Le segment CS n’inclut pas 389F2H puisque 389F2H>36FFFH
 Si c’est non, quelle valeur à donner à CS si IP=1282H?
CS*10H+1282H=389F2H CS=(389F2H- 1282H)/10H=3777H

REGISTRES
 Tous les registres du 8086 sont structurés en 16 bits.

Registres Usage
AX:  Usage général,
Accumulateur  Obligatoire pour la multiplication et la division,
 Ne peut pas servir pour l'adressage
BX : Base  Usage général,

 Adressage
CX :  Usage général,
Comptage et Compteur de répétition.
calcul  Ne peut pas servir pour l'adressage
DX : Data  Usage général,

 Extension au registre AX pour contenir un nombre
32 bits Dans la multiplication et la division 16 bits 20
Ne peut pas servir pour l'adressage
REGISTRES GÉNÉRAUX
Registres Usage
SP : Pointeur  Utilisé pour l'accès à la pile. Pointe sur la tête de

de Pile la pile
BP : Pointeur  Usage général

de Base  Adressage comme registre de base
SI : Registre Usage général

Adressage comme registre d’index de l'opérande
d'index (source)
source.
DI : Registre  Usage général

d'index Adressage comme registre d’index de l'opérande
21
(destination) destination
forme [Rseg :Roff]

segment.
Registres Usage
CS : Code Définit le début de la mémoire programme dans laquelle sont
Segment
stockées les instructions du programme.
Les adresses des différentes instructions du programme sont
relatives à CS
DS : Data Définit le début de la mémoire de données dans laquelle sont

Segment stockées toutes les données traitées par le programme.
SS : Stack  Définit le début de la pile.

Segment  SP permet de gérer l’empilement et le dépilement.
ES : Extra  Définit le début d'un segment auxiliaire pour données

23
Segment
REGISTRE D'ÉTAT (FLAGS)
15 0
O D I T S Z AA P C
o C (Carry) : indique qu’il y a une retenue globale du résultat à
o 8 bits ou 16 bits.
o P (Parité) : indique que le nombre de ‘1’ dans le résultat est un

nombre pair.
o Z (Zéro) : à ‘1’ indique que le résultat est nul.
o S (Signe) : indique le signe du résultat
o O (Overflow): indique un dépassement de capacité. à ‘1 en cas

d’addition si et seulement si:
°la somme de deux nombres positifs est négative
°la somme de deux nombres négatifs est positive
o A(Auxiliary): indique la retenue auxiliaire

• L’instruction ADD permet de positionner les flags CZSOPA à ‘1’ ou à ‘0’ selon le
résultat de l’opération:
a. Après avoir exécuté le programme suivant, quelles sont les valeurs que
prennent ces flags? Faire un calcul manuel pour justifier la réponse.
Org 100H Org 100H

MOV BL, 75 MOV AL, D8h
MOV BH, 67 MOV AH, CAh C 1
ADD BH, BL ADD AH, AL Z 1
ret ret S 0
O 0
b. Proposer un programme pour positionner les flags comme indiqué: P 1
A 1
JEU D’INSTRUCTIONS
Exercices:
1.
org 100h org 100h
mov al, 0D8h mov bl, 75 ; décimal
mov ah, 0CAh mov bh, 67; décimal
add ah,al add bh, bl
ret ret
Exercices:
2.
C 1
Z 1
S 0
O 0
P 1
A 1
VII- Format d’une instruction

Un microprocesseur exécute un programme. Le programme est une suite d’instructions
stockées dans la mémoire. Une instruction peut être codée sur un ou plusieurs octets.
 La structure la plus générale d’une instruction est la suivante :
L’opération est réalisée entre les 2 opérandes et le résultat est toujours récupéré dans l’opérande de gauche.
Exemples : CMP, ADD, MOV, XCHG, AND …
 Il y a des instructions qui agissent sur un seul opérande:
Exemples : INC, DEC, NEG, NOT …
 Il y a aussi des instructions sans opérande
Exemples : NOP, STI, CLI, CBW …
Les opérandes peuvent être des registres, des constantes ou le contenu de cases mémoire.
VIII- Modes d'adressage du 8086

Il existe différentes façons de spécifier l’adresse d’une case mémoire dans une instruction : ce
sont les modes d’adressage. Il y a plusieurs modes d’adressage dans le 8086:
1. Adressage registre
2. Adressage immédiat
3. Adressage direct
4. Adressage indirect
a. Adressage basé
b. Adressage indexé
c. Adressage basé-indexé
1- Adressage registre
Ce mode d'adressage concerne tout transfert ou toute opération, entre deux

registres de même taille. Dans ce mode, le μP effectue toutes les opérations d'une
façon interne et l'opérande sera stockée dans un registre interne (sauf IP).
L'opération se fait sur un ou deux registres:

INST R1 , R2
INST R
Exemples :
INC AX : incrémenter le registre AX
MOV AX, BX : Copier le contenu de BX dans AX (AXBX); opérandes 16 bit
ADD CH, DL : Ajouter le contenu de DL au CH (CHDL+CH) ; opérandes 8 bits
ADD BX, AL : Déclaration d’erreur car BX est de 16 bits et AL est de 8 bits.
2- Adressage immédiat
Ce mode d’adressage est un mode de manipulation des valeurs latéraux avec un

registre interne.
L'opérande est une constante (valeur) qui fait partie de l’instruction:

INST R , VN
Exemples :
MOV AX, 243 : Charger AX par le nombre décimal 243 (AX243)
MOV AL, ‘A‘ : Charger AL par le code ASCII du caractère ‘A' (65)
MOV AX,‘AB' : Charger AH par le ASCII du caractère ‘A' (65) et AL par le ASCII du ‘B‘ (66)
MOV AX, A1EBH
A1EBh :: Charger le registre AX par la valeur hexadécimal A1EB
MOV AL, 102h
102H: : Déclaration d’une erreur, AL est de 8 bits et la valeur 102h est de taille de 12
bits.
MOV AX, 40H
40h :: Cette instruction est juste, car on peut écrire 40h  0040h valeur sur 16 bits.
3- Adressage direct
Un des deux opérandes se trouve en mémoire. L’adresse de la case mémoire est
précisé directement dans l’instruction.
INST R , [@]
INST [@] , R
INST taille [@] , VN
• L’adresse doit être placée dans [Rseg : Roffset].
• Si le segment (Rseg) n’est pas précisé, le registre DS est pris par défaut comme Rseg.
Exemples : :
Exemples
MOV AX, AX,
MOV [1234]
[1234]
; : Copier le contenu de la mémoire d'adresse DS:1234 dans AX
MOV [0200h]
MOV , AX, ;AX : Copier le contenu de AX dans la mémoire d'adresse DS:0200
[0200h]
MOV AX ,AX
MOV SS:243
, SS:243
; : Copier le contenu de la mémoire SS:243 dans AX
MOV BYTE
MOV BYTEptr [1213]
[1213] ,, 4Ah,
4Ah ; Copier la valeur 4A dans la case mémoire DS:1213
MOV WORD
MOV WORD ptr [1213]
[1213] ,, 4Ah
4Ah ;; 4A → adresse DS:1213, et 00 → adresse+1 (c-à-d
DS:1214)
4- Adressage indirect
Un des deux opérandes se trouve en mémoire. L’adresse se trouve dans l’un de

ces 4 registres BX, BP, SI ou DI.
INST R , [Rseg : Roffset]
INST [Rseg : Roffset] , R
INST taille [Rseg : Roffset] , VN
Si Rseg n'est pas spécifié, le segment Roffset BX BP SI DI

par défaut sera utilisé comme suit:
Rseg par défaut DS SS DS DS
Exemples :
MOV AX, [BX] ;: Transfert de contenu de la case mémoire 16 bits pointer par BX,
par rapport au DATA segment vers AX.
ADD [SI], DL ;: Ajouter le contenu de DL au contenu de la case mémoire 8 bits
pointer par DS:SI et stocker le résultats dans Op Déstination.
L’adressage indirect est divisé en 3 catégories selon le registre d’offset utilisé:

a. Adressage Basé
b. Adressage indexé
c. Adressage basé indexé
Mode Adressage Basé Indexé Basé Indexé

Registres utilisés BX DI BX, DI
BP SI BX, SI
BP, DI
BP, SI
a. Adressage Basé
L’offset se trouve dans l’un des deux registres de base BX ou BP. On peut préciser
un déplacement (Dep) optionnel qui sera ajouté au contenu de Rbase pour déterminer
l’offset:
INST R , [Rbase+Dep]
INST [Rbase+Dep] , R
INST taille [Rbase+Dep] , VN
Exemples :
MOV [BX+12], AL ; Transfert de contenu de AL vers la case mémoire pointer par
(BX+12) par rapport au DATA segment (DS:BX+12).
MOV SI, [BP+400] ; Charger SI par le contenu de la mémoire d'adresse SS:BP+400
MOV AX, [ES:BP] ; Charger AX par le contenu de la mémoire d'adresse ES:BP
VII- Modes d'adressage du 8086
a. Adressage Basé
Exemple d’application : Ecrire un programme assembleur du 8086 permettant d’ajouter la
même valeur 5h à 10 cases mémoires successives: DS:0100; DS:0101; DS:0102; DS:0103;
DS:0104; …. ; DS:0109
MOV CX, 0A ; CX  la valeur numérique 1010 = 0A16

MOV BX, 0100 ; BX  la valeur numérique 010016
etiq MOV AL, [BX] ; AL  le contenu de la case mémoire d’adresse DS:BX
ADD AL, 05 ; AL  AL +0516
MOV [BX], AL ; [DX:BX]  AL
INC BX ; BX  BX+1
LOOP etiq
b. Adressage Indexé
L’offset se trouve dans l’un des deux registres d’index SI ou DI. On peut préciser
un déplacement (Dep) optionnel qui sera ajouté au contenu de Rindex pour déterminer
l’offset:
INST R , [Rindex+Dep]
INST [Rindex+Dep] , R
INST taille [Rindex+Dep] , VN
Exemples :
MOV AX, [SI] ;: Charger AX par le contenu de la mémoire d'adresse DS:SI
MOV AX, [SI+200] ;: Charger AX par le contenu de la mémoire d'adresse DS:SI+200
MOV AX, [DI-10] ;: Charger AX par le contenu de la mémoire d'adresse DS:DI-10
MOV AX, [ES:SI+4] ;: Charger AX par le contenu de la mémoire d'adresse ES:SI+4
c. Adressage Basé-Indexé
L'offset de l’adresse de l'opérande est la somme d’un registre de base (Rbase),

d'un registre d'index (Rindex) et d'un déplacement (Dep) optionnel. Si Rseg n'est pas
spécifié, le segment par défaut du registre de base est utilisé :
INST R , [Rbase+Rindex+Dep]
INST [Rbase+Rindex+Dep] , R
INST taille [Rbase+Rindex+Dep] , VN
Exemples :
MOV AX, [BX+DI+5] ;: AX est chargé par la mémoire d'adresse DS:BX+DI+5
MOV AX, [BX+SI] ;: AX est chargé par la mémoire d'adresse DS:BX+SI
MOV AX, [SS:BP+SI+2] ;: AX est chargé par la mémoire d'adresse SS:BP+SI+2
MOV AX, [SS:BP+DI] ;: AX est chargé par la mémoire d'adresse SS:BP+DI
Exercice II: Identifier le mode d’adressage pour chacune des lignes suivantes:
N° de ligne
1. MOV AL, [000BH] ; 1. Adressage direct

2. ADD AL, C4H ; 2. Adressage immédiat
3. MOV [BX], 00H ; 3. Adressage indirect basé
4. SUB AL, [BX+SI] ; 4. Adressage indirect basé-indexé
5. MOV AX, [BX+DI+5] ; 5. Adressage indirect basé-indexé + déplacement
6. MOV AX, ‘AB’ ; 6. Adressage immédiat
7. ADD CH, DL ; 7. Adressage registre
8. MOV AX, [SI]; 8. Adressage indirect indexé
9. MOV AX, 5; 9. Adressage immédiat
10. MOV AX, BX; 10. Adressage registre
11. MOV AX, [BX]; 11. Adressage indirect basé
12. MOV AX, [BX+5]; 12. Adressage indirect basé + déplacement
13. MOV AX, [SI+5]; 13. Adressage indirect indexé + déplacement
14. MOV AX, [BX+SI]; 14. Adressage indirect basé-indexé
15. MOV AX, [BX+DI]; 15. Adressage indirect basé-indexé
16. MOV AX, [BX][DI]5; 16. Adressage indirect basé-indexé + déplacement
17. MOV AX, [BX+SI+5]; 17. Adressage indirect basé-indexé + déplacement
Pour chacune des lignes de la routine assembleur, identifiez les modes d’adressage
utilisés :
a. Adressage Immédiat
b. Adressage Registre N° de ligne
1 mov si, [SP+4]
c. Adressage direct 2 mov AX, 0
d. Adressage indirect 3 cmp [SI+BX], al
e. Adressage indirect basé 4 jmp etiq3
f. Adressage indirect indexé 5 inc AX
6 etiq3: ret
7 add DL,[FAh]
IX- Taille des échanges avec la mémoire

 La mémoire est organisée en octets.
 Lorsqu'une instruction est effectuée entre un registre et des données en mémoire,
le registre détermine la taille de l'opération :
 Si le registre est sur un octet, l'opération sera effectuée avec MOV [@], AL @ AL
une cellule de mémoire.
 Si le registre est sur un mot, l'opération sera effectuée avec AL

MOV [@], AX @
deux cellules de mémoire. @+1 AH
 Lorsqu'on effectue une opération entre une constante et une cellule de mémoire, il faut
utiliser les préfixes BYTE (octet) et WORD (mot) pour spécifier le nombre d'octets à écrire :
MOV BYTE ptr [@], 4Ah @ 4A MOV WORD ptr [@], 4Ah @ 4A
@+1 00
Donner l’état des cases mémoires d’adresse: 400h, 401h, 402h et 403h
avant et après l’éxecution des instructions INC.
Donner l’état du registre Flag après chacune des deux instructions INC
CZSOPA
org 100h
mov [400h],0xFFh ;Mov word ptr [400h], 33FFh
mov [401h],33h
mov [402h], 0xFFh
mov [403h], 33
INC BYTE ptr [400h]
INC WORD ptr [402h]
ret
Exemple 1:
 Soit: SI = 24ABh; DI = C140h; DS = A1BAh
MOV [SI+1000h], 142Bh
 L'adresse effective : 24ABh + 1000h = 34ABh

 L'adresse physique : 34ABh + A1BA0h = A504Bh
 Soit le programme suivant :
MOV AX, A1BAh

MOV DS, AX
MOV DI, C140h
MOV AX, 1412h
MOV [DI], AX
Dans la dernière instruction où l'adressage indirect indexé est employé :

 L'adresse effective : C140h
 L'adresse physique : A1BA0h + C140h = ADCE0h
Exemples:
 Soit: SS = 1240h ; BP = 42A8h ; SI = 4010h
MOV [BP+SI], 12h
 Autre écriture : MOV [BP][SI],12h

 L'adresse effective : BP + SI = 82B8h
 L'adresse physique : 10h × SS + 82B8h = 1A6B8h
 L'octet d'adresse 1A6B8h sera chargé par la valeur 12h.
 Indiquer le mode d’adressage pour chacune des instructions suivantes :
• MOV AX, BX
• MOV CX, 1234H
• MOV [1000H], CX
• MOV AL, [BX]
• MOV AH, [BX+SI]
PLAN
I. Introduction
II. Architecture Générale du 8086
III. Jeu d’Instructions
IV. Programmation en Assembleur 8086
V. Code Machine des Instructions

I- Introduction
Chaque microprocesseur reconnait un ensemble d’instructions appelé jeu
d’instructions fixé par le constructeur.
Une instruction est définie par son code opératoire (opcode). On utilise donc une
notation symbolique pour représenter les instructions (mnémoniques). Un programme
constitué de mnémoniques est appelé programme en assembleur.
Les instructions peuvent être classées en groupes :
 Instructions de transfert de données (MOV, XCHG, ...) ;
 Instructions arithmétiques (ADD, SUB, MUL, DIV, ...) ;
 Instructions logiques (NOT, AND, OR, XOR, ...) ;
 Instructions de décalage et de rotation (SHR, SHL, ROL, ROR, ...);
 Instructions de branchement (JMP, Jxx, LOOP, ...) ...

II- Les instructions de transfert
Elles permettent de déplacer des données d’une source vers une destination.
MOV
MOV Od, Os : Copie l'opérande Source (Os) dans l'opérande Destination (Od)
[Od  Os]
MOV R1 , R2 R1R2
MOV R , [adr] R [adr]
MOV [adr] , R [adr] R
MOV R , im Rim
MOV taille [adr] , im copier une constante dans une case mémoire
taille = BYTE ou WORD
MOV [adr], [adr]

MOV Rseg, Rseg
II- Les instructions de transfert
Elles permettent de déplacer des données d’une source vers une destination.
XCHG
XCHG Od, Os : Échange de l'opérande Source (Os) avec l'opérande Destination (Od)
[Od Os]
XCHG R1 , R2 R1 R2
XCHG R , [adr]
R [adr]
XCHG [adr] , R
XCHG [adr], [adr]

Exercices:
1. Ecrire un code permettant de: org 100h

mov ax, 10FAh
• Mettre dans AX la valeur 10FAH
mov bx, 2234h
• Mettre dans BX la valeur 2234H xchg ax,bx
• Permuter le contenu des registres AX et BX ret
2. Ecrire un code permettant de: org 100h

• Mettre dans SI la valeur 10AAH
mov si,1
mov di,1
• Mettre dans DI la valeur 10ABH
mov [si
• Mettre dans [SI] la valeur FFH mov [di
• Mettre dans [DI] la valeur 33H xchg [s
• Permuter le contenu des [SI] et [DI] xchg bl,
xchg [s
ret
Exercices:
1. Ecrire un programme en assembleur 8086 qui org 100h

permet de : mov ax, 100h
 Charger la valeur 100H dans le registre AX. mov bx, 205h
 Charger la valeur 205H dans le registre BX. xchg ax,bx
 Permuter les valeurs des registres AX et BX. ret
2. Refaire la même chose sans utiliser l’instruction org 100h

mov ax, 100h
XCHG
mov bx, 205h
mov cx, ax
mov ax, bx
mov bx, cx
ret
II- Les instructions arithmétiques
Le 8086 permet d'effectuer les quatre opérations arithmétiques de base: l'addition,

la soustraction, la multiplication et la division.
Les opérations peuvent s'effectuer sur des nombres de 8 bits ou de 16 bits signés
ou non signés. Les nombres signés sont représentés en complément à 2.
ADD
ADD Od, Os : Additionne l'opérande source (Os) et l'opérande destination (Od) et
met le résultat dans l'opérande destination (Od).
[Od  Od + Os]
ADD R1 , R2 R1R1+R2
ADD R , [adr] R R+[adr]
ADD [adr] , R [adr] R+[adr]
ADD R , im RR+im
ADD taille [adr] , im [adr] [adr]+im
ADD [adr], [adr]

Exemples :
add ah, [1100H] ; ajoute le contenu de la case mémoire d’offset 1100H à

l’accumulateur AH;
add ah,[bx] ; ajoute le contenu de la case mémoire pointée par DS:BX à

l’accumulateur AH;
add byte [1200H], 05H ; ajoute la valeur 05H au contenu de la case

mémoire d’offset 1200H.
Exercice:
L’instruction ADD permet de positionner les flags à « 1 » ou à « 0 » selon le résultat
de l’opération:
1. Après avoir exécuté les programmes suivants, quelles sont les valeurs que
prennent les flags? Faire un calcul manuel pour justifier la réponse.
org 100h org 100h

mov al, 0D8h mov bl, 75 ; décimal
mov ah, 0CAh mov bh, 67; décimal
add ah,al add bh, bl C 1
ret ret
Z 1
2. Proposer un programme pour positionner les flags comme indiqué: S 0
O 0
P 1
A 1
Le 8086 permet d'effectuer les quatre opérations arithmétiques de base: l'addition,

la soustraction, la multiplication et la division.
Les opérations peuvent s'effectuer sur des nombres de 8 bits ou de 16 bits signés
ou non signés. Les nombres signés sont représentés en complément à 2.
SUB
SUB Od, Os : Soustrait l'opérande source (Os) et l'opérande destination (Od) et met
le résultat dans l'opérande destination (Od).
[Od  Od - Os]
SUB R1 , R2 R1R1-R2
SUB R , [adr] R R-[adr]
SUB [adr] , R [adr] [adr] -R
SUB R , im RR-im SUB [adr], [adr]
SUB taille [adr] , im [adr] [adr]-im
Exemple :
mov ax, 39h
sub ax, 18h ; axax-18h
Exercice:
L’instruction SUB permet de positionner les flags CZSOPA à ‘1’ ou à ‘0’ selon le
résultat de l’opération:
1. Après avoir exécuté les programmes suivants, quelles sont les valeurs que
prennent les flags? Faire un calcul manuel pour justifier la réponse.
org 100h org 100h

mov bl, 75 ; décimal mov bl, 75 ; décimal
mov bh, 67; décimal mov bh, 67; décimal
sub bh, bl sub bl, bh
ret ret
2. Discuter les résultats

EXERCICES
Exercice:
Il faut un CA2

MUL
MUL Os : Effectue une multiplication non signée entre l'accumulateur (AL ou AX) et
l'opérande (Os). Le résultat de taille double est stocké dans l'accumulateur
et son extension (AH ou DX).
IMUL Os : Identique à MUL excepté qu'une multiplication signée est effectuée.
(I) MUL Reg8 AXAL*Reg8

(I) MUL BYTE [adr] AXAL*[adr]
(I) MUL Reg16 DX:AX AX*Reg16 (I) MUL im
(I) MUL WORD [adr] DX:AX AX*[adr]
Exemples :
mov al,51 mov ax,4253

mov bl,32 mov bx,1689
mul bl; AX = 51 × 32 mul bx; (DX, AX) = 4253 × 1689

Exemples : AH AL
MOV AL, 4 ? ? 0 4
MOV AH, 25 1 9 0 4 AX
MUL AH 0 0 6 4
MOV BX, 435 0 1 B 3 BX

MOV AX, 2372 0 9 4 4 AX
MUL BX 0 0 0 F B E 8 C
DX AX
MOV BX, -435 F E 4 D BX
MOV AX, 2372 0 9 4 4 AX
IMUL BX F F F 0 4 1 7 4
DX AX
Exemples:
MOV BX, 435

A l’issue de l’exécution de ces 3 instructions, AX contient la
MOV AX, 2372 valeur BE8C et DX la valeur F, soit la valeur hexadécimale
FBE8C, c’est-à-dire 1031820, le produit de 435 par 2372.
IMUL BX
MOV BX, -435

MOV AX, 2372 valeur 4174 et DX la valeur FFF0, soit la valeur -1031820, le
produit de -435 par 2372.
IMUL BX
Ecrire un programme en assembleur 8086 qui calcule

de factoriel de 5. Stocker le résultat dans l’@ D000h
org 100h
MOV AL, 05H
MOV CL, 05h-1h
Back:
MUL CL
LOOP back
MOV [0xD000], AL
ret

DIV
DIV Os : Effectue une division non signée entre l'accumulateur (AL ou AX) par
l'opérande (Os). Le quotient est récupéré dans le registre AL ou AX et le
reste dans le registre AH ou DX.
IDIV Os : Identique à DIV excepté qu'une division signée est effectuée.
(I) DIV Reg8 AL Quotient

(I) DIV BYTE [adr] AH Reste
(I) DIV Reg16 AX  Quotient (I) DIV im
(I) DIV WORD [adr] DX  Reste
Exemples : mov dx,0

mov ax,35 mov ax,1234
mov bl,10 mov bx,10
div bl; AL = 3h (quotient) et AH = 5h (reste) div bx; AX = 7Bh (quotient) et DX = 4h (reste)

Exemples :
MOV BX, 435 0 1 B 3 BX

MOV AX, 2372 0 9 4 4 AX
DIV BX 0 0 C 5 0 0 0 5
DX (reste) AX (quotient)
MOV BX, -435 F E 4 D BX

MOV AX, 2372 0 9 4 4 AX
IDIV BX 0 0 C 5 F F F B
DX (reste) AX (quotient)
Exemples:
MOV BX, FFFEh

MOV AX, 2372H valeur 0172H et DX la valeur 2656H.
MOV DX, 0172H Tous les opérandes sont considérés comme nombre positifs.
DIV BX
MOV BX, FFFEh

MOV AX, 2372H valeur 2372H et DX la valeur 0172H.
MOV DX, 0172H Un opérande est considéré comme un nombre négatif si le

IDIV BX bit du poids leplus fort est 1 (bit signe).

INC
INC Os : incrémente l'opérande (Os) d’une unité. Os [Os  Os +1]
INC R R R+1
Incrémenter le contenu d’une case mémoire

INC taille [adr]
Exemples : En partant de la situation mémoire illustrée, quelle est la situation mémoire

après l’exécution séquentielle des instructions suivantes
INC BYTE ptr [400h] DS: 400 FEh

DS: 401 33h
INC WORD ptr [400h]
org 100h
mov al,-3
titi: inc al
JNZ titi
ret
Exemple : FEh
DS: 400
33h
INC BYTE ptr [400h]
DS: 400 FFh

33h
INC WORD ptr [400h]
DS: 400 00 octet du poids faible

34h octet du poids fort

DEC
DEC Os : Décrémente l'opérande (Os) d’une unité. Os [Os  Os -1]
DEC R R R-1
Décrémenter le contenu d’une case mémoire

DEC taille [adr]
Exemples : En partant de la situation mémoire illustrée, quelle est la situation mémoire

après l’exécution séquentielle des instructions suivantes
DEC BYTE ptr [400h] DS: 400 FEh

DS: 401 33h
DEC WORD ptr [400h]

NEG
NEG Os : Remplace l'opérande (Os) par son complément à 2 [Os  0- Os=CA2(Os)]
NEG R R CA2(R)
NEG taille [adr] adresse CA2([adresse])


CMP
CMP Od, Os : Compare (soustrait) les opérandes Od et Os et positionne les flags
(registre d’état) en fonction du résultat. L’opérande Od n’est pas modifié.
Opérandes non Signés Opérandes Signés
O S Z C O S Z C
Od > Os - - 0 0 0/1 0 0 -
Od = Os - - 1 0 0 0 1 -
Od < Os - - 0 1 0/1 1 0 -
IV- Les instructions de branchement

CMP
 Instructions de branchement (saut) arithmétique:
Condition Nombres signés Nombres non signés

A=B JE
A≠B JNE
A>B JG JA
A≥B JGE JAE
A<B JL JB
A≤B JLE JBE 7

Exemples :
AH AL
MOV AL, 23 ? ? 1 7 AX
CMP AL, 34
C=1;Z=0;S=1
Exemple: CMP Nbr signé, Nbr non signé

org 100h org 100h
mov ah,0xFFh 100h mov ah,0xFFh
mov dl,1 102h mov dl,1
toto: dec dl 104h toto: dec dl
cmp ah,dl 106h cmp ah,dl
;Nombres non signés ;Nombres signés
JA titi 108h JG titi

(JA 10Eh)
JB toto 10Ah JL toto
(JB 104h)
JMP toto 10Ch JMP toto
(JMP 104h)
titi: RET 10Eh
titi: RET

Autres instructions arithmétiques
DEC Op : Décrémentation d’une unité ; Op - 1 → Op
NEG Op : Remplace Op par son négatif (Complément à 2 de Op)
CWD : Conversion de mot en double mot, effectuer une extension de AX dans DX

en respectant le signe.
MOV AX, 96 ? ? ? ? 0 0 6 0
CWD 0 0 0 0 0 0 6 0
DX AX
MOV AX, - 96 ? ? ? ? F F A 0
CWD F F F F F F A 0
DX AX

Autres instructions arithmétiques
DEC Op : Décrémentation d’une unité ; Op - 1 → Op
NEG Op : Remplace Op par son négatif (Complément à 2 de Op)
CWD : Conversion de mot en double mot, effectuer une extension de AX dans DX

en respectant le signe.
CBW : Conversion d’octet en mot, effectue une extension de AL dans AH en

respectant le signe:
• Si AL contient un nombre positif, on complète par des 0 pour obtenir la
représentation sur 16 bits.

• Si AL contient un nombre négatif, on complète par des 1 pour obtenir la
représentation sur 16 bits

AH AL
MOV AX, 96 ? ? 6 0
AX
CBW 0 0 6 0
Ecrire des programmes en assembleur 8086 :

A. Qui permet d’avoir toujours AH sup ou égale à AL
B. Qui permet de transférer les 11 données de l'@ [B000H] vers
l@ [E001h]
C. Pour que AH comporte le max des valeurs des @ mémoire
allant de l’@ 200h à l’@ 211h
D. Qui permet de compter les nombres nuls dans un tableau
d'octets dans une mémoire de longueur 20h et débutant à l@
[200h], le résultat sera placé a l@ [400h].
E. Qui permet de comparer les valeurs contenues dans les regitres
AL, BL et CL pour trouver le minimum et le maximum de ces
trois valeurs. Stocker le minimum dans la mémoire à l’adresse
400h et le maximum dans la mémoire à l’adresse 500h.
84
III- Les instructions Logiques
Le 8086 permet d’exécuter les instructions logiques. Ces instructions permettent de

manipuler des données au niveau des bits. Les opérations logiques de base sont :
 ET;
 OU;
 OU exclusif ;
 complément à 1;
 complément à 2;
 décalages et rotations.
III- Les instructions logiques

AND
AND Od, Os effectue un ET logique entre Od et Os.
Od ← Od ET Os
AND R1 , R2 R1R1 ET R2
AND R , [adr] R R et [adr]
AND [adr] , R [adr] [adr] et R
AND R , im RR et im
AND [adr], [adr]
AND taille [adr] , im [adr] [adr] et im
Exemple :
MOV AL, 10010110B

MOV BL, 11001101B →
AND AL, BL

Exemple :
MOV AX, 503H

AND AX, 0201H
AX 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1
0201h 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1
AX 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

OR
OR Od, Os effectue un OU logique entre Od et Os.
Od ← Od ET Os
OR R1 , R2 R1R1 ou R2
OR R , [adr] R R ou [adr]
OR [adr] , R [adr] [adr] ou R
OR R , im RR ou im
OU [adr], [adr]
OR taille [adr] , im [adr] [adr] ou im
Exemple :
MOV AX , 503h
AX 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1
OR AX , 0201h
0201h 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1
AX 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1

XOR
XOR Od, Os effectue un OU Exclusif logique entre Od et Os.
Od ← Od XOR Os
XOR R1 , R2 R1R1 ou exclusif R2

XOR R , [adr] R R ou exclusif [adr]
XOR [adr] , R [adr] [adr] ou exclusif R
XOR R , im RR ou exclusif im
XOR [adr], [adr]
XOR taille [adr] , im [adr] [adr] ou exclusif im
Exemple :
MOV AX , 503h
AX 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1
XOR AX , 0201h
0201h 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1
AX 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0

NOT
NOT Od transforme la valeur de l’opérande (registre ou mot mémoire) en son
complément à 1.
Od ← CA1(Od)
NOT R RCA1(R)
NOT [adr] [adr]CA1([adr])
Exemples :
MOV AX , 503h AX 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1
NOT AX AX 1 1 1 1 1 0 1 0 1 1 1 1 1 1 0 0
AX
MOV AX, 96 0 0 6 0
NOT AX F F 9 F

TEST
TEST Od, Os similaire à AND mais ne retourne pas de résultat dans Od, seuls les
indicateurs sont positionnés.
Exemple :
MOV AX , 503h
TEST AX, 0201h
AX 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1
0201h 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1
RT 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
S = 0, Z = 0
En utilisant l’instruction Org 100h

TEST compter les nombres Mov SI,300h
paires dans un tableau Mov CL,12h
d’octet de 12h adresses qui Mov [D000h], 0h
commence à l’@ 300h. nbr_pr:
Mettre le résultat dans l’@ TEST [SI],1
D000H JNZ impaire
INC [D000h]
impaire:
INC SI
Loop nbr_pr
Ret

Exercices:
Écrire un programme qui fait AX BX sans utiliser l'instruction XOR.
org 100h
MOV AX,[301h]
MOV BX,[303h]
NOT AX
NOT BX
AND AX, [303h]
AND BX, [301h]
OR AX, BX
ret

Exercices:
1. Convertir le caractère en AL en majuscule.
2. Convertir un octet décimal binaire en son équivalent

ASCII décimal.
3. Sauter à une étiquette si la valeur dans AL est

différente de zéro.
Utiliser pour chacune de ces 4 questions, une seule instruction parmi AND,
OR, XOR et TEST pour effectuer une des tâches suivantes: (chaque instruction doit être
utilisé une seule fois)
1. Convertir le code ASCII d'un chiffre décimal («0» à «9») contenu dans AL en sa
valeur numérique.
2. Fixer à '1' les bits impairs dans AX (ie: les bits numérotés 1, 3, 5…) sans changer
les bits pairs.
3. Ecrire un programme qui indique si les deux bits : le bit le MSB et LSB de BH sont
tous les deux à '1' sans changer la valeur de BH. Expliquer:
4. Inverser le bit le moins significatif de BX LSB sans changer les autres bits.
(0--> 1 et 1-->0)
INSTRUCTIONS LOGIQUES
Exercices
1. Convert the character in AL to upper case.
Solution: Use the AND instruction to clear bit 5.
• mov al,'a' ; AL = 0110 0001b
• and al, 1101 1111b ; AL = 0100 0001b
2. Convert a binary decimal byte into its equivalent ASCII decimal digit.
• Solution: Use the OR instruction to set bits 4 and 5.
• mov al,6 ; AL = 0000 0110b
• or al, 0011 0000b ; AL = 0011 0110b
• The ASCII digit '6' = b
3. Jump to a label if the value in AL is not zero.
• Solution: OR the byte with itself, then use the JNZ (jump if not zero)
instruction.
• or al,al
• jnz IsNotZero ; jump if not zero
• ORing any number with itself does not change its value.
RAPPEL ET COMPLÉMENT : CODAGE

Exercices:
1. Convertir le caractère en AL en majuscule.
Solution : Utilisez l'instruction AND pour effacer le bit 5.
mov al,'a' ; AL = 0110 0001b
and al, 1101 1111b ; AL = 0100 0001b
2. Convertit un octet décimal binaire en son équivalent ASCII décimal.
Solution : Utilisez l'instruction OR pour positionner les bits 4 et 5.
mov al,6 ; AL = 0000 0110b
or al, 0011 0000b ; AL = 0011 0110b
The ASCII digit '6' = 0011 0110b
3. Sauter à une étiquette si la valeur dans AL est différente de zéro.
Solution : Faites un OU entre l'octet et lui-même, puis utilisez l'instruction JNZ
(jump if not zero).
or al,al
jnz IsNotZero ; jump if not zero
ORing any number with itself does not change its value.
IV- Les instructions de décalage et de rotation
SHL Od, n Décalage Logique Gauche (Shift Logical Left)
SAL Od, n Décalage Arithmétique Gauche (Shift Arithmetic Left
SHR Od, n Décalage Logique Droit (Shift Logical Right)
SAR Od, n Décalage Arithmétique Droit (Shift Arithmetic Right)
ROL Od, n Décalage Circulaire Gauche (Rotate Left)
ROR Od, n Décalage Circulaire Droit (Rotate Right)
RCL Od, n Décalage Circulaire Gauche à travers la retenue (Rotate Left through Carry)
RCR Od, n Décalage Circulaire Droit à travers la retenue (Rotate Right through Carry)
Od = registre ou adresse mémoire

n=1, CL ou CX

 SHL Od, n et SAL Od, n ont le même comportement.
... ... 0 ... 0

C MSB LSB n zéros
 SHR Od, n
0 ... 0 ... ...

n zéros MSB LSB C
SHR ne tient pas compte du bit de signe  SHR travaille avec les nombres non signés.
 SAR Od, n
n fois C
LSB
SAR préserve le bit de signe  SAR est réservée aux nombres signés.

Exemple :
MOV AX, 503H

AND AX, 0201H
AX 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1
0201h 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1
AX 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

Exemples:
Écrire un programme permettant de déterminer la valeur du

quartet le plus significatif dans le registre AL.

Exemples:
Écrire un programme pour déterminer l'état du bit 5 de AL :
Avec un décalage de 6 positions vers la droite ou de 4 positions vers la

gauche, le bit 5 de AL est transféré au drapeau de retenue CF. Il suffit donc
de tester ce drapeau.

 ROL Od, n
... ...
C7
 ROR Od, n
... ...
C7

 RCL Od, n
C ... ...
 RCR Od, n
... ... C

Exemples:
AL C
MOV AL, 11001011B 1 1 0 0 1 0 1 1 x
SHR AL, 1 0 1 1 0 0 1 0 1 1
AL C
MOV AL, 11001011B 1 1 0 0 1 0 1 1 x
ROR AL, 1 1 1 1 0 0 1 0 1 1
AL C
MOV AL, 11001011B 1 1 0 0 1 0 1 1 x
69
RCR AL, 1 x 1 1 0 0 1 0 1 1
org 100h
XOR BL, BL
MOV CL, 16
Ecrire un programme en MOV AX, 0xFFFF ; le nbr à traiter
ASM 8086 qui permet de
ENCORE:
calculer le nombre de ‘1’ ;ROL AX, 1
dans AX. SHR AX,1
JNC PROCHAIN
Mettre le résultat dans le INC BL
registre BL. PROCHAIN:
LOOP ENCORE
ret

Exercice:
Soit le programme suivant en langage 8086:

org 100h
…
MOV AX, [0400h]
~cmd AX,1
MOV BX,AX
~cmd AX, ~nbr
ADD AX,BX
…
ret
Cette partie du programme permet de faire une multiplication de AX par 10.
a. Parmi les instructions de décalage citer dans le rappel laquelle doit remplacer ~cmd?
b. Quel est le nombre de décalage ~nbr ?

Exercice:
Soit le programme suivant en langage 8086:

org 100h org 100h
… …
MOV AX, [0400h] MOV AX, [0400h]; AX  [0400h]
~cmd AX,2 SHL AX,2 ;AX4AX
MOV BX,AX MOV BX,AX ; BXAX
~cmd AX, ~nbr SHL AX,1 ;AX2AX
ADD AX,BX ADD AX,BX ;AXAX + BX
… …
ret ret
Cette partie du programme permet de faire une multiplication de AX par 10.
a. Parmi les instructions de décalage citer dans le rappel laquelle doit remplacer ~cmd?
b. Quel est le nombre de décalage ~nbr ?
org 100h
….
; multiply ax by 10
SHL AX,1
;AX2 AX
MOV BX,AX
;BX2 AX
SHL AX,2
;AX8 AX
ADD AX,BX
;AX10 AX
….
ret
• org 100h • 18 =2 + 16
• ….Mov ax,3 • 2 un déplacement vers
• ; multiply ax by 10 la gauche SHL
• SHL AX,1
• ;Ax 2AX
• 16=2^4 c’est 4
• MOV BX,AX déplacements vers la
• ;BX 2AX gauche
• SHL AX, 3
• ;Ax 2AX* 2^3
• ;Ax 16AX
• ADD AX,BX
• ;Ax 16AX+2AX
• ….
• Ecrire un programme qui permet de trier par ordre

croissant un tableau de longueur N = 100h
débutant à l’adresse [200h].
TRI d’un tableau: ORDRE CROISSANT
org 100h
MOV CX, 0FFh

Etq1: MOV SI, 200h
Etq3: INC SI
MOV DX, CX DEC DX
MOV BL, 0 JNZ Etq2
CMP BL, 0
JZ Fin
Etq2: MOV AL, [SI] DEC CX
CMP AL, [SI+1] JNZ Etq1
JBE Etq3
Fin: ret
XCHG AL, [SI+1]
MOV [SI], AL
INC BL
 Les instructions de branchement (ou saut) permettent de

modifier l’ordre d’exécution des instructions du programme en
fonction de certaines conditions.
 L’instruction de branchement est une instruction à un
opérande « INST Label ». Un label (ou une étiquette) est une
représentation symbolique d’une instruction en mémoire.
 Le mode d’adressage des instructions de branchement est
immédiat.
 On distingue trois types d’instructions:
 Contrôle de boucle : LOOP X
 Branchement inconditionnel: JMP
 Branchement conditionnel: Jcondition

 Instructions de contrôle de boucle : LOOP

LOOP label : fonctionne automatiquement avec le registre CX. Quand le
processeur rencontre une instruction LOOP, il décrémente le registre CX.
Si CX n'est pas encore nul, il reboucle à la ligne portant l'étiquette label,
sinon il poursuit le programme à la ligne suivante:
MOV CX, 10
ici: .....
..... S’exécute 10 fois
.....
LOOP ici
......
Exemple: Que fait ce programme?
MOV DX, 0
MOV CX, 5
ETIQ: MOV BX, CX
ADD DL, [BX+1100]
LOOP ETIQ
Ajoute les 5 valeurs trouvées aux adresses 1101--1105

Incrémenter 5 fois le contenu du registre AX

Actions
Instructions
1. Mise à jours de CX 2. Branchement si:
LOOP CXCX-1 CX≠0
(CX ≠ 0 ) et (ZF = 1)
LOOPZ, LOOPE CXCX-1
(égalité)
(CX ≠ 0 ) et (ZF = 0)
LOOPNZ, LOOPNE CXCX-1
(inégalité)
 Instructions de branchement inconditionnel : JMP

JMP label : effectue un saut (jump) vers le label spécifié.
. .
. .
. .
JMP suite Etiq: . . . . . . .
. .
. .
. .
Suite: . . . . . . . . . JMP Etiq
. .
. .
 Instructions de branchement inconditionnel : JMP

org 100h
mov ax, 5 ; set ax to 5.
mov bx, 2 ; set bx to 2.
jmp calc ; go to 'calc'.
back: jmp stop ; go to 'stop'.
calc: add ax, bx ; add bx to ax.
jmp back ; go 'back'.
stop: ret ; return to operating system.
 Instructions de branchement conditionnel : Jcondition
 Un saut conditionnel n’est exécuté que si une certaine condition est
satisfaite, sinon l’exécution se poursuit séquentiellement à
l’instruction suivante.
 La condition du saut porte sur l’état de l’un (ou plusieurs) des
indicateurs d’état (flags) du microprocesseur qui sont positionnés en
fonction du résultat de la dernière opération.


Instruction Nom Condition
JZ Jump if Zero Saut si Z = 1
JNZ Jump if Not Zero Saut si Z = 0
JC Jump if Carry Saut si C = 1
JNC Jump if Not Carry Saut si C = 0
JS Jump if Sign Saut si S = 1
JNS Jump if Not Sign Saut si S = 0
JO Jump if Overflow Saut si O = 1
JNO Jump if Not Overflow Saut si O = 0
JP Jump if Parity Saut si P = 1
JNP Jump if Not Parity Saut si P = 0
PLAN
I. Introduction
II. Architecture Générale du 8086
III. Jeu d’Instructions
IV. Programmation en Assembleur 8086
V. Code Machine des Instructions

PROGRAMMATION EN ASSEMBLEUR 8086
Exercices :
Ecrire des programmes en assembleur 8086 qui permet:

1. d’avoir toujours AH supérieur ou égal à AL.
2. de transférer les 11 données l’@ [DS:B000H] vers l’@ [DS:E001h].
3. de faire en sorte que AH contient toujours le maximum des valeurs des adresses
mémoire comprises entre 200h et 211h.
4. de compter les nombres nuls dans un tableau d'octets dans une mémoire de
longueur 20h et débutant à l'adresse [200h], le résultat sera placé à l@ [400h].
IV- Les instructions de branchement org 100h

MOV CX, 0FFh
Exercice: Ecrire un programme qui permet de trier par Etq1: MOV SI, 200h
ordre croissant un tableau de longueur N = 100h MOV DX, CX
débutant à l’adresse [200h]. MOV BL, 0
Etq2: MOV AL, [SI]
CMP AL, [SI+1]
JBE Etq3
XCHG AL, [SI+1]
MOV [SI], AL
INC BL
Etq3: INC SI
DEC DX
JNZ Etq2
CMP BL, 0
JZ Fin
DEC CX
JNZ Etq1
Fin: ret
TRI d’un tableau: ORDRE CROISSANT
org 100h
MOV CX, 0FFh

Etq1: MOV SI, 200h
Etq3: INC SI
MOV DX, CX DEC DX
MOV BL, 0 JNZ Etq2
CMP BL, 0
JZ Fin
Etq2: MOV AL, [SI] DEC CX
CMP AL, [SI+1] JNZ Etq1
JBE Etq3
Fin: ret
XCHG AL, [SI+1]
MOV [SI], AL
INC BL
Exercices:
1. Trouver le plus grand (puis le plus petit) des deux nombres des adresses 38H et
40H, la mettre en 42H
2. Faire la somme des valeurs contenues à partir de l'adresse 42H, le nombre de

valeurs à additionner étant en 40H, mettre la somme en 38H
3. Trouver le nombre de valeurs négatives contenues à partir de l'adresse 42H, le

nombre de valeurs étant en 40H, mettre le résultat en 38H
4. De la même manière, trouver la valeur minimum puis la valeur maximum, puis les
deux en même temps
5. Trouver le nombre de caractères d'une chaîne ASCII terminée par le caractère nul
de code ASCII ‘0’
6. Faire la concaténation de deux chaînes ASCII terminées par 0 (CH1 et CH2) dans
une chaîne RES, mettre le nombre de caractères de la chaîne obtenue dans LG
7. Convertir un octet NB en une chaîne de caractères numériques RES ( 123 --> '123' )
Exercice:
Soit les nombres a, b et c stockés en mémoire, tel que :
• a est stocké à l’adresse 100H.

• b est stocké à l’adresse 101H.
• c est stocké à l’adresse 102H.
Ecrire un programme en assembleur 8086 qui permet d’évaluer l’expression

suivante :
d = a2 / (2b + c)
Et stocker le résultat en mémoire à l’adresse 200H.

Exercice:
Ecrire un programme en Assembleur 8086 qui permet de :
• Comparer les valeurs contenues dans les registres AL, BL et CL pour trouver
le minimum et le maximum de ces trois valeurs.
• Stocker le minimum en mémoire à l’adresse 100H
• Stocker le maximum en mémoire à l’adresse 200H
Les boucles
Il n’existe pas de structure générale en assembleur pour coder une boucle tant-que ou
une boucle répéter.
 Cependant, à l’aide des instructions vues précédemment pour réaliser des tests, on
peut coder n’importe quel type de boucle.
 On verra également que des instructions simplifient grandement le codage des

boucles pour (boucle for).
Principe général
Une boucle est essentiellement composée de deux éléments :
 Une condition de sortie qui indique quand la boucle doit être interrompue,
qu’il faut sortir de la boucle et continuer l’exécution des instructions
en séquence.
 Un corps de boucle qui spécifie l’action à réaliser pendant que la condition de
sortie n’est pas vérifiée, à chaque itération de la boucle.
La condition de sortie va donc être codée d’une manière ressemblant aux tests.
Un saut conditionnel testera cette condition et entraînera, quand la condition est
vérifiée, la sortie de la boucle.
Le corps de la boucle devra pour sa part (boucler), c’est-à-dire, une fois exécuté,
entraîner le réévaluation de la condition de sortie et la prise de décision quant à la
poursuite ou non des itérations
Boucle Tant que

Le squelette d’une boucle tant-que, dans un langage de haut niveau, est le suivant :
TANT-QUE (condition) FAIRE

action
FIN_TQ
Cela va se traduire en assembleur sous la forme suivante :
TQn: calcul de la condition

Jcc FTQn
action
...
JMP TQn
FTQn:
...
Boucle Répéter
Le squelette d’une boucle répéter, dans un langage de haut niveau, est le suivant :
Répéter
action
Jusqu’à (condition vraie)
Cela va se traduire en assembleur sous la forme suivante :
REPETERn: action
...
Calcul de la condition
Jcc REPETERn
...
Boucles pour
Une boucle pour est généralement codée à l’aide d’une instruction de la famille LOOP.
Syntaxe : LOOP label
LOOP fonctionne avec le registre CX qui joue le rôle de compteur de boucles. Elle
décrémente le compteur Sans Modifier Aucun Des Indicateurs.
Si le compteur est différent de 0, un saut à l’étiquette opérande de l’instruction
LOOP est réalisé.
Le squelette d’une boucle pour s’écrit de la manière suivante :
POUR indice = 0 à n FAIRE
Action
Fin pour
Cette boucle se traduit en assembleur de la manière suivante :
mov cx, n ; n est le nombre d’itérations
POURn: ...
action
loop POURn
…

Exemples :
org 100h
mov ah,0xFFh 100h
mov dl,1 102h
MOV AL, 23
toto: dec dl 104h
cmp ah,dl 106h CMP AL, 34
;Nombres non signés ;Nombres signés
JA titi 108h JG titi

(JA 10Eh)
JB toto 10Ah JL toto
(JB 104h)
JMP toto 10Ch JMP toto
(JMP 104h)
titi : RET 10Eh titi : RET

Exercice: Ecrire un programme qui permet de trier par ordre
croissant un tableau de longueur N = 100h débutant à
l’adresse [200h].
XXX- Xxxx

8086 Courspdf 2024

Transféré par

Droits d'auteur :

Formats disponibles

8086 Courspdf 2024

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

8086 Courspdf 2024

Transféré par

Droits d'auteur :

Formats disponibles

Microprocesseur

Core 2, i5, i7, .....

 Il se présente sous forme d'un boîtier de 40 broches

Bus de données Interne 16 bits

Tous les registres du 8086 sont structurés en 16 bits.

V- Architecture interne du 8086

Bloc de commandes de l’unité d’exécution

Bloc UAL (Unité Arithmétique-Logique)

VI- Gestion de la mémoire

 La mémoire est donc divisée en pages de 64 Ko appelées segments

 Deux registres sont alors nécessaires pour adresser un emplacement mémoire:

• Registre pour adresser le segment (registre de segment) : CS, DS, SS, ES

 Une adresse se présente sous la forme segment : offset

• L’offset précise l’adresse relative par rapport au début de segment.

VI- Gestion de la mémoire

 Tous les registres du 8086 sont structurés en 16 bits.

DS : Data Définit le début de la mémoire de données dans laquelle sont

SS : Stack  Définit le début de la pile.

ES : Extra  Définit le début d'un segment auxiliaire pour données

 Le registre segment localise le début d’une zone mémoire de 64Ko

SP : Pointeur  Utilisé pour l'accès à la pile. Pointe sur la tête de

BP : Pointeur  Usage général

SI : Registre Usage général

DI : Registre  Usage général

 Le registre segment localise le début d’une zone mémoire de 64Ko

VI- Gestion de la mémoire

Exercice 1 : Trouver l’adresse logique, si:

VI- Gestion de la mémoire

Exercice 2: Calculer l’adresse physique, si:

Adresse segment: 1005H -------> 0001 0000 0000 0101

Adresse offset: 5555H

Adresse Physique = Adresse de segment * 10H + Offset (adresse de décalage)

VI- Gestion de la mémoire

Décalage à gauche de 4 positions : ------> 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Adresse physique: (A5F00)H <------- 1 0 1 0 0 1 0 1 1 1 1 1 0 0 0 0 0 0 0 0

La limite inférieure de CS : CS*10H+ 0000H

VI- Gestion de la mémoire

Décalage à gauche de 4 positions : ------> 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Adresse physique: (A5F00)H <------- 1 0 1 0 0 1 0 1 1 1 1 1 0 0 0 0 0 0 0 0

La limite inférieure de CS : CS*10H+ 0000H

Une instruction à rechercher est dans l’adresse physique 389F2H

VI- Gestion de la mémoire

 Est-ce que la bande du code segment l’inclut ou pas?

Le segment CS n’inclut pas 389F2H puisque 389F2H>36FFFH

 Si c’est non, quelle valeur à donner à CS si IP=1282H?

CS*10H+1282H=389F2H CS=(389F2H- 1282H)/10H=3777H

 Tous les registres du 8086 sont structurés en 16 bits.

BX : Base  Usage général,

DX : Data  Usage général,

SP : Pointeur  Utilisé pour l'accès à la pile. Pointe sur la tête de

BP : Pointeur  Usage général

SI : Registre Usage général

DI : Registre  Usage général

 Le registre segment localise le début d’une zone mémoire de 64Ko

DS : Data Définit le début de la mémoire de données dans laquelle sont

SS : Stack  Définit le début de la pile.

ES : Extra  Définit le début d'un segment auxiliaire pour données

o P (Parité) : indique que le nombre de ‘1’ dans le résultat est un

o Z (Zéro) : à ‘1’ indique que le résultat est nul.