Chapitreiiiprocesseurintel80x86 140116154821 Phpapp02 PDF

Université Saad Dahleb de Blida
Faculté des Sciences

Département d’Informatique
Licence Génie des Systèmes Informatique (GSI)
Semestre 3 (2ème année)
CHAPITRE III
PROCESSEUR INTEL 80X86
AROUSSI
2013 - 2014
Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/

OBJECTIFS DU CHAPITRE
 Présenter le Processeur 8086 de Intel
 Étudier son jeux d'instruction.
 Apprendre à le programmer en assembleur pour
comprendre son fonctionnement.
 Coder les instructions en langage machine (binaire).
2
PLAN DU CHAPITRE III
 Introduction
 Architecture Générale
 Jeu d’instructions
 Programmation en Assembleur
 Code Machine des Instructions
3
INTRODUCTION
ÉVOLUTION DES PROCESSEURS INTEL
Processeurs multi-cœurs:
Core 2, i5, i7, .....
Pentium: I, II, III,
IV, V, ... 2006
Processeurs 80x : 8080,
jusqu’à
8086, 8080, 80286, 80386, 1993-2005 aujourd’hui
80486, ......
1972 – 1992
Premier processeur
4004
1971
La majorité des microprocesseurs

4
Intel sont compatibles avec le 8086

INTRODUCTION
PROCESSEUR INTEL 8086
 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.
5
PARTIE 1:
ARCHITECTURE GÉNÉRALE DU
PROCESSEUR 8086
6
AX AH AL Bus d’adresse Interne 20 bits
BX 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
Flags Architecture Générale du processeur 8086

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.
 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é
8
registre offset: IP, SP, BP, SI, DI.
 Une adresse se présente sous la forme segment:offset
REGISTRES
 Tous les registres du 8086 sont structurés en 16 bits.
9
REGISTRES GÉNÉRAUX
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 10
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

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

d'index Adressage comme registre d’index de l'opérande
11
(destination) destination
REGISTRES DE SEGMENT
 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.
12
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 13
COMPTEUR D’INSTRUCTION
 Le compteur d’instruction (IP), appelé aussi Compteur

Ordinal (C.O.) permet de pointer TOUJOURS le premier
octet de l’instruction suivante.
14
REGISTRE D'ÉTAT (FLAGS)
15 0
O D I T S Z A P C
 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.
 Z (Zéro) : indique que le résultat est nul.
 S (Signe) : indique le signe du résultat

15
 O (Overflow): indique un dépassement de capacité
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

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. 16
MODE D’ADRESSAGE
1. Adressage registre
 L'opération se fait sur un ou 2 registres
INST R , R
INST R
 Exemples :
 INC AX : incrémenter le registre AX (AX++)
 MOV AX, BX : Copier le contenu de BX dans AX

(AXBX)
17
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)
18
 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

19
‘A' et AL par le code ASCII du caractère ‘B‘ (66)

MODE D’ADRESSAGE
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 , [adr]
INST [adr] , R
INST taille [adr] , im
 L’adresse doit être placée entre [Rseg:Roff]. Si le segment

20
(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
 Exemples :
 MOV AX,[243] : Copier le contenu de la mémoire d'adresse

DS:243 dans AX
 MOV [123],AX : Copier le contenu de AX dans la mémoire

d'adresse DS:123
21
 MOV AX, [SS:243] : Copier le contenu de la mémoire SS:243
dans AX
MODE D’ADRESSAGE
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 : Roff]
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 22
Segment par défaut DS SS DS DS

MODE D’ADRESSAGE
 Exemples :
 MOV AX, [BX]; Charger AX par le contenu de la mémoire d'adresse

DS:BX
 MOV AX, [BP]; Charger AX par le contenu de la mémoire d'adresse

SS:BP
 MOV AX, [SI]; Charger AX par le contenu de la mémoire d'adresse

DS:SI
 MOV AX, [DI] ; Charger AX par le contenu de la mémoire d'adresse

DS:DI
23
 MOV AX, [ES:BP]; Charger AX par le contenu de 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é.
Mode Adressage Basé Indexé Basé Indexé
Registres utilisés BX DI BX, DI

BP SI BX, SI
BP, DI
24
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é
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

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

DS:BX+5
 MOV AX, [BP-200] : Charger AX par le contenu de la mémoire d'adresse

SS:BX-200
 MOV AX, [ES:BP] : Charger AX par le contenu de la mémoire d'adresse

26
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
contenu de Ri pour déterminer l’offset.
INST R , [Rseg : Ri+dep]
INST [Rseg : Ri+dep] , R
INST taille [Rseg : Ri+dep] , im

27
MODE D’ADRESSAGE
B. Adressage Indexé
 Exemples :
 MOV AX, [SI]; Charger AX par le contenu de la mémoire

d'adresse DS:SI
 MOV AX, [SI+500]; Charger AX par la mémoire d'adresse

DS:SI+500
 MOV AX, [DI-8]; Charger AX par la mémoire d'adresse DS:DI-8
 MOV AX, [ES:SI+4]; Charger AX par la mémoire d'adresse

28
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
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

29
INST taille [Rseg : Rb+Ri+dep] , im
MODE D’ADRESSAGE
C. Adressage Basé Indexé
 Exemples :
 MOV AX,[BX+SI]; AX est chargé par la mémoire d'adresse

DS:BX+SI
 MOV AX,[BX+DI+5]; AX est chargé par la mémoire d'adresse

DS:BX+DI+5
 MOV AX,[BP+SI-8]; AX est chargé par la mémoire d'adresse

SS:BP+SI-8
30
 MOV AX,[BP+DI]; AX est chargé par la mémoire d'adresse
SS:BP+DI
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:
 Si le registre est un registre simple (8 bits), l’opération

se fera avec une seule case mémoire.
31
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:
 Si le registre est un registre double (2 octets),

l’opération se fera avec deux cases mémoires
MOV [adresse], AX donne 
32
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
 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] 36
MOV Rseg, Rseg

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

XCHG R , [adr]
XCHG [adr], [adr]
37
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.

38
ADDITION
 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
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
39
ADD [adr], [adr]
ADDITION
 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

taille = BYTE ou WORD
 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
DS: 400 FE 40
INC BYTE [400h]
33
INC WORD [400h]
ADDITION
 Exemple: DS: 400 FE
33
INC BYTE [400h]
DS: 400 FF
33
INC WORD [400h]
DS: 400 00 Bits de poids faible

34 Bits de poids fort
41
SOUSTRACTION
 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
SUB R , [adr] R1  R - [adr]
SUB [adr] , R [adr]  [adr] – R
SUB R , im R  R - im
SUB taille [adr] , im [adr]  [adr] - im
42
SUB [adr], [adr]
SOUSTRACTION
 DEC Op: décrémente l'opérande Op [Op Op-1].
DEC R R  R-1
DEC taille [adr] [adr]  [adr] - 1
 NEG Op: Remplace Op par son négatif
[Op0-Op = CA2 (Op)]
NEG R R  CA2(R)
43
NEG taille [adr] [adr]  CA2 ([adr])
SOUSTRACTION
 Exemple:
MOV AX, 26h 0 0 2 6 AX
SUB CX 59h F F C D CX
Z=0;C=1;S=1
MOV AX, 35 0 0 2 3 AX
NEG AX F F D D AX
44
SOUSTRACTION
 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é
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 -
45
Od < Os - 1 0 1 0/1 1 0 -
SOUSTRACTION
Opérandes non Signés Opérandes Signé
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 -
AH AL
 Exemple:
? ? 1 7 AX
MOV AL, 23 46
CMP AL, 34 C = 1 ; Z = 0; S = 1
MULTIPLICATION
 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.
47
MULTIPLICATION
(I) MUL Reg8 AX  AL * Reg8
(I) MUL BYTE [adr] AX  AL * [adr]
(I) MUL Reg16 DX:AX  AX * Reg16
(I) MUL WORD [adr] DX:AX  AX * [adr]
(I) MUL im
48
MULTIPLICATION
 Exemple:
AH AL
MOV AL, 4 ? ? 0 4 AX
MOV AH, 25 1 9 0 4
MUL AH 0 0 6 4
MOV BX, 435 0 1 B 3 BX
0 9 4 4 AX
MOV AX, 2372
49
MUL BX 0 0 0 F B E 8 C
DX AX
MULTIPLICATION
 Exemple:
MOV BX, 435 0 1 B 3 BX
0 9 4 4 AX
MOV AX, 2372
MUL BX 0 0 0 F B E 8 C
DX AX
MOV BX, -435 F E 4 D BX
0 9 4 4 AX
MOV AX, 2372
IMUL BX F F F 0 4 1 7 4
50
DX AX
DIVISION
 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
registre AH ou DX.
 IDIV Os : identique à DIV excepté qu'une division signée
est effectuée.
51
DIVISION
(I) DIV Reg8 AL  Quotient

(I) DIV BYTE [adr] AH Reste
(I) DIV Reg16 AX  Quotient

(I) DIV WORD [adr] DX Reste
(I) DIV im
52
DIVISION
 Exemple:
MOV BX, 435 0 1 B 3 BX
0 9 4 4 AX
MOV AX, 2372
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
DIV BX 0 0 C 5 F F F B 53
DX (Reste) AX (Quotient)
DIVISION
 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

obtenir la représentation sur 16 bits.
 Exemple: AH AL
MOV AL, 96 AX
? ? 6 0
CBW 0 0 6 0
54
DIVISION
 CWD (Convert Word to Double Word) effectue une
extension de AX dans DX en respectant le signe.
 Exemple: DX AX
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
55
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
MOV AX, 96 0 0 6 0
NOT AX F F 9 F
56
ET LOGIQUE
 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]
AND [adr] , R [adr]  [adr]  R
AND R , im R  R  im
AND taille [adr] , im [adr]  [adr]  im
AND [adr], [adr]

57
ET LOGIQUE
 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
58
ET LOGIQUE
 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
59
RT 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
S = 0, Z = 0
OU LOGIQUE
 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]
OR [adr] , R [adr]  [adr]  R
OR R , im R  R  im
OR taille [adr] , im [adr]  [adr]  im
OR [adr], [adr]
60
OU LOGIQUE
 Exemple:
MOV AX , 503h
OR 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 1 1 1 0 0 0 0 0 0 1 1
61
OU EXCLUSIF
 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]
XOR [adr] , R [adr]  [adr]  R
XOR R , im R  R  im
XOR taille [adr] , im [adr]  [adr]  im
XOR [adr], [adr]

62
OU EXCLUSIF
 Exemple:
MOV AX , 503h
OR 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 1 1 1 0 0 0 0 0 0 1 0
 Exercice 1 (Premier programme): Écrire un programme

63
qui fait AX  BX sans utiliser l’instruction XOR
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.
... ... 0 ... 0

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

n zéros MSB LSB C
65
DÉCALAGE LINÉAIRE DROIT
 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
LSB C
 SAR préserve le bit de signe  SAR est réservée aux
66
nombres signés.
DÉCALAGE CIRCULAIRE GAUCHE/DROIT
 ROL Od, n
... ...
C
 ROR Od, n
... ...
C
67
DÉCALAGE CIRCULAIRE À TRAVERS LA RETENUE
 RCL Od, n
C ... ...
 RCR Od, n
... ... C
68
DÉCALAGE CIRCULAIRE À TRAVERS LA RETENUE
 Exemple:
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
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

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. 70
 On distingue 3 types d’instructions:
 Branchement inconditionnel: JMP
 Contrôle de Boucle : LOOPX
 Branchement conditionnel: Jcondition
71
INCONDITIONNEL
 JMP label: effectue un saut (jump) vers le label spécifié.
. .
. .
. .
JMP suite Etiq: .
. .
. .
. .
Suite: ..................... JMP Etiq
. .
. .
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
l'étiquette label, sinon il continue le programme à la ligne
suivante MOV CX, 10
ici: .....
..... S’exécute 10 fois
.....
LOOP ici 73
......
 Exemple: Que fait ce programme?
MOV DX, 0
MOV CX, 5
ETIQ: MOV BX, CX
MOV DL, [BX+1100]
LOOP ETIQ
Addition les 5 valeurs se trouvant à l’adresse 1101-1105

74
Instruction Actions
1. Mise à jours de CX 2. Branchement si:
LOOP CXCX-1 CX  0
LOOPZ, LOOPE 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)

des indicateurs d’état (flags) du microprocesseur qui sont
positionnés en fonction du résultat de la dernière
opération.
76
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

77
JNP Jump if Not Parity 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
AB JNE
A>B JG JA
AB JGE JAE
A<B JL JB
AB JLE JBE 78
PARTIE 3:
PROGRAMMATION EN ASSEMBLEUR
8086
79
ÉTAPES DE LA RÉALISATION D’UN PROGRAMME
1. Définir le problème à résoudre : que faut-il faire
exactement ?
2. Déterminer des algorithmes: comment faire ? Par

quoi commencer, puis poursuivre ?
3. Rédiger le programme (code source) en utilisant le

jeu d’instructions (mnémoniques) ;
4. Tester le programme en réel ;
5. Corriger les erreurs (bugs) éventuelles : déboguer le

programme puis refaire des tests jusqu’à obtention d’un
80
programme fonctionnant de manière satisfaisante.

DÉFINITION D’UN ASSEMBLEUR
 Assembleur : logiciel de traduction du code source écrit
en mnémoniques (jeu d’instructions) au langage machine
(codes binaires correspondant aux instructions).
81
ÉTAPES DE LA RÉALISATION PRATIQUE
1. Saisir le code source avec
un éditeur de texte.
2. Compiler le code source
pour obtenir le code objet.
3. Éditer les liens pour avoir

82
un programme exécutable;
ÉTAPES DE LA RÉALISATION PRATIQUE
 Plusieurs logiciels
permettent le passage entre
ces trois phases présentée
comme:
 MASM (Microsoft Assembl

er : avec LINK comme
éditeur de lien),
 TASM (Turbo assembler :

avec TLINK comme éditeur
de lien) et
83
 NASM, etc ...
POURQUOI?
 Quelques fois, le code écrit en assembleur peut être plus rapide et
plus compact que le code généré par un compilateur.
 L'assembleur permet l'accès à des fonctionnalités matérielles du
système directement qu'il pourrait être difficile ou impossible à
utiliser depuis un langage de plus haut niveau (C, C++, C #, Java,).
 Acquérir une compréhension plus profonde de la façon dont
fonctionne un ordinateur (par exemple, comment les compilateurs et
les langage de haut niveau fonctionnent) 84

FICHIER SOURCE
 Comme tout programme, un programme écrit en assembleur

(programme source) comprend des définitions de données et des
instructions, qui s'écrivent chacune sur une ligne de texte.
85
FICHIER SOURCE
PROGRAM Exemple
Data SEGMENT
; On met les directives de données pour réserver de la mémoire pour les

variables qui seront utilisées dans le programme.
Data ENDS
Code SEGMENT
ASSUME CS : Code, DS: Data
PROG
; mettre les instructions du programme

86
Code ENDS
END PROG
FICHIER SOURCE
 Les données sont déclarées par des directives, mots clefs

spéciaux que comprend l'assembleur (donc ils sont destinés à
l'assembleur.
 Les directives qui déclarent des données sont regroupées dans les
segments de données, qui sont délimités par les directives
SEGMENT et ENDS.
 Déclaration d’une constante: Nom EQU Expression
VAL EQU 50 ; assigner la valeur 50 au nom VAL
ET1 EQU VAL* 5 + 1 ; assigner une expression calculer à VAL
87
FICHIER SOURCE
 Déclaration des variables
 DB (Define Byte): définit une variable de 8 bits, c-à-d elle

réserve un espace mémoire d'un octet. Donc, les valeurs de telle
variable sont comprises entre 0 et 255 (pour les nombres non
signés ) et de -128 jusqu'à 127 pour les nombres signés .
Nom DB Expression
X DB 8H ; Définir une variable nommée X sur un octet de valeur

initiale (8)16
Y DB ? ; Définir une variable nommée Y sur un octet de valeur

initiale quelconque (autrement dit, la variable n’est pas 88
n’intialisée)
FICHIER SOURCE
 Déclaration des variables
 DW (Define Word): définit une variable de 16 bits, c-à-d elle

réserve un espace mémoire de deux octets. Donc, les valeurs de
telle variable sont comprises entre 0 et 65535 (pour les nombres
non signés) et de -32768 jusqu'à 32767 pour les nombres signés .
Nom DW Expression
X DW 458H ; Définir une variable nommée X sur deux octets de

valeur initiale (458)16
Y DW ? ; Définir une variable nommée Y sur 2 octets de valeur

initiale quelconque 89
FICHIER SOURCE
 Déclaration des tableaux
T1 DW 10,12,14,5,8 ; réserve un tableau de 5 cases, chaque

case est sur un octet tel que 10 12 14 5 8
T2 DW 10,1200,140 ; réserve un tableau de 3 cases, chaque

case est sur deux octets tel que 10 1200 140
Mess DB 'ISET' ; réserve un tableau de 4 cases, chaque case est

sur un octet et contient le code ASCII du caractère tel que:
‘I’ ‘S’ ‘E’ ‘T’
 Directive DUP: utilisée pour déclarer un tableau de n cases,

toutes initialisées à la même valeur. 90
FICHIER SOURCE
 Déclaration des tableaux
 Directive DUP: utilisée pour déclarer un tableau de n cases,

toutes initialisées à la même valeur.
T3 DB 100 DUP (15) ; tableau de 100 cases (octets) valant 15
T4 DW 10 DUP (?) ; 10 cases de 16 bits non initialisés
91
FICHIER SOURCE
 Les instructions sont placées dans le segment de code.
Code SEGMENT ; Sert à déclarer le début segment code. On aurait

aussi bien pu choisir un autre nom que Code
ASSUME CS : Code, DS: Data ; Permet d'indiquer à l'assembleur le

nom du segment de données et de code
PROG; La première instruction du programme doit toujours être repérée

par une étiquette (dans notre cas : PROG).
; mettre les instructions du programme
Code ENDS ; Sert à déclarer la fin du segment code.
END PROG ; Permet d'indiquer à l'éditeur de liens quelle est la première

92
instruction qui a été exécutée lorsque l'on lance le programme

FICHIER SOURCE
 La syntaxe des instruction est comme suit :
{Label :} Mnémonique {opérandes} { ; commentaire}
Champs Description
Label champ optionnel destiné pour marquer une ligne
(étiquette) qui sera la cible d'une instruction de saut ou de
branchement. Il doit se terminer par « : » et ne
peut commencer par un chiffre.
Mnémonique champ obligatoire présente le nom de l’instruction
Opérande champ optionnel selon l'instruction (parfois
l'instruction nécessite deux opérandes, un
opérande et parfois non).
Commentaire champ optionnel sans signification syntaxique et
sémantique mais très intéressant pour la93
programmation
EXERCICE 1
 N1 et N2 sont deux variables de 2 octets chacune
Début
N1 + N2
Non Oui
Résultat > 0
Ranger le résultat Ranger le résultat

dans le mot mémoire dans le mot mémoire
d’adresse 200h d’adresse 100h
94
Fin
EXERCICE 1 (1ÈRE SOLUTION)
PROGRAM Exemple1 MOV [200h], AX
Data1 SEGMENT JMP Fin
N1 DW ? Cond1: MOV [100h], AX
N2 DW ? Fin:
Data1 ENDS Code1 ENDS
Code1 SEGMENT END Debut
ASSUME CS : Code1, DS: Data1
Debut : MOV AX, N1 ; AX  N1
ADD AX, N2 ;AX  N1+ N2

95
CMP AX, 0
JG Cond1
EXERCICE 1 (2ÈME SOLUTION)
PROGRAM Exemple1 JE Cond2
Data1 SEGMENT MOV [100h], AX
N1 DW ? JMP Fin
N2 DW ? Cond2: MOV [200h], AX
Data1 ENDS Fin:
Code1 SEGMENT Code1 ENDS
ASSUME CS : Code1, DS: Data1 END Debut
Debut : MOV AX, N1 ; AX  N1
ADD AX, N2 ;AX  N1+ N2

96
CMP AX, 0
JS Cond1
EXEMPLE DE CODAGE DE TESTS
Langage évolué Assembleur
Jump si la condition est fausse
SI (condition vraie) ALORS Calcul de la condition
Actions_ALORS JNCond FSI
Actions-ALORS
FSI
FSI:
Suite_programme
Suite_Programme 97
1ère version 2ème version

Jump si la condition est Jump si la condition est
fausse vraie
SI (condition vraie) Calcul de la condition Calcul de la condition

ALORS JNCond SINON JCond SI
actions_ALORS Actions-ALORS Actions-SINON

JMP FSI JMP FSI
SINON
SINON: SI:
Actions_SINON
Actions-SINON Actions-ALORS
FSI FSI: FSI:
98
Suite_programme Suite_Programme Suite_Programme
Jump si CX  0
Pour i  1 à n FAIRE MOV CX, n
Actions-POUR POUR:
Actions-POUR
FP
LOOP POUR
Suite_programme
Suite_Programme 99
TANT-QUE (condition)FAIRE TQ: Calcul de la condition
Actions-TQ JNCond FTQ
Actions-TQ
FTQ
JUMP TQ
Suite_programme
FTQ: Suite_Programme 100
REPETER REPERTER:
Actions-REPETER Actions-REPETER
Calcul de la condition
JUSQUA (condition vraie)
JNCond REPETER
Suite_programme
Suite_Programme 101
EXERCICE 2
 Écrire la suite d’instructions pour réaliser les étapes

suivantes :
1. Copier le contenu de la case mémoire [1230h] dans

CX
2. Comparer CX à 200
a. si < incrémenter CX et recommencer au point 2
b. si > décrémenter CX et recommencer au point 2
c. si = copier CX dans AX et continuer le programme

102
ACCÈS AUX ÉLÉMENTS D’UN TABLEAU
 L’adresse du premier octet du tableau est récupérée à

l’aide de la directive offset.
 Exemple:
 TAB DW 15, 17, 80
 MOV BX, TAB; BX contient la valeur 15
 MOV BX, offset TAB; BX contient l’adresse du

premier octet du TAB
 Pour accéder à un élément d'un tableau, son adresse doit

103
être calculée.
 Exercice 3: Écrire un programme qui initialise un
tableau avec 32 éléments (0, 3, 9, 12, ......, 91) dans les
deux cas suivants
 Cas 1: Les éléments sont sur un octet
 Cas 2: Les éléments sont sur deux octets
104
TRAITEMENT DES CHAÎNES DE DONNÉES
LODSB/W Chargement d’un élément de chaîne depuis la mémoire

dans un registre
STOSB/W Écriture d’un élément de chaîne en mémoire
MOVSB/W Transfert d’un élément entre deux chaînes
SCASB/W Comparaison entre une valeur et un élément de chaîne
CMPSB/W Comparaison entre deux éléments de chaîne
 Un élément de la chaîne peut être soit un octet

105
(caractère) [B] ou un mot [W].
 Une chaîne peut atteindre 128K octets;
 La chaîne Source est référencée par DS:SI;
 La chaîne Destination est référencée par ES:DI;
 L’indicateur D indique le sens de l’accès aux éléments de

la chaîne;
 D=1 ⇒ Droite à Gauche (Fin au Début)
 D=0 ⇒ Gauche à Droite (Début à la Fin ),
 Le bit D est positionné par les instructions STD et CLD.

106
 LODSB/W: Chargement d’un élément de chaîne depuis

la mémoire dans un registre
D=0 D=1
LODSB MOV AL, [DS:SI] MOV AL, [DS:SI]
INC SI DEC SI
LODSW MOV AX, [DS:SI] MOV AX, [DS:SI]

107
ADD SI, 2 SUB SI, 2
 STOSB/W: Écriture d’un élément de chaîne en mémoire
D=0 D=1
STOSB MOV [ES:DI], AL MOV [ES:DI], AL
INC DI DEC DI
STOSW MOV [ES:DI], AX MOV [ES:DI], AX
ADD DI, 2 SUB DI, 2 108

 MOVSB/W: transfert un élément de la chaîne source (DS:SI)
vers une élément de la chaîne destination (ES:DI).
D=0 D=1
MOVSB MOV R, [DS:SI] MOV R, [DS:SI]

MOV [ES:DI], R MOV [ES:DI], R
INC SI DEC SI
INC DI DEC DI
MOVSW MOV R, [DS:SI] MOV R, [DS:SI]

MOV [ES:DI], R MOV [ES:DI], R
109
ADD SI, 2 SUB SI, 2
ADD DI, 2 SUB DI, 2
 SCASB/W: Comparaison entre une valeur et un élément

de chaîne
D=0 D=1
SCASB CMP [ES: DI], AL CMP [ES: DI], AL
INC DI DEC DI
SCASW CMP [ES: DI], AX CMP [ES: DI], AX
ADD DI, 2 SUB DI, 2 110

 CMPSB/W: compare un élément de la chaîne source (DS:SI)
avec une élément de la chaîne destination (ES:DI).
D=0 D=1
CMPSB MOV R, [DS:SI] MOV R, [DS:SI]

CMP [ES:DI], R CMP [ES:DI], R
INC SI DEC SI
INC DI DEC DI
CMPSW MOV R, [DS:SI] MOV R, [DS:SI]

CMP [ES:DI], R CMP [ES:DI], R
111
ADD SI, 2 SUB SI, 2
ADD DI, 2 SUB DI, 2
 Les indicateurs de FLAGS ne sont pas modifiés par les

opérations (incrémentation et décrémentation) modifiant
la valeur des index (SI, DI) qui se font automatiquement
dans les instructions de traitement de chaines de
caractères. Donc, on ne peut pas utiliser les instructions
de branchement après ces instructions pour détecter la
fin des chaînes.
D=1
STOSB MOV [ES:DI], AL 112
JE DEC DI
JE
 REP, REPE, REPNE permettent de répéter une
instruction de traitement de chaînes de données. Le
registre CX indique le nombre d’itérations à effectuer.
 REP ne peut préfixer que les instructions LODS, STOS,
MOVS.
 REPE et REPNE ne peuvent préfixer que les

113
instructions CMPS et SCAS.
 REP LODSB, REP LODSW, REP STOSB, REP
STOSW, REP MOVSB, REP MOVSW: à chaque
itération, les actions suivantes sont exécutées :
1. Tester le compteur (CX). S’il est à zéro, aller à 2, sinon:
a. Exécuter l’opération sur la chaîne (LODS, STOS ou MOVS)
b. Décrémenter le compteur CX
114
2. Continuer l’exécution du programme
 REPE SCAS compare au plus CX éléments de la chaîne
pointée par ES:DI avec la valeur du registre AL ou AX
selon le cas. Les itérations sont poursuivies tant que les
éléments de la chaîne sont égaux à la valeur du
registre et tant que le compteur n’est pas nul. Dès
que l’une de ces conditions n’est plus vérifiée,
l’instruction REPE SCAS est terminée 115

 REPE CMPS compare au plus CX éléments de la chaîne
pointée par ES:DI avec ceux de la chaîne pointée par DS:
SI. Les itérations sont poursuivies tant que les
éléments des deux chaînes sont égaux et tant que le
compteur n’est pas nul. Dès que l’une de ces
conditions n’est plus vérifiée, l’instruction REPE CMPS
est terminée 116

 REPNE SCAS compare au plus CX éléments de la
chaîne pointée par ES:DI avec la valeur du registre AL
ou AX selon le cas. Les itérations sont poursuivies tant
que les éléments de la chaîne sont différents à la
valeur du registre et tant que le compteur n’est pas
nul. Dès que l’une de ces conditions n’est plus vérifiée,
l’instruction REPE SCAS est terminée 117

 REPNE CMPS compare au plus CX éléments de la
chaîne pointée par ES:DI avec ceux de la chaîne pointée
par DS: SI. Les itérations sont poursuivies tant que les
éléments des deux chaînes sont différents et tant
que le compteur n’est pas nul. Dès que l’une de ces
conditions n’est plus vérifiée, l’instruction REPE CMPS
est terminée 118

 Exemple: Copie d’un tableau de caractères dans un autre.
Data Segment
CH DB ‘hello word’ ; chaîne source
RES DB 11 DUP(?) ;chaîne destinataire
Date Ends
Code Segment
Assume CS: Code, DS: Date
Debut: LEA DI, RES ; MOV DI, offset RES
LEA SI, CH ; MOV SI, offset CH
MOV CX, 11 ; longueur de la chaîne
REP MOVSB ; copie
119
Code Ends
End Debut
 Exemple: Recherche d’un caractère dans une chaîne de
caractères
Data Segment
CH DB ‘hello word’
Date Ends
Code Segment
Assume CS: Code, DS: Date
Debut: MOV AL, ’w’
LEA DI, CH
MOV CX, 11
REPNE SCASB
120
Code Ends
End Debut
ENTRÉES / SORTIES
 Pour faire des entrées/sorties (essentiellement avec
l’écran et le clavier), on passe par des interruptions (des
sous-programmes préexistants dans la machine) du
BIOS, la plus importante est l’interruption 21h.
 L’appel se fait via l’instruction INT 21h.
 Le registre AH contient le numéro de la fonction qu’on

121
veut utiliser.
ENTRÉES / SORTIES
Instructions Fonctionnalité
MOV AH, 4CH Quitter le système d'exploitation.

INT 21
MOV AH, 01H Lire un caractère au clavier et le renvoyer (son

INT 21 code ASCII) dans le registre AL.
MOV AH, 02H Afficher le caractère qui se trouve dans le registre

INT 21 DL à l’écran.
 Exemple: afficher le caractère b à l’écran.

MOV DL, ’b’
MOV AH, 2 122
INT 21h
ENTRÉES / SORTIES
MOV AH, Lire une chaîne de caractère à partir du clavier

0AH L'adresse du premier caractère de la chaîne est DS:DX,
INT 21 Il faut préciser dans le premier octet de la chaîne, la
longueur maximale à ne pas dépasser.
Le deuxième octet indique le nombre de caractère
effectivement saisi.
La chaîne se termine par retour chariot.
 La longueur de la chaîne doit être supérieure ou égale à 3.
Long max Long lue X X .... X X CR

123
Chaîne Lue
 Exemple: Copier une chaîne lue dans une autre
Ch1 DB 15 DUP(13)
Ch2 DB 15 DUP(13)
.....
MOV AH, 0AH
LEA DX, Ch1
INT 21h
MOV CH, 0
MOV CL, [Ch1 + 1]
LEA SI, Ch1+2
LEA DI, Ch2+2 124
REP MOVSB
ENTRÉES / SORTIES
MOV AH, 09H Afficher une chaîne de caractère à l’écran:

INT 21 L'adresse du premier caractère de la chaîne est
DS:DX,
Le dernier caractère de la chaîne doit être le caractère
$.
msg DB ’hello world’, ’$’

.....
MOV AH, 9
LEA DX, msg 125
INT 21h
PARTIE 4:
CODE MACHINE DES
INSTRUCTIONS 8086
126
CODE MACHINE DES INSTRUCTIONS
 Les instructions 8086 sont présentées dans la machine
sous forme d’une suite de bits.
 Elles comportent de 1 à 6 octets:
 Le premier octet est obligatoire
 Les autres octets sont facultatifs (ils dépendent du

code de l’opération)
 De manière générale, le code machine d’une instruction

comportent le code de l’opération (COP), le code du
registre utilisé (REG), le code du mode d’adressage
127
utilisé (MOD), l’adresse de la case mémoire (R/M), etc.

Bits 7 6 5 4 3 2 1 0
1er octet COP D W Le code d’opération
2ème octet MOD REG R/M Le mode d’adressage
3ème octet [Optionnel] Les bits de poids faibles

ADR, DEP ou VAL
4ème octet [Optionnel] Les bits de poids forts de

ADR, DEP ou VAL
5ème octet [Optionnel] Les bits de poids faible de

VAL
6ème octet [Optionnel] Les bits de poids faible128

de
VAL
 1er octet: Le code d’opération
7 6 5 4 3 2 1 0
COP D W
 COP: présente le code proprement dit de l’instruction
 D: désigne la destination du résultat

D
0 Résultat dans mémoire ou Opération entre deux registres
1 Résultat dans un registre
 W: indique si l’opération est sur 8 bits ou sur 16 bits

W=0 W=1 129
8 bits 16 bits
 2ème octet: Le mode d’adressage
7 6 5 4 3 2 1 0
MOD REG R/M
 MOD: indique le mode d’adressage
MOD Mode d’adressage
00 Directe
Indirecte avec DEP = 0
01 Indirect déplacement court (sur 8 bits)
10 Indirect déplacement long (sur 16 bits) 130
11 Par registre ou Immédiat

7 6 5 4 3 2 1 0
MOD REG R/M
 REG: désigne le registre constituant un opérande

REG W=0 W=1
000 AL AX
001 CL CX
010 DL DX
011 BL BX
100 AH SP
101 CH BP
131
110 DH SI
111 BH DI
7 6 5 4 3 2 1 0
MOD REG R/M
 R/M: précise l’adresse constituant l’instruction (direct

ou indirect) ou le code de registre destinataire (par
registre)
R/M R/M
000 [BX+SI+DEP] 100 [SI+DEP]
001 [BX+DI+DEP] 101 [DI+DEP]
010 [BP+SI+DEP] 110 [BP+DEP]
Direct 132
011 [BP+DI+DEP] 111 [BX+DEP]

 Exemples:
MOV AL, BL
COP D W MOD REG R/M
1000 10 ? ? ? ? ?
1000 10 0 0 11 011 000
88 D8
MOV AX, BX
COP D W MOD REG R/M
1000 10 0 1 11 011 000
133
89 D8
 Exemples:
MOV DX, [123h]

COP D W MOD REG R/M ADR
1000 10 ? ? ? ? ? ?
1000 10 1 1 00 010 110 2301
8B 16 23 01
MOV [123h], DX

1000 10 0 1 00 010 110 2301
134
89 16 23 01
 Exemples:
MOV [SI], BL
COP D W MOD REG R/M
1000 10 ? ? ? ? ?
1000 10 0 0 00 011 100
88 1C
MOV [SI + 14h], BL

1000 10 0 0 01 011 100 14
135
88 5C 14
 Exemples:
MOV [SI + 14h], BL

1000 10 0 0 01 011 100 14
88 5C 14
MOV [SI + 146h], BL

1000 10 0 0 10 011 100 4601
136
88 9C 46 01
CODE MACHINE
DES INSTRUCTIONS DE TRANSFERT
Mnémonique 1er octet
MOV
R/M, R/M 1000 10dw MOD REG R/M (Adr ou dep)
M, Val 1100 011w MOD 000 M (Adr ou dep) valeur
R, Val 1011 w REG Valeur
AX/AL, M_direct 1010 000w M_direct
M_direct, AX/AL 1010 001w M_direct
XCHG
R/M, R/M 1000 011w MOD REG R/M (Adr ou dep)
R, AX 10010 REG
LEA R, Var 10001101 MOD REG 110 Offset de 137
Var
CODE MACHINE
DES INSTRUCTIONS ARITHMÉTIQUE
ADD
R/M, Val 1000 00sw MOD 000 R/M (Adr ou dep) Valeur
AL/AX, Val 0000 010w Valeur
SUB
M, Val 1000 00sw MOD 101 R/M (Adr ou dep) Valeur
R, Val 1000 00sw 11 101 REG Valeur
CMP
R/M, Val 1000 00sw MOD 111 R/M (Adr ou dep) Valeur
s=1 dans le cas où une extension de signe 8 bits vers 16 bits 138
est effectuée sur la donnée valeur avant l’opération.
CODE MACHINE
DES INSTRUCTIONS ARITHMÉTIQUE
Mnémonique 1er octet 2ème octet

INC
M 1111 111w MOD 000 R/M (Adr ou dep)
R 8 bits 1111 1110 MOD 000 R/M
R 16 bits 01000 REG
DEC
M 1111 111w MOD 001 R/M (Adr ou dep)
R 8 bits 1111 1110 MOD 001 R/M
R 16 bits 01001 REG
NEG R/M 1111 011w MOD 011 R/M (Adr ou dep)
MUL R/M 1111 011w MOD 100 R/M (Adr ou dep)
IMUL R/M 1111 011w MOD 101 R/M (Adr ou dep)
DIV R/M 1111 011w MOD 110 R/M (Adr ou dep)

139
IDIV R/M 1111 011w MOD 111 R/M (Adr ou dep)
CODE MACHINE
DES INSTRUCTIONS LOGIQUE
NOT R/M 1111 011w MOD 010 R/M (Adr ou dep)
AND
R/M, Val 1000 000w MOD 100 R/M (Adr ou dep) Valeur
OR
XOR
TEST
140
R/M, R/M 1000 010w MOD REG R/M (Adr ou dep)
CODE MACHINE
DES INSTRUCTIONS DE DÉCALAGE
SAR
R/M,1 1101 000w MOD 111 R/M (Adr ou dep)
R/M,CL 1101 001w MOD 111 R/M (Adr ou dep)
SHL/SAL
SHR
141
CODE MACHINE
DES INSTRUCTIONS DE DÉCALAGE
ROL
ROR
RCL
RCR 142

CODE MACHINE
DES INSTRUCTIONS DE BRANCHEMENT
JMP
Etiq 1110 1001 DepRel_16
Short Etiq 1110 1011 DepRel_8
JS 0111 1000 DepRel_8
JNS 0111 1001 DepRel_8
JC 1110 0010 DepRel_8
JNC 0111 0011 DepRel_8
JE/JZ 0111 0100 DepRel_8
JNE/JNZ 0111 0101 DepRel_8 143

JA 0111 0111 DepRel_8
JAE 0111 0011 DepRel_8
JB 0111 0010 DepRel_8
JBE 0111 0110 DepRel_8
JG 0111 1111 DepRel_8
JGE 0111 1101 DepRel_8
JL 0111 1100 DepRel_8
JLE 0111 1110 DepRel_8
LOOP 1110 0010 DepRel_8
LOOPZ 1110 0001 DepRel_8
LOOPNZ 1110 0000 DepRel_8 144
JCXZ 1110 0011 DepRel_8

CODE MACHINE
DES INSTRUCTIONS DE TRAITEMENT DES CHAÎNES
MOVS 1010 010w w = 0 pour MOVSB,
LODS 1010 110w LODSB, STOSB,

SCASB, CMPSB
STOS 1010 101w
w = 1 pour MOVSW,
SCAS 1010 111w
LODSW, STOSW,
CMPS 1010 011w SCASW, CMPSW
REP/REPZ/REPE 1111 0011
REPNZ/REPNE 1111 0010
145
AUTRES INSTRUCTIONS
 Instructions d’action sur les indicateurs :
Mnémonique 1er octet Action
CLC 1111 1000 C0
STC 1111 1001 C 1
CMC 1111 0101 C  NOT C
CLD 1111 1100 D0 (Gauche à droite)
STD 1111 1101 D 1 (Droite à gauche)
 Instructions de Conversion Mnémonique 1er octet

CBW 1001 1000
CWD 1001 1001
 Instruction d’une interruption
Mnémonique 1er octet 2eme octet 146
INT Num 1100 1101 Numéro d’ interruption (21h)

SOURCES DE CE COURS
 A. Oumnad, Microprocesseur de la famille 8086, pp.53, Disponible sur
http://arabteam2000-forum.com/index.php?app=core&module=attach&section=attach&attach_id=133285
 Djamal BENNOUAR, Cours Architecture des Ordinateurs 1, Département
Informatique, Faculté des Sciences, USDB, 2012.
 Abdelhakim Khouas, Cours Architecture des Ordinateurs, Département de
Physique, Faculté des Sciences, Université de Boumerdes, 2008-2009. Disponible
sur http://infotroniquedz.ble.fr/architecture_des_pcs_107.htm
 Microprocesseur 8086 Architecture et Programmation, Disponible sur
http://www.technologuepro.com/cours-genie-electrique/cours-2-microprocesseur-
8086-architecture-programmation/
 Philippe Preux, Assembleur i8086, IUT Informatique du Littoral. Disponible sur

147
www.grappa.univ-lille3.fr/~ppreux/Documents/assembleur-i8086.pdf‎

Chapitreiiiprocesseurintel80x86 140116154821 Phpapp02 PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Chapitreiiiprocesseurintel80x86 140116154821 Phpapp02 PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Université Saad Dahleb de Blida

Faculté des Sciences

Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/

 Présenter le Processeur 8086 de Intel

 Étudier son jeux d'instruction.

 Apprendre à le programmer en assembleur pour

comprendre son fonctionnement.

 Coder les instructions en langage machine (binaire).

 Code Machine des Instructions

La majorité des microprocesseurs

Intel sont compatibles avec le 8086

 Disponible depuis 1978, le processeur 8086 fut le premier

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

Bus de données Interne 16 bits

Flags Architecture Générale du processeur 8086

 La taille du bus d’adresse égale à 20 bits  La mémoire totale

 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

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

 Le compteur d’instruction (IP), appelé aussi Compteur

 C (Carry) : indique qu’il y a une retenue du résultat à

 P (Parité) : indique que le nombre de 1 est un nombre

 Z (Zéro) : indique que le résultat est nul.

 S (Signe) : indique le signe du résultat

 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

 Il y a aussi des instructions qui agissent sur un seul opérande

 Les opérandes peuvent être des registres, des constantes ou le

 L'opération se fait sur un ou 2 registres

 INC AX : incrémenter le registre AX (AX++)

 MOV AX, BX : Copier le contenu de BX dans AX

 L’opérande est une constante (valeur) qui fait partie de

 MOV AX, 243 : charger le registre AX par le nombre

 JMP 008 : saut à l’instruction du numéro 008

 MOV AL, ‘A‘ : Charger le registre AL par le code ASCII du

 MOV AX, ‘A‘ : Charger le registre AH par 00 et le registre

 MOV AX,‘AB' : Charger AH par le code ASCII du caractère

‘A' et AL par le code ASCII du caractère ‘B‘ (66)

 Un des deux opérandes se trouve en mémoire. L’adresse

INST taille [adr] , im

 L’adresse doit être placée entre [Rseg:Roff]. Si le segment

INST taille [adr] , im

 MOV AX,[243] : Copier le contenu de la mémoire d'adresse

 MOV [123],AX : Copier le contenu de AX dans la mémoire

 Un des deux opérandes se trouve en mémoire. L’adresse se

INST R , [Rseg : Roff]

INST [Rseg : Roff] , R

INST taille [Rseg : Roff] , im

 Si Rseg n'est pas spécifié, le segment par défaut sera

Segment par défaut DS SS DS DS

 MOV AX, [BX]; 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, [SI]; Charger AX par le contenu de la mémoire d'adresse

 MOV AX, [DI] ; Charger AX par le contenu de la mémoire d'adresse

 L’adressage indirect est divisé en 3 catégories selon le

Mode Adressage Basé Indexé Basé Indexé

Registres utilisés BX DI BX, DI

 L’offset se trouve dans l’un des deux registres de base BX