Les instructions 8086_288888888_1_2021.pdf

EMSI
(2ème année) AP
PROCESSEUR INTEL
PROCESSEUR INTEL
80X86
2018 - 2019

 Présenter le Processeur 8086 de Intel
 Étudier son jeux d'instruction.
Apprendre à le programmer en assembleur pour
OBJECTIFS DU CHAPITRE
2
 Apprendre à le programmer en assembleur pour
comprendre son fonctionnement.
 Coder les instructions en langage machine (binaire).

PLAN DU CHAPITRE III
 Introduction
 Architecture Générale
 Jeu d’instructions
 Programmation en Assembleur
 Code Machine des Instructions
3

1993-2005
2006
jusqu’à
aujourd’hui
Processeurs 80x : 8080,
• 8086, 8080, 80286, 80386,
Pentium: I, II, III,
IV, V, ...
ÉVOLUTION DES PROCESSEURS INTEL
Processeurs multi-cœurs:
Core 2, i5, i7, .....
INTRODUCTION
4
1971
• 8086, 8080, 80286, 80386,
• 80486, ......
• 1972 – 1992
• Premier processeur
• 4004 La majorité des microprocesseurs
Intel sont compatibles avec le 8086

PROCESSEUR INTEL 8086
fut le premier
 Disponible depuis 1978, le processeur 8086
processeur 16 bits fabriqué par Intel.
40 broches
 Il se présente sous forme d'un boîtier de
alimenté par une alimentation unique de 5V.
INTRODUCTION
5

PARTIE 1:
ARCHITECTURE GÉNÉRALE DU
PROCESSEUR 8086
6

AH AL
BH BL
CH CL
DH DL
BP
SP
SI
DI
AX
BX
CX
DX
CS
DS
SS
ES
Calcul
d’adresse
IP
Interface
avec Bus
externes
Bus d’adresse
Bus de données
Bus de données Interne 16 bits
Bus de contrôle
20 bits
16 bits
16 bits
Bus d’adresse Interne 20 bits
7
Codage
Contrôle
Séquencement
File d’attente 6
octets de codes
instructions
Bus de données Interne 16 bits
RT RT
UAL
Flags Architecture Générale du processeur 8086

SEGMENTATION DE LA MEMOIRE
 La taille du bus d’adresse égale à 20 bits  La mémoire totale
adressable égale 220 octets = 1 Mo
 La taille des registres est 16 bits  on peut adresser seulement 216
octets = 64 ko.
 La mémoire est donc fractionnée en pages de 64 ko appelés
segments.
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
segments.
 On utilise alors deux registres pour adresser une case mémoire
donnée:
 Un registre pour adresser le segment, appelé registre segment:
CS, DS, SS, ES
 Un registre pour adresser à l'intérieur du segment, appelé
registre offset: IP, SP, BP, SI, DI. 8
 Une adresse se présente sous la forme segment:offset

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

REGISTRES DE SEGMENT
Registres Usage
CS : Code
Segment
Définit le début de la mémoire programme dans laquelle sont
stockées les instructions du programme.
Les adresses des différentes instructions du programme sont
relatives à CS
DS : Data
Segment
Définit le début de la mémoire de données dans laquelle sont
stockées toutes les données traitées par le programme.
SS : Stack
Segment
 Définit le début de la pile.
 SP permet de gérer l’empilement et le dépilement.
ES : Extra
Segment
 Définit le début d'un segment auxiliaire pour données
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.
11
segment.

REGISTRES GÉNÉRAUX
Registres Usage
SP : Pointeur
de Pile
 Utilisé pour l'accès à la pile. Pointe sur la têtede
la pile
BP : Pointeur
de Base
 Usage général
 Adressage comme registre de base
86
SI : Registre
d'index (source)
Usage général
Adressage comme registre d’index de l'opérande
source.
DI : Registre
d'index
(destination)
 Usage général
12
destination

forme [Rseg :Roff]
segment.
13
segment.

14

15

Exemple
• Adresse logique CS: IP A000:5F00
• Adresse physique:
16

EXERCICE
CS = F000h
DS = 1000h
Org 100h
mov AH, 32h
mov CX, 45F2h
• Soit le programme ci contre:
• Donner l’adresse logique et
physique de:
mov CX, 45F2h
mov [A011], B2h
mov BX, 45E7h
mov [BX], B211 h
RET
– La première instruction
– Des adresses:
• [A011]
• [BX]

Exercice 1:
• Si CS=3499H et IP=2500H , trouver:
a- les limites du code segment CS
b- l’adresse logique du registre IP
c- l’adresse physique du registre IP
• (ensuite CS= 1296H et IP= 100H) refaire le même exercice
Exercice 2:
Exercice 2:
Donner le résultat de l’opération: 26B4Eh – 9D5Eh.
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?
17

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

Registres Usage
AX:
Accumulateur
 Usage général,
 Obligatoire pour la multiplication et ladivision,
 Ne peut pas servir pour l'adressage
BX : Base  Usage général,
 Adressage
 Adressage
CX :
Comptage et
calcul
 Usage général,
Compteur de répétition.
 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 Usage
SP : Pointeur
de Pile
 Utilisé pour l'accès à la pile. Pointe sur la têtede
la pile
BP : Pointeur
de Base
 Usage général
 Adressage comme registre de base
86
SI : Registre
d'index (source)
Usage général
source.
DI : Registre
d'index
(destination)
 Usage général
21
destination

forme [Rseg :Roff]
segment.
ARCHITECTURE GÉNÉRALE DU µP 8086
22
segment.

Registres Usage
CS : Code
Segment
Définit le début de la mémoire programme dans laquelle sont
stockées les instructions du programme.
Les adresses des différentes instructions du programme sont
relatives à CS
DS : Data
Segment
Définit le début de la mémoire de données dans laquelle sont
stockées toutes les données traitées par le programme.
SS : Stack
Segment
 Définit le début de la pile.
 SP permet de gérer l’empilement et le dépilement.
ES : Extra
Segment
 Définit le début d'un segment auxiliaire pour données
23

COMPTEUR D’INSTRUCTION
 Le compteur d’instruction (IP), appelé aussi Compteur
Ordinal (C.O.) permet de pointer TOUJOURS le premier
octet de l’adresse de l’instruction suivante.
24

REGISTRE D'ÉTAT (FLAGS)
 C (Carry) : indique qu’il y a une retenue du résultat à
8 bits ou 16 bits.
P (Parité) : indique que le nombre de 1 est un nombre pair.
O D I T S Z A P C
0
15
A
25
 P (Parité) : indique que le nombre de 1 est un nombre pair.
 Z (Zéro) : indique que le résultat est nul.
 S (Signe) : indique le signe du résultat
 A(Auxiliary): indique la retenue auxiliaire
 O (Overflow): indique un dépassement de capacité

• 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
ADD BH, BL ADD AH, AL
ret ret
b. Proposer un programme pour positionner les flags
• comme indiqué:
C 1
Z 1
S 0
O 0
P 1
A 1
26

FORMAT D’INSTRUCTION
 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
27
est toujours récupéré dans l’opérande de gauche.
 Il y a aussi des instructions qui agissent sur un seul opérande
INST Opérande
 Les opérandes peuvent être des registres, des constantes ou le
contenu de cases mémoire.

MODE D’ADRESSAGE
1. Adressage registre
 L'opération se fait sur un ou 2 registres
INST R , R
INST R
28
INST R
 Exemples :
 INC AX : incrémenter le registre AX (AX++)
 MOV AX, BX : Copier le contenu de BX dans AX
(AXBX)

MODE D’ADRESSAGE
2. Adressage Immédiat
 L’opérande est une constante (valeur) qui fait partie de
l’instruction :
INST R , IM
INST IM
 Exemples :
 MOV AX, 243 : charger le registre AX par le nombre
décimal 243 (AX243)
29
 JMP 008 : saut à l’instruction du numéro 008

MODE D’ADRESSAGE
2. Adressage Immédiat
 L’opérande est une constante (valeur) qui fait partie de
l’instruction : INST R , IM; INST IM
 Exemples :
 MOV AL, ‘A‘ : Charger le registre AL par le code ASCII du
caractère ‘A' (65)
 MOV AX, ‘A‘ : Charger le registre AH par 00 et le registre
AL par le code ASCII du caractère ‘A'
 MOV AX,‘AB' : Charger AH par le code ASCII du caractère
‘A ‘ (65) et AL par le code ASCII du caractère ‘B‘ (66)
30

MODE D’ADRESSAGE
3. Adressage direct
 Une des deux opérandes se trouve en mémoire. L’adresse
de la case mémoire est précisé directement dans
l’instruction.
31
INST R , [adr]
INST [adr] , R
INST taille [adr] , im
 L’adresse doit être placée entre [Rseg:Roff]. Si le segment
(Rseg) n’est pas précisé, DS est pris par défaut.

MODE D’ADRESSAGE
3. Adressage direct
INST R , [adr]
INST [adr] , R
INST taille [adr] , im
: Copier le contenu de la mémoire d'adresse
: Copier le contenu de AX dans la mémoire
 Exemples :
 MOV AX,[243]
DS:243 dans AX
 MOV [123],AX
d'adresse DS:123
: Copier le contenu de la mémoire
32
SS:243
 MOV AX, [SS:243]
dans AX

MODE D’ADRESSAGE
4. Adressage Indirect
 Une 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 : Roff]
33
INST [Rseg : Roff] , R
INST taille [Rseg : Roff] , im
 Si Rseg n'est pas spécifié, le segment par défaut sera
utilisé.
Registre BX BP SI DI
Segment par défaut DS SS DS DS

MODE D’ADRESSAGE
 Exemples :
[BX]; Charger AX par le contenu de la mémoire d'adresse
 MOV AX,
DS:BX
[BP]; Charger AX par le contenu de la mémoire d'adresse
 MOV AX,
[BP]; Charger AX par le contenu de la mémoire d'adresse
 MOV AX,
SS:BP
[SI]; Charger AX par le contenu de la mémoire d'adresse
 MOV AX,
DS:SI
[DI] ; Charger AX par le contenu de la mémoire d'adresse
 MOV AX,
DS:DI
 MOV AX, [ES:BP]; Charger AX par le contenu de
34
la mémoire
d'adresse ES:BP

MODE D’ADRESSAGE
 L’adressage indirect est divisé en 3 catégories selon le
registre d’offset utilisé: l’adressage Basé, l’adressage
indexé et l’adressage basé indexé.
35
Mode Adressage Basé Indexé Basé Indexé
Registres utilisés BX
BP
DI
SI
BX, DI
BX, SI
BP, DI
BP, SI

MODE D’ADRESSAGE
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 qui sera ajouté
36
au contenu de Roff pour déterminer l’offset,
INST R , [Rseg : Rb+dep]
INST [Rseg : Rb+dep] , R
INST taille [Rseg : Rb+dep] , im

MODE D’ADRESSAGE
A. Adressage Basé
 Exemples :
[BX] : Charger AX par le contenu de la mémoire d'adresse
 MOV AX,
DS:BX
DS:BX
[BX+5] : Charger AX par le contenu de la mémoire d'adresse
 MOV AX,
DS:BX+5
[BP-200] : Charger AX par le contenu de la mémoire d'adresse
 MOV AX,
SS:BX-200
 MOV AX, [ES:BP] : Charger AX par le contenu de la mémoire d'adresse
37
ES:BP

MODE D’ADRESSAGE
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 qui sera ajouté au
27
contenu de Ri pour déterminer l’offset.
INST R , [Rseg : Ri+dep]
INST [Rseg : Ri+dep] , R
INST taille [Rseg : Ri+dep] , im

MODE D’ADRESSAGE
B. Adressage Indexé
Charger AX par le contenu de la mémoire
 Exemples :
 MOV AX, [SI];
d'adresse DS:SI
d'adresse DS:SI
Charger AX par la mémoire d'adresse
 MOV AX, [SI+500];
DS:SI+500
 MOV AX, [DI-8]; Charger AX par la mémoire d'adresse DS:DI-8
d'adresse
28
 MOV AX, [ES:SI+4]; Charger AX par la mémoire
ES:SI+4

MODE D’ADRESSAGE
C. Adressage Basé Indexé
 L'offset de l’adresse de l'opérande est la somme d'un
registre de base, d'un registre d'index et d'un déplacement
29
optionnel. Si Rseg n'est pas spécifié, le segment par défaut
du registre de base est utilisé :
INST R , [Rseg : Rb+Ri+dep]
INST [Rseg : Rb+Ri+dep] , R
INST taille [Rseg : Rb+Ri+dep] , im
and byte ptr [bx+si], 11011111b

MODE D’ADRESSAGE
C. Adressage Basé Indexé
 Exemples :
 MOV AX,[BX+SI]; AX est chargé par la mémoire d'adresse
DS:BX+SI
DS:BX+SI
mémoire d'adresse
mémoire d'adresse
mémoire d'adres3
s0
e
 MOV AX,[BX+DI+5]; AX est chargé par la
DS:BX+DI+5
 MOV AX,[BP+SI-8]; AX est chargé par la
SS:BP+SI-8
 MOV AX,[BP+DI]; AX est chargé par la
SS:BP+DI

Pour chacune des lignes de la routine assembleur, identifiez les modes d’adressage
utilisés :
a. Adressage Immédiat
b. Adressage Registre
c. Adressage direct
d. Adressage indirect
e. Adressage indirect basé
f. Adressage indirect indexé
N° de ligne
N° de ligne
1 mov si, [sp+4]
2 mov ax, 0
3 cmp [si+bx], al
4 jmp etiq3
5 inc ax
6 add dl,[FAh]
7 etiq3: ret

TAILLE DES ECHANGES AVEC LA MEMOIRE
 La mémoire est organisée en octets.
1.Quand on fait une instruction entre un registre et une
donnée qui se trouve en mémoire, c’est le registre qui
détermine la taille de l’opération:
31
 Si le registre est un registre simple (8 bits), l’opération
se fera avec une seule case mémoire.

1. Quand on fait une instruction entre un registre et une
donnée qui se trouve en mémoire, c’est le registre qui
 Si le registre est un registre double (2 octets),
32
 Si le registre est un registre double (2 octets),
l’opération se fera avec deux cases mémoires
MOV [adresse], AX donne 

2. Quand on fait une opération entre une constante et une
case mémoire, il faut utiliser les préfixes BYTE (1 octet) et
WORD (2 octets) pour préciser le nombre d’octets à écrire :
33

PARTIE 2:
JEUX D’INSTRUCTIONS
DU PROCESSEUR 8086
34

JEUX D’INSTRUCTIONS
 Plusieurs types d’instructions, notamment:
 Instructions de Transfert (MOV, XCHG, ....)
 Instructions Arithmétiques (ADD, SUB, MUL, DIV, ...)
 Instructions Logiques (NOT, AND, OR, XOR, ...)
 Instructions de Décalage (SHR, SHL, ROL, ROR, ...)
 Instruction de Branchement (JMP, Jxx, LOOP....)
35
 ......

INSTRUCTIONS DE TRANSFERT
MOV
Source (Os) dans
 MOV Od,Os: Copie l'opérande
l'opérande Destination (Od) [OdOS]
MOV R1 , R2 R1R2
MOV R , [adr] R[adr]
36
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

XCHG
Ecrire un code où
Mettre dans AX la valeur 10FAh
Mettre dans BX la valeur 2234h
Permuter le contenu des registres
AX et BX
org 100h
Ecrire un code où
Mettre dans SI la valeur 10AAh
Mettre dans DI la valeur 10ABh
Mettre dans [SI] la valeur FFh
Mettre dans [DI] la valeur 33h
Permuter le contenu des [SI] et [DI]
org 100h
37
org 100h
mov ax, 10FAh
mov bx, 2234h
xchg ax,bx
ret
org 100h
mov si,10AAh
mov di,10ABh
mov [si], 0FFh
mov [di], 033h
xchg [si],bl
xchg bl,[di]
xchg [si],bl
ret

INSTRUCTIONS DE TRANSFERT
XCHG
Source (Os) avec
 XCHG Od,Os: Échange l'opérande
l'opérande Destination (Od) [OsOd].
XCHG R1 , R2 R1R2
37
XCHG [adr] , R
XCHG R , [adr]
[adr]R
XCHG [adr], [adr]

INSTRUCTIONS ARITHMÉTIQUES
quatre opérations
 Le 8086 permet d'effectuer les
arithmétiques de base: l'addition, la soustraction, la
multiplication et la division.
38
 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 Od,Os: additionne l'opérande source et l'opérande
destination et met le résultat dans l'opérande destination
[OdOd+Os].
ADD R1 , R2 R1  R1 + R2
ADDITION
39
ADD R , [adr] R1  R + [adr]
ADD [adr] , R [adr]  [adr] + R
ADD R , im R  R + im
ADD taille [adr] , im [adr]  [adr] + im
ADD [adr], [adr]

 INC Op: incrémente l'opérande Op [Op Op+1].
INC R R  R+1
INC taille [adr] Incrémenter le contenu d’une case mémoire
ADDITION
40
 Exemple: 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]
INC WORD ptr [400h]
FEh
33h
DS: 400
DS: 401

ADDITION
 Exemple: FEh
33h
DS: 400
INC BYTE ptr [400h]
FFh
DS: 400
41
FFh
33h
DS: 400
00
34h
DS: 400
INC WORD ptr [400h]
Bits de poids faible
Bits de poids fort

Exercice
org 100h
mov [400h],0xFFh
mov [401h],33h
mov [402h], 0xFFh
;Mov word ptr [400h], 33FFh
mov [402h], 0xFFh
mov [403h], 33
INC BYTE ptr [400h]
INC WORD ptr [402h]
ret

Exercice
org 100h
mov al,-3
titi: inc al
JZ fin
JZ fin
JNZ titi
fin: ret

 SUB Od,Os: soustrait l'opérande source et l'opérande
destination et met le résultat dans l'opérande destination
[OdOd-Os].
SUB R1 , R2 R1  R1 - R2
MULTIPLICATION
42
SUB R , [adr] R  R - [adr]
SUB [adr] , R [adr]  [adr] – R
SUB R , im R  R - im
SUB taille [adr] , im [adr]  [adr] - im
SUB [adr], [adr]

 DEC Op: décrémente l'opérande Op [Op Op-1].
DEC R R  R-1
DEC taille [adr] [adr]  [adr] - 1
MULTIPLICATION
43
 NEG Op: Remplace Op par son négatif
[Op0-Op = CA2 (Op)]
NEG R R  CA2(R)
NEG taille [adr] [adr]  CA2 ([adr])

 Exemple:
MOV AX, 26h
MOV CX, AX
0 0 2 6 AX
F F C D CX
Z = 0 ; C = 1 ; S = 1
SUB AX, 59h
MULTIPLICATION
44
MOV AX, 35
NEG AX
Z = 0 ; C = 1 ; S = 1
0 0 2 3 AX
F F D D AX

 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é
SOUSTRACTION
45
O S Z C O S Z C
Od > Os - 0 0 0 0/1 0 0 -
Od = Os - 0 1 0 0 0 1 -
Od < Os - 1 0 1 0/1 1 0 -

Exemple instruction: CMP
Nbr signé, Nbr non signé
org 100h
mov ah,0xFFh 100h
mov dl,1 102h
toto:dec dl 104h
cmp ah,dl 106h
;Nombres non signés ;Nombres signés
JA titi 108h
(JA 10Eh)
JB toto 10Ah
(JB 104h)
JMP toto 10Ch
(JMP 104h)
titi:RET 10Eh
JG titi
JL toto
JMP toto
titi:RET
;Nombres non signés ;Nombres signés

SOUSTRACTION
O S Z C O S Z C
Od > Os - 0 0 0 0/1 0 0 -
Od = Os - 0 1 0 0 0 1 -
46
 Exemple:
MOV AL, 23
CMP AL, 34
? ? 1 7 AX
C = 1 ; Z = 0; S = 1
Od = Os - 0 1 0 0 0 1 -
Od < Os - 1 0 1 0/1 1 0 -
AL
AH

 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
MULTIPLICATION
47
extension (AH ou DX).
 IMUL Os : identique à MUL excepté qu'une
multiplication signée est effectuée.

MULTIPLICATION
(I) MUL Reg8 AX  AL * Reg8
(I) MUL BYTE [adr] AX  AL * [adr]
(I) MUL Reg16 DX:AX  AX * Reg16
48
(I) MUL Reg16 DX:AX  AX * Reg16
(I) MUL WORD [adr] DX:AX  AX * [adr]
(I) MUL im

MULTIPLICATION
 Exemple:
MOV AL, 4
MOV AH, 25
? ? 0 4 AX
AL
AH
1 9 0 4
49
MUL AH
MOV BX, 435
MOV AX, 2372
MUL BX
0 0 6 4
0 1 B 3
0 0 0 F
0 9 4 4
B E 8 C
BX
AX
AX
DX

MULTIPLICATION
 Exemple:
MOV BX, 435
MOV AX, 2372
MUL BX
0 1 B 3
0 0 0 F
0 9 4 4
B E 8 C
BX
AX
AX
DX
50
MOV BX, -435
MOV AX, 2372
IMUL BX
F E 4 D
F F F 0
0 9 4 4
4 1 7 4
BX
AX
AX
DX
AX
DX

• Ecrire un programme en assembleur 8086 qui
calcul de factoriel de 5. Enregistrer le résultat
dans l’@ D000h
org 100h
MOV AL, 05H
MOV AL, 05H
MOV CL, 05h-1h
Back: MUL CL
LOOP back
MOV [0xD000], AL
ret

 DIV Os: effectue une division non signée de
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
DIVISION
51
registre AH ou DX.
 IDIV Os : identique à DIV excepté qu'une division signée
est effectuée.

DIVISION
(I) DIV Reg8
(I) DIV BYTE [adr]
AL  Quotient
AH Reste
(I) DIV Reg16 AX  Quotient
52
(I) DIV Reg16
(I) DIV WORD [adr]
AX  Quotient
DX Reste
(I) DIV im

 Exemple:
MOV BX, 435
MOV AX, 2372
DIV BX
0 1 B 3
0 0 C 5
0 9 4 4
0 0 0 5
BX
AX
DIVISION
53
DIV BX
MOV BX, -435
MOV AX, 2372
IDIV BX
0 0 C 5 0 0 0 5
AX (Quotient)
DX (Reste)
F E 4 D
0 0 C 5
0 9 4 4
F F F B
BX
AX
AX (Quotient)
DX (Reste)

 CBW (Convert Byte to Word) 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
DIVISION
54
 Si AL contient un nombre négatif,on complète par des 1 pour
obtenir la représentation sur 16 bits.
 Exemple:
MOV AL, 96
CBW
AX
AL
AH
0 0 6 0
? ? 6 0

DIVISION
 CWD (Convert Word to Double Word) effectue une
extension de AX dans DX en respectant le signe.
 Exemple:
MOV AX, 96
AX
? ? ? ? 0 0 6 0
DX
55
CWD
MOV AX, -96
CWD
0 0 0 0 0 0 6 0
0 0 6 0
AX
F F F F
? ? ? ?
F F A 0
F F A 0
DX

INSTRUCTIONS LOGIQUES
NÉGATION
 NOT OP transforme la valeur de l’opérande (registre ou
mot mémoire) en son complément à 1 [OPCA1(OP)].
 Exemple: AX
56
MOV AX, 96
NOT AX
AX
0 0 6 0
F F 9 F

 AND Od, Os effectue un ET logique entre Od et Os.
[Od  Od  Os]
AND R1 , R2 R1  R1  R2
AND R , [adr] R1  R  [adr]
ET LOGIQUE
57
AND [adr] , R [adr]  [adr]  R
AND R , im R  R  im
AND taille [adr] , im [adr]  [adr]  im
AND [adr], [adr]

0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1
 Exemple:
MOV AX , 503h
AND AX , 0201h
AX
ET LOGIQUE
58
0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0201h
AX

 OR Od, Os effectue un OU logique entre Od et Os.
[Od  Od  Os]
OR R1 , R2 R1  R1  R2
OR R , [adr] R1  R  [adr]
OU LOGIQUE
60
OR [adr] , R [adr]  [adr]  R
OR R , im R  R  im
OR taille [adr] , im [adr]  [adr]  im
OR [adr], [adr]

OU LOGIQUE
0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1
 Exemple:
MOV AX , 503h
OR AX , 0201h
AX
61
0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1
0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1
0201h
AX

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
Exercices
• 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.

INSTRUCTIONS LOGIQUES ET LOGIQUE
 TEST Od, Os: similaire à AND mais ne retourne pas
de résultat dans Od, seuls les indicateurs sont
positionnés.
 Exemple:
59
0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1
0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
MOV AX , 503h
TEST AX , 0201h
AX
0201h
RT
S = 0, Z = 0

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

 XOR Od, Os effectue un OU exclusif (XOR) entre Od et
Os [Od  Od  Os].
XOR R1 , R2 R1  R1  R2
XOR R , [adr] R1 R  [adr]
ou EX
ou EXCLUSIF
CLUSIF
XOR R , [adr] R1  R  [adr]
XOR [adr] , R [adr]  [adr]  R
XOR R , im R  R  im
XOR taille [adr] , im [adr]  [adr]  im
XOR [adr], [adr]
62

ou EX
ou EXCLUSIF
CLUSIF
0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1
 Exemple:
MOV AX , 503h
XOR AX , 0201h
AX
 Exercice 1 (Premier programme): Écrire un programme
63
qui fait AX  BX sans utiliser l’instruction XOR
0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1
0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0
0201h
AX

INSTRUCTIONS DE DÉCALAGE
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)
64
Od = registre ou adresse mémoire
n=1 ou CL

DÉCALAGE LINÉAIRE GAUCHE/DROIT
 SHL Od, n et SAL Od, n ont le même comportement.
. . . . . .
MSB LSB
C
0 . . . 0
n zéros
65
 SHR Od, n
. . . . . .
MSB LSB C
0 . . . 0
n zéros

DÉCALAGE LINÉAIRE DROIT
 SHR Od, n
de signe  SHR
. . . . . .
MSB
tient pas compte du bit
LSB C
0 . . . 0
n zéros
 SHR ne
travaille avec les nombres non signés.
 SAR préserve le bit de signe  SAR est réservée au6
x
6
nombres signés.
travaille avec les nombres non signés.
 SAR Od, n
. . . . . .
LSB C
n fois

DÉCALAGE CIRCULAIRE GAUCHE/DROIT
 ROL Od, n
. . . . . .
C
 ROR Od, n
. . . . . .
C
67

DÉCALAGE CIRCULAIRE À TRAVERS LA RETENUE
 RCL Od, n
. . . . . .
C
68
 RCR Od, n
. . . . . . C

DÉCALAGE CIRCULAIRE À TRAVERS LA RETENUE
 Exemple:
MOV AL, 11001011B
SHR AL, 1
1 1 0 0 1 0 1 1
0 1 1 0 0 1 0 1 1
x
AL C
C
AL
69
MOV AL, 11001011B
ROR AL, 1
MOV AL, 11001011B
RCR AL, 1
1 1 0 0 1 0 1 1
1 1 1 0 0 1 0 1 1
x
C
AL
1 1 0 0 1 0 1 1
x 1 1 0 0 1 0 1 1
x
C
AL

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

Les instructions 8086_288888888_1_2021.pdf

Soit le programme suivant
en langage 8086:
org 100h
; multiply ax by 10
~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 ?

Multiply ax by 10
org 100h
….
; multiply ax by 10
SHL AX,1
;AX2 AX
MOV BX,AX
MOV BX,AX
;BX2 AX
SHL AX,2
;AX8 AX
ADD AX,BX
;AX10 AX
….
ret

Soit le programme suivant
en langage 8086:
org 100h
Mov ax,3
; multiply ax by 12
SHL AX,2 ;Ax 4AX
SHL AX,2 ;Ax 4AX
MOV BX,AX
SHL AX, 1 ;Ax 8AX
ADDAX,BX
ret

INSTRUCTIONS DE BRANCHEMENT
 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
70
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 3 types d’instructions:
 Branchement inconditionnel: JMP
Contrôle de Boucle : LOOPX
71
 Contrôle de Boucle : LOOPX
 Branchement conditionnel: Jcondition

INCONDITIONNEL
 JMP label: effectue un saut (jump) vers le label spécifié.
.
.
.
Etiq: .
.
.
.
JMP suite
72
Etiq: .
.
.
.
JMP Etiq
.
.
JMP suite
.
.
.
Suite: .....................
.
.

Exercice JMP
org 100h
mov ax, 5 ; set ax to 5.
mov bx, 2 ; set bx to 2.
jmp calc ; go to 'calc'.
INCONDITIONNEL
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.
72

DE CONTRÔLE DE BOUCLE
 LOOP Label: fonctionne automatiquement avec le
registre CX (compteur). Quant le processeur rencontre
une instruction LOOP, il décrémente le registre CX. Si le
résultat n'est pas encore nul, il reboucle à la ligne portant
73
l'étiquette label, sinon il continue le programme à la ligne
suivante MOV CX, 10
ici: .....
.....
.....
LOOP ici
......
S’exécute 10 fois

 Exemple: Que fait ce programme?
MOV DX, 0
MOV CX, 5
ETIQ: MOV BX, CX
ETIQ: MOV BX, CX
ADD DL, [BX+1100]
LOOP ETIQ
Additionne les 5 valeurs se trouvant à l’adresse 1101-1105
74

Instructions Actions
1. Mise à jours de CX 2. Branchement si:
LOOP CXCX-1 CX=0
LOOP CXCX-1 CX=0
LOOPZ, LOOPZ CXCX-1 (CX = 0 ) et (Z=1)
LOOPNZ, LOOPNE CXCX-1 (CX = 0 ) et (Z=0)
JCXZ Pas d’action
CX = 0
75

CONDITIONNEL
 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)
76
 La condition du saut porte sur l’état de l’un (ou plusieurs)
des indicateurs d’état (ﬂags) 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
7
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 7
Saut si P = 0

CONDITIONNEL
 Branchements (sauts) arithmétiques: suivent en
général l’instruction de comparaison : CMP A,B
Condition Nombres signés Nombres non signés
A = B JE
8
A = B JE
A  B JNE
A > B JG JA
A  B JGE JAE
A < B JL JB
A  B JLE JBE 7

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
MOV DX, CX
MOV BL, 0
Etq3: INC SI
DEC DX
JNZ Etq2
MOV BL, 0
Etq2: MOV AL, [SI]
CMP AL, [SI+1]
JBE Etq3
XCHG AL, [SI+1]
MOV [SI], AL
INC BL
JNZ Etq2
CMP BL, 0
JZ Fin
DEC CX
JNZ Etq1
Fin: ret

Les instructions 8086_288888888_1_2021.pdf

Contenu connexe

Similaire à Les instructions 8086_288888888_1_2021.pdf (20)

Les instructions 8086_288888888_1_2021.pdf