Vous êtes sur la page 1sur 146

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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
REGISTRES

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

9
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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é
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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


ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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)


ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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.
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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


ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
MODE D’ADRESSAGE

4. Adressage Indirect
 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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
MODE D’ADRESSAGE

4. Adressage Indirect

 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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
MODE D’ADRESSAGE

4. Adressage Indirect
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
MODE D’ADRESSAGE

4. Adressage Indirect
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
MODE D’ADRESSAGE

4. Adressage Indirect
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
MODE D’ADRESSAGE

4. Adressage Indirect
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
MODE D’ADRESSAGE

4. Adressage Indirect
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
MODE D’ADRESSAGE

4. Adressage Indirect
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
TAILLE DES ECHANGES AVEC LA MEMOIRE

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
ARCHITECTURE GÉNÉRALE DU PROCESSEUR 8086
TAILLE DES ECHANGES AVEC LA MEMOIRE

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
INSTRUCTIONS ARITHMÉTIQUES
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]
INSTRUCTIONS ARITHMÉTIQUES
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]
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS ARITHMÉTIQUES
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]
INSTRUCTIONS ARITHMÉTIQUES
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])
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS ARITHMÉTIQUES
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 -
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS ARITHMÉTIQUES
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)
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS ARITHMÉTIQUES
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
INSTRUCTIONS LOGIQUES
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
INSTRUCTIONS LOGIQUES
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
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:

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
INSTRUCTIONS LOGIQUES
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
INSTRUCTIONS LOGIQUES
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
INSTRUCTIONS LOGIQUES
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
INSTRUCTIONS LOGIQUES
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
INSTRUCTIONS DE DÉCALAGE
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
INSTRUCTIONS DE DÉCALAGE
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.
INSTRUCTIONS DE DÉCALAGE
DÉCALAGE CIRCULAIRE GAUCHE/DROIT

 ROL Od, n

... ...
C

 ROR Od, n

... ...
C
67
INSTRUCTIONS DE DÉCALAGE
DÉCALAGE CIRCULAIRE À TRAVERS LA RETENUE

 RCL Od, n

C ... ...

 RCR Od, n

... ... C

68
INSTRUCTIONS DE DÉCALAGE
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
INSTRUCTIONS DE BRANCHEMENT

 On distingue 3 types d’instructions:

 Branchement inconditionnel: JMP

 Contrôle de Boucle : LOOPX

 Branchement conditionnel: Jcondition

71
INSTRUCTIONS DE BRANCHEMENT
INCONDITIONNEL
 JMP label: effectue un saut (jump) vers le label spécifié.

. .
. .
. .
JMP suite Etiq: .
. .
. .
. .
Suite: ..................... JMP Etiq
. .
. .

72
INSTRUCTIONS DE BRANCHEMENT
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

......
INSTRUCTIONS DE BRANCHEMENT
DE CONTRÔLE DE BOUCLE

 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
INSTRUCTIONS DE BRANCHEMENT
DE CONTRÔLE DE BOUCLE

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
INSTRUCTIONS DE BRANCHEMENT
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
INSTRUCTIONS DE BRANCHEMENT
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
PROGRAMMATION EN ASSEMBLEUR
É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.


PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
É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;
PROGRAMMATION EN ASSEMBLEUR
É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 ...
PROGRAMMATION EN ASSEMBLEUR
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


PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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)
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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


PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
EXEMPLE DE CODAGE DE TESTS
Langage évolué Assembleur

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
PROGRAMMATION EN ASSEMBLEUR
EXEMPLE DE CODAGE DE TESTS

Langage évolué Assembleur

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
PROGRAMMATION EN ASSEMBLEUR
EXEMPLE DE CODAGE DE TESTS

Langage évolué Assembleur

Jump si la condition est fausse

TANT-QUE (condition)FAIRE TQ: Calcul de la condition

Actions-TQ JNCond FTQ

Actions-TQ
FTQ
JUMP TQ
Suite_programme
FTQ: Suite_Programme 100
PROGRAMMATION EN ASSEMBLEUR
EXEMPLE DE CODAGE DE TESTS

Langage évolué Assembleur

Jump si la condition est fausse

REPETER REPERTER:

Actions-REPETER Actions-REPETER

Calcul de la condition
JUSQUA (condition vraie)
JNCond REPETER
Suite_programme
Suite_Programme 101
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
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.
PROGRAMMATION EN ASSEMBLEUR
ACCÈS AUX ÉLÉMENTS D’UN TABLEAU

 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
PROGRAMMATION EN ASSEMBLEUR
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].
PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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
PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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
PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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


PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES
 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
PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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


PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES
 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
PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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
PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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.
PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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
PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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


PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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


PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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


PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES

 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


PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES
 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
PROGRAMMATION EN ASSEMBLEUR
TRAITEMENT DES CHAÎNES DE DONNÉES
 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
PROGRAMMATION EN ASSEMBLEUR
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.
PROGRAMMATION EN ASSEMBLEUR
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
PROGRAMMATION EN ASSEMBLEUR
ENTRÉES / SORTIES
Instructions Fonctionnalité

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
PROGRAMMATION EN ASSEMBLEUR
ACCÈS AUX ÉLÉMENTS D’UN TABLEAU
 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
PROGRAMMATION EN ASSEMBLEUR
ENTRÉES / SORTIES
Instructions Fonctionnalité

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.


CODE MACHINE DES INSTRUCTIONS

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
CODE MACHINE DES INSTRUCTIONS
 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
CODE MACHINE DES INSTRUCTIONS
 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


CODE MACHINE DES INSTRUCTIONS
 2ème octet: Le mode d’adressage

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
CODE MACHINE DES INSTRUCTIONS
 2ème octet: Le mode d’adressage

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]


CODE MACHINE DES INSTRUCTIONS
 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
CODE MACHINE DES INSTRUCTIONS
 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

COP D W MOD REG R/M ADR


1000 10 0 1 00 010 110 2301

134
89 16 23 01
CODE MACHINE DES INSTRUCTIONS
 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

COP D W MOD REG R/M ADR


1000 10 0 0 01 011 100 14

135
88 5C 14
CODE MACHINE DES INSTRUCTIONS
 Exemples:

MOV [SI + 14h], BL

COP D W MOD REG R/M ADR


1000 10 0 0 01 011 100 14

88 5C 14

MOV [SI + 146h], BL

COP D W MOD REG R/M ADR


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
Mnémonique 1er octet
ADD
R/M, R/M 0000 00dw MOD REG R/M (Adr ou dep)
R/M, Val 1000 00sw MOD 000 R/M (Adr ou dep) Valeur
AL/AX, Val 0000 010w Valeur
SUB
R/M, R/M 0010 10dw MOD REG R/M (Adr ou dep)
M, Val 1000 00sw MOD 101 R/M (Adr ou dep) Valeur
R, Val 1000 00sw 11 101 REG Valeur
AL/AX, Val 0010 110w Valeur
CMP
R/M, R/M 0011 10dw MOD REG R/M (Adr ou dep)
R/M, Val 1000 00sw MOD 111 R/M (Adr ou dep) Valeur
AL/AX, Val 0011 110w 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
Mnémonique 1er octet
NOT R/M 1111 011w MOD 010 R/M (Adr ou dep)
AND
R/M, R/M 0010 00dw MOD REG R/M (Adr ou dep)
R/M, Val 1000 000w MOD 100 R/M (Adr ou dep) Valeur
AL/AX, Val 0010 010w Valeur
OR
R/M, R/M 0000 10dw MOD REG R/M (Adr ou dep)
R/M, Val 1000 000w MOD 001 R/M (Adr ou dep) Valeur
AL/AX, Val 0000 110w Valeur
XOR
R/M, R/M 0011 00dw MOD REG R/M (Adr ou dep)
R/M, Val 1000 000w MOD 110 R/M (Adr ou dep) Valeur
AL/AX, Val 0011 010w Valeur
TEST
140
R/M, R/M 1000 010w MOD REG R/M (Adr ou dep)
R/M, Val 1111 011w MOD 000 R/M (Adr ou dep) Valeur
AL/AX, Val 1010 100w Valeur
CODE MACHINE
DES INSTRUCTIONS DE DÉCALAGE
Mnémonique 1er octet 2ème octet

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
R/M,1 1101 000w MOD 100 R/M (Adr ou dep)
R/M,CL 1101 001w MOD 100 R/M (Adr ou dep)

SHR
R/M,1 1101 000w MOD 101 R/M (Adr ou dep)
R/M,CL 1101 001w MOD 101 R/M (Adr ou dep)
141
CODE MACHINE
DES INSTRUCTIONS DE DÉCALAGE
Mnémonique 1er octet 2ème octet

ROL
R/M,1 1101 000w MOD 000 R/M (Adr ou dep)
R/M,CL 1101 001w MOD 000 R/M (Adr ou dep)

ROR
R/M,1 1101 000w MOD 001 R/M (Adr ou dep)
R/M,CL 1101 001w MOD 001 R/M (Adr ou dep)

RCL
R/M,1 1101 000w MOD 010 R/M (Adr ou dep)
R/M,CL 1101 001w MOD 010 R/M (Adr ou dep)

RCR 142

R/M,1 1101 000w MOD 011 R/M (Adr ou dep)


CODE MACHINE
DES INSTRUCTIONS DE BRANCHEMENT
Mnémonique 1er octet 2ème octet

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


Mnémonique 1er octet 2ème octet

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

Mnémonique 1er octet

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‎