Syllabus Assembleur

Première année / 2010
Architecture et langage
assembleur du
microprocesseur de la
famille INTEL 8086
1
Sommaire
1 Structure d’un processeur En 5
général....................................................................
1.1 L'unité de 5
calcul...................................................................................
1.2 L'unité de 6
control ................................................................................
2 Le microprocesseur 7
8086 .................................................................................
........
2.1 La segmentation de la 8
mémoire............................................................
2.2 Les registres du 10
8086...........................................................................
2.2.1 Les registres 10
généraux.......................................................................
2.2.2 Les registres d'adressage 11
(offset) ......................................................
2.2.3 Les registres de 11
segment ..................................................................
2.2.4 Le registre d'état 12
(flags)....................................................................
2.3 Les modes 13
d'adressage ........................................................................
2.4 Taille des échanges avec la 16
mémoire ....................................................
2.5 Les instructions du 17
8086.......................................................................
2.5.1 Les instructions de 17
transfert ..............................................................
2.5.2 Les instructions 19
Arithmétiques............................................................
2.5.3 Les instructions 21
logiques ...................................................................
2.5.4 Les masques 22
logiques :......................................................................
décalage..............................................................
2.5.6 Instructions agissant sur les 24
indicateurs .............................................
2.5.7 Les instructions de contrôle de 25
boucle................................................
2
branchement .......................................................
2.5.9 Instructions d'accès aux ports 28
d'E/S....................................................
2.6 tableau récapitulatif des 29
instructions......................................................
3 L’assembleur 30
NASM................................................................................
.................
3.1 Les directives de 30
NASM .......................................................................
3.2 Les pseudo instruction de 31
NASM ..........................................................
3.3 Les 31
expressions....................................................................................
4 Les entrées 32
sorties ..............................................................................
......................
4.1 L'interruption 10h du 32
BIOS...................................................................
4.2 L'interruption 21h du 35
DOS....................................................................
4.3 Accès direct à la mémoire 37
Vidéo ...........................................................
4.4 Les 38
temporisations...............................................................................
Objectif du cours
Dans ce cours on va présenter le Microprocesseur 8086 d’Intel, on va
étudier son jeux d'instruction complet, on va apprendre à le programmer
en assembleur et finir par étudier les entrées sorties.
Pourquoi un cours sur les Microprocesseurs et l'assembleur ? : Parce que

c'est la seule façon de comprendre comment fonctionne un ordinateur à
l'intérieur. Il devient ainsi beaucoup plus facile de le programmer à l'aide
3
d'autres langages plus évolué comme le Pascal, le C/C++, et les langages

visuels.
Pourquoi le 8086 d'Intel ? : Parce que la majeure partie des Ordinateurs

individuels utilisés de nos jours (2007) sont des PC équipés de
microprocesseurs Intel compatibles avec le 8086. C'est-à-dire que tout
programme écrit pour tourner sur un 8086 peut être exécuté sur un
Pentium 4. Ce qui signifie que si on maîtrise la programmation en
assembleur du 8086, on a fait un grand pas vers la programmation de nos
PC actuels que ce soit en assembleur ou à l'aide d'autres langages plus
évolué comme le C/C++.
Attention : Le 8086 est un microprocesseur qui était destiné à fonctionner

dans des ordinateurs mono tâches. C'est-à-dire qui ne peuvent exécuter
qu'un seul programme à la fois. Il fonctionnait alors en mode réel, c.à.d.
que le programme en cours d'exécution peut accéder à n'importe quelle
ressource de la machine y compris n'importe quelle zone mémoire. Avec
les systèmes d'exploitation récents comme Windows ou Linux, les
ordinateurs sont devenus multitâches c'est-à-dire que le processeur peut
travailler sur plusieurs programmes à la fois. Il devient alors impératif de
"réglementer" les accès à la mémoire afin qu'un programme ne puisse pas
aller écrire dans une zone mémoire utilisée par un autre programme. Pour
cela,
Les processeurs actuels fonctionnent en mode protégé. Ils interagissent

avec le système d'exploitation qui gère les ressources de la machine et
évite les conflits entre les programmes qui s'exécutent simultanément.
INTRODUCTION
Le rôle d'un processeur est d'exécuter des programmes. Un programme
est une suite d'instructions écrites une par ligne. Une instruction peut
être plus ou moins sophistiquée selon le langage utilisé. Pour un langage
de bas niveau comme l'assembleur, une instruction réalise une tache
4
élémentaire comme une addition par exemple. Avec un langage de haut

niveau comme le C++, une instruction peut réaliser un ensemble de
taches qui nécessiterait plusieurs instructions en Assembleur. Il va falloir
éclaircir un peut tout ça pour bien comprendre le fonctionnement d'une
machine informatique.
Un processeur quel qu'il soit sait exécuter un ensemble bien défini de

codes machines (jeux d'instructions). Chaque code machine est un
nombre binaire de quelques octets, il correspond à une instruction
élémentaire bien définie. Sur papier, on a pris l'habitude de les
représenter en hexadécimal pour faciliter.
Par exemple, l'instruction (assembleur) MOV BP,41h qui signifie : placer le

nombre 41h dans le registre BP est codée (en hexadécimal) par les trois
octets BD 41 00 , Dans la suite de ce cours, nous désignerons ces octets
par : éléments d'instruction.
Quand on veut écrire un programme, on dispose d'un choix très important
de langages de programmation différents les uns des autres : Assembleur,
Basic/Qbasic, Pascal, C/C++, Visual Basic, Visual C++, Delphi, Java, …
En fait, les lignes de programme que nous écrivons constituent ce qu'on

appelle un programme source qui sera stocké dans un fichier texte dont
l'extension dépend du langage choisi (test.pas pour le pascal, test.cpp
pour le c++ etc …)
Ces programmes sources sont compréhensibles par nous mais pas par le
processeur.
Pour que le processeur puisse les comprendre il faut les traduire
(compiler) en langage machine qui est une suite de codes machine. Sur
les PCs, se sont les fichiers avec l'extension .exe (test.exe). Chaque
langage de programmation a son compilateur qui permet de transformer
le programme source en un programme exécutable compréhensible par le
processeur. Tous les exécutables se ressemblent et le processeur ne sait
pas avec quel langage ils ont été écrits.
Avec un langage de haut niveau comme le C++, une instruction que nous
écrivons peut être très sophistiquée. C'est le compilateur C++ qui la
traduit en un ensemble d'instructions élémentaires compréhensible par le
processeur.
L'intérêt du langage assembleur est que chaque instruction que nous

écrivons correspond à une instruction élémentaire du processeur. C'est
comme si on travaillait directement en langage machine. Ainsi, on sait
exactement tout ce que fait le processeur lors de l'exécution d'un
programme.
5
Quand on demande l'exécution d'un programme, celui-ci est chargé par le

système d'exploitation (à partir du disque dur) dans une zone de la
mémoire RAM. Celle-ci étant organisée en octets, chaque élément
d'instruction est stocké dans une position mémoire.
L'adresse (le numéro) de la case mémoire de début est communiquée au
processeur pour qu'il commence l'exécution au bon endroit.
1. STRUCTURE D’UN PROCESSEUR EN GENERAL
Les différents constituants du Processeur peuvent être regroupés dans

deux blocs principaux, l'unité de calcul et l'unité de control.
1.1 L'UNITE DE CALCUL
Elle est constituée de l’Unité Arithmétique et logique UAL et d’un certain

nombre de registres
L'ALU :
Elle est constituée d'un circuit logique combinatoire qui reçoit deux
opérandes A (An
. . . A1 A0) et B (Bn . . . B1 B0) et produit le résultat S (Sm . . . S1 S0) selon
l'indication appliquée sur l'entrée C (Ck . . . C1 C0). Les opérations réalisées
peuvent être soit arithmétiques, S=A+B, S=A-B, S=AxB … ou logiques
S=A OU B, S=A ET B, S= A XOR B …
6
Les registres :
Ce sont des mémoires élémentaires pouvant contenir chacun un

opérande. Les registres peuvent être de 8, 16 ou 32 bits.
1.2 L'UNITE DE CONTROL
C'est l'unité de control qui supervise le déroulement de toutes les

opérations au sein du Processeur. Elle est constituée principalement de :
L’horloge
C'est l'horloge qui génère les signaux qui permettent le cadencement et la

synchronisation de toutes les opérations. Attention, l'horloge n'est pas une
montre au sens commun du terme, c'est juste un signal carré qui a une
fréquence fixe (3 Ghz par exemple), a chaque coup (front) d'horloge, le
microprocesseur (qui ne l'oublions pas n'est qu'un circuit électronique)
réalise une tache élémentaire. L'exécution d'une instruction nécessite
plusieurs coups d'horloges.
Il existe des processeurs qui exécutent une instruction par coup d'horloge,
ce n'est pas le cas du 8086.
Le compteur programme PC
Le compteur programme (PC : program counter) est un registre (pointeur)

qui contient l'adresse de la case mémoire où est stockée le prochain
élément d'instruction qui devra être chargé dans le processeur pour être
analysé et exécuté. Au début de l'exécution d'un programme, le PC est
initialisé par le système d'exploitation à l'adresse mémoire où est stockée
la première instruction du programme. Le compteur programme est
7
incrémenté automatiquement chaque fois qu'un élément d'instruction est

est chargée dans le processeur.
Le registre d'instruction RI
C'est là où le CPU stocke l'instruction en cours d'exécution.
Le décodeur
C'est lui qui va "décoder" l'instruction contenue dans RI et générer les

signaux logiques correspondant et les communiquer au séquenceur.
Le séquenceur
Il gère le séquencement des opérations et génère les signaux de

commande qui vont activer tous les éléments qui participeront à
l'exécution de l'instruction et spécialement l'ALU.
Le registre d'état
Le registre d'état est formé de plusieurs bits appelés drapeaux ou

indicateurs (Flags) qui sont positionnés par l'ALU après chaque opération.
Par exemple l’indicateur Z indique quand il est positionné que le résultat
de l'opération est égal à Zéro.
L’indicateur C indique que l'opération a généré une retenue. Le bit N

indique que le résultat est négatif …
On dispose d'un jeu d'instructions conditionnées par l'état de différents
drapeaux
2. LE MICROPROCESSEUR 8086
Disponible depuis 1987, le 8086 fut le premier microprocesseur 16 bits

fabriqué par
Intel. Parmi ses caractéristiques principales, on peut citer :
• Il se présente sous forme d'un boîtier de 40 broches alimenté par

une alimentation unique de 5V.
• Il possède un bus multiplexé adresse/donnée de 20 bits.
• Le bus de donnée occupe 16 bits ce qui permet d'échanger des mots

de 2 octets
• Le bus d'adresse occupe 20 bits ce qui permet d'adresser 1 Moctets

(220)
8
• Il est entièrement compatible avec le 8088, le jeu d'instruction est

identique. La seule différence réside dans la taille du bus de
données, celui du 8088 fait seulement 8 bits. Les programmes
tourneront donc un peu plus lentement sur ce dernier puisqu'il doit
échanger les mots de 16 bits en deux étapes.
• Tous les registres sont de 16 bits, mais pour garder la compatibilité
avec le 8085/8088, certains registres sont découpés en deux et on
peut accéder séparément à la partie haute et à la partie basse.
2.1 LA SEGMENTATION DE LA MEMOIRE
Le 8086 possède 20 bits d'adresse, il peut donc adresser 220 octets soit 1
Mo.
L'adresse de la première case mémoire est 0000 0000 0000 0000 0000
celle de la dernière casse est 1111 1111 1111 1111 1111 1111. Il me
paraît inutile de justifier pourquoi à partir de cet instant, nous allons
représenter les adresses en hexadécimal, et notre 8086 peut donc
adresser 1 Mo allant de 00000 à FFFFF. Le problème qui se pose est
comment représenter ces adresses au sein du μP puisque les registres ne
9
font que 16 bits soit 4 digits au maximum en hexadécimal. La solution

adoptée par Intel a été la suivante :
Puisque avec 16 bits en peut adresser 216 octets = 65535 octets = 64 ko,
La mémoire totale adressable de 1 Mo est 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 qu'on appelle
registre segment et un registre pour adresser à l'intérieur du segment
qu'on désignera par registre d'adressage ou offset. Une adresse se
présente toujours sous la forme segment:offset
A titre d'exemple, procédons au découpage de la mémoire en 16

segments qui ne se chevauche pas.
Considérons la case mémoire d'adresse 20350, appelée adresse absolue

ou adresse linéaire. Cette case mémoire se situe dans le segment 2, son
adresse relative à ce segment est 350, on peut donc la référencer par le
couple segment:offset = 20000:350.
Se pose maintenant le problème de la représentation de cette adresse au

sein du CPU car les registres de 16 bits ne peuvent contenir que 4 digits.
S'il n'y a aucun problème pour représenter 350 dans un registre d'offset,
on ne peut pas représenter 20000 dans un registre segment. La solution
adoptée par Intel est la suivante :
- Dans le registre segment, on écrit l'adresse segment sans le chiffre de

faible poids
- Dans le registre d'adressage (d'offset) on écrit l'adresse relative dans le
segment
- Pour calculer l'adresse absolue qui sera envoyée sur le bus d'adresse de
20 bits, le
CPU procède à l'addition des deux registres après avoir décalé le registre
segment d'un chiffre à gauche :
10
Dans notre exemple, l'adresse de la case mémoire considérée devient

2000:350 soit :
Segment = 2000
Offset = 350
L'adresse absolue est calculée ainsi :
2.2 LES REGISTRES DU 8086
Tous les registres et le bus interne du 8086 sont structurés en 16 bits.

Vu de l'utilisateur, le 8086 comprend 3 groupes de 4 registres de 16 bits,
un registre d'état de 9 bits et un compteur programme de 16 bits non
accessible par l'utilisateur.
2.2.1 Les registres généraux
Les registres généraux participent aux opérations arithmétiques et

logiques ainsi qu'à l'adressage. Chaque demi-registre est accessible
comme registre de 8 bits, le 8086 peut donc effectuer des opérations 8
bits d'une façon compatible avec le 8080.
11
AX : Accumulateur
• Usage général,
• Obligatoire pour la multiplication et la division,
• Ne peut pas servir pour l'adressage
BX : Base
• Adressage, (Par défaut, son offset est relatif au segment DS)
CX : Comptage et calcul
• Utilisé par certaines instructions comme compteur de répétition.
DX : Data
• Dans la multiplication et la division 16 bits, il sert comme extension au
registre AX pour contenir un nombre 32 bits,
2.2.2 Les registres d'adressage (offset)
Ces registres de 16 bits permettent l'adressage d'un opérande à l'intérieur

d'un segment de 64 ko (216 positions mémoires)
SP : Pointeur de Pile
• Utilisé pour l'accès à la pile. Pointe sur la tête de la pile.

• Par défaut, son offset est relatif à SS
BP : Pointeur de Base
• Adressage comme registre de base, (Par défaut, son offset est relatif à
SS)
• Usage général
SI : Registre d'index (source)
• Adressage comme registre d’index, (Par défaut, son offset est relatif à
DS)
12
• Certaines instruction de déplacement de donnés l'utilise comme index

de l'opérande source. L'opérande destination étant indexé par DI
• Usage général
DI : Registre d'index (destination)
• Adressage comme registre d’index, (par défaut, son offset est relatif à
DS)
• Certaines instruction de déplacement de donnés l'utilise comme index
de l'opérande destination, l'opérande destination étant indexé par SI
2.2.3 Les registres de segment
Ces registrent sont combiné avec les registres d’offset pour former les
adresses. Une case mémoire est repérée par une adresse de la forme
RS:RO. On place le registre segment au début d’une zone mémoire de de
64Ko, ensuite on fait varier le registre d’offset qui précise l’adresse
relative par rapport à cette position.
CS : Code Segment
Définit le début de la mémoire programme. Les adresses des différentes

instructions du programme sont relatives à CS
DS : Data Segment
Début de la mémoire de données dans laquelle sont stockées toutes les

données traitées par le programme
SS : Stack Segment
Début de La pile qui est une zone mémoire gérée d’une façon particulière.
Elle est organisée comme une pile d’assiettes. On pose et on retire les
assiettes toujours sur le haut de la pile. Un seul registre d’adresse suffit
donc pour la gérer, c’est le stack pointer SP. On dit que c’est une pile LIFO
(Last IN, First Out).
Empiler une donnée : sauvegarder une donnée sur (le sommet) de la pile
Dépiler une donnée : retirer une donnée (du sommet) de la pile
ES : Extra Segment
Début d'un segment auxiliaire pour données
13
2.2.4 Le registre d'état (flags)
Six bits reflètent les résultats d'une opération arithmétique ou logique et 3

participent au control du processeur.
C : (Carry) indique le dépassement de capacité de 1 sur une opération 8

bits ou 16bits. Ce flag peut être utilisé par des instructions de saut
conditionnel, des calculs arithmétique en chaîne ou dans des opérations
de rotation.
P : (Parité) indique que le nombre de 1 est un nombre pair. Ce flag est

utilisé avec certains sauts conditionnels.
A : (retenue Arithmétique) indique une retenue sur les 4 bits (digit) de

poids faible.
Par exemple quand la somme des 2 digits de poids faible dépasse F (15)
Z : (Zéro) Indique que le résultat d'une opération arithmétique ou logique

est nul. Il est utilisé dans plusieurs instructions de sauts conditionnels.
S : (Signe) reproduit le bit de poids fort d'une quantité signée sur 8 bits ou
sur 16 bits. L'arithmétique signée fonctionne en complément à 2. S=0 :
positif, S=1 : négatif. Ce flag sert lors de sauts conditionnels.
T : (Trap) met le CPU en mode pas à pas pour faciliter la recherche des
défauts d'exécution.
I : (Interruption) autorise ou non la reconnaissance des interruptions

I = 0 Interruptions autorisées
I = 1 Interruptions non autorisées
D : (Direction) fixe la direction de l'auto-inc/décrémentation de SI et DI lors

des instructions de manipulation de chaînes.
D = 0 Incrémentation des index
D = 1 décrémentation des index
O : (Overflow) indique un dépassement de capacité quand on travaille

avec des nombres signés. Comme par exemple si la somme de 2 nombres
positifs donne un nombre négatif ou inversement. (40h + 40h = 80h et
O=1)
14
2.3 LES MODES D'ADRESSAGE
Dans la suite on utilisera les abréviations suivantes :
INST : instruction,
R : Registre quelconque,
Rseg : Registre Segment
Roff : Registre d’offset
Adr : Adresse
[ adr] : contenu Mémoire
Off : Offset de l’adresse
Im : donnée (constante)
Dep : déplacement (constante)
Op : Opérande
Os : Opérande source
Od : opérande destination
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
Les opérandes peuvent être des registres, des constantes ou le contenu
de cases mémoire, on appelle ça le mode d’adressage.
• Adressage registre (R)
L'opération se fait sur un ou 2 registres
INST R , R
INST R
Exemples :
INC AX : incrémenter le registre AX

MOV AX, BX : Copier le contenu de BX dans AX
• Adressage Immédiat (IM)
15
Un des opérandes est une constante (valeur) :
INST R , im
INST taille [adr] , im
Exemples :
MOV AX, 243 : charger le registre AX par le nombre décimal 243

ADD AX, 243h : additionner le registre AX avec le nombre hexadécimal
243
MOV AX, 0xA243 : Quand le chiffre de gauche du nombre hexadécimal est
une lettre, il est préférable d'utiliser le préfix 0x pour l'hexadécimal
MOV AL, 'a' : Charger le registre AL par le code ASCII du caractère 'a'
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 'a' et AL par 'b'
• Adressage direct (DA)
Un des deux opérandes se trouve en mémoire. L’adresse de la case

mémoire ou plus précisément son Offset est précisé directement dans
l’instruction. L’adresse Rseg:Off doit être placée entre [ ], si le segment
n’est pas précisé, DS est pris par défaut,
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 dan la mémoire d'adresse DS:123
MOV AX, [SS:243] : Copier le contenu de la mémoire SS:243 dans AX.
• Adressage indirect (IR)
Un des deux opérandes se trouve en mémoire. L’offset de l’adresse n’est

pas précisé directement dans l'instruction, il se trouve dans l’un des 4
registres d’offset BX, BP, SI ou DI et c’est le registre qui sera précisé dans
l’instruction : [Rseg : Roff]. Si Rseg n'est pas spécifié, le segment par
défaut sera utilisé (voir Tableau 2.1)
INST R , [Rseg : Roff]

INST [Rseg : Roff] , R
16
INST taille [Rseg : Roff] , im
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
MOV AX, [ES:BP] ; Charger AX par le contenu de la mémoire d'adresse
ES:BP
L’adressage indirect est divisé en 3 catégories selon le registre d’offset
utilisé. On distingue ainsi, l’adressage Basé, l’adressage indexé et
l’adressage basé indexé,
• Adressage Basé (BA)
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
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
ES:BP
• Adressage Indexé (X)
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
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
17
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 ES:SI+4
• Adressage Basé Indexé (BXI)
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
INST taille [Rseg : Rb+Ri+dep] , im
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
MOV AX, [BP+DI] ; AX est chargé par la mémoire d'adresse SS:BP+DI
2.4 TAILLE DES ECHANGES AVEC LA MEMOIRE
La mémoire est organisée en octets. 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.
Si le registre est un registre double (2 octets), l’opération se fera avec

deux cases
Mémoires
18
Quand on fait une opération entre une constante et une case mémoire,
il y a ambiguïté, le processeur ne sait pas s’il faut considérer la constante
sur 8 bits ou sur 16 bits. Il faut utiliser les préfixes BYTE et WORD pour
préciser le nombre d’octets á écrire :
2.5 LES INSTRUCTIONS DU 8086
2.5.1 Les instructions de transfert
MOV Od , Os
Copie l'opérande Source dans l'opérande Destination

MOV R1 , R2 copier un registre dans un autre
MOV R , M copier le contenu d’une case mémoire dans un registre
MOV M , R copier un register dans une case mémoire
MOV R , im copier une constante dans un registre
MOV taille M , im copier une constante dans une case mémoire (taille =
BYTE ou WORD)
PUSH Op
Empiler l’opérande Op (Op doit être un opérande 16 bits)
- Décrémente SP de 2
- Copie Op dans la mémoire pontée par SP
PUSH R16
PUSH word [adr]
POP Op
Dépiler dans l’opérande Op (Op doit être un opérande 16 bits)
- Copie les deux cases mémoire pointée par SP dans l'opérande Op
19
- Incrémente SP de 2
POP R16
POP word M
L'exemple de la figure 2.4 illustre plusieurs situations :
(a) Situation de la pile après empilement des registres AX, BX et CX

(b) Situation de la pile après empilement du registre DX
(c) Situation de la pile après un dépilement. On remarquera que DX reste
dans la mémoire mais s'il ne fait plus partie de la pile. La pile s'arrête à
son sommet qui est pointé par le pointeur de pile.
(d) Situation de la pile après empilement du registre BP. On remarque que
la valeur BP écrase la valeur DX dans la mémoire.
PUSHA
Empile tous les registres généraux et d’adressage dans l'ordre suivant :

AX, CX, DX, BX, SP, BP, SI, DI
POPA
Dépile tous les registres généraux et d’adressage dans l'ordre inverse de

PUSHA afin que chaque registre retrouve sa valeur. La valeur dépilée de
SP est ignorée
XCHG OD , OS
20
Echange l'opérande Source avec l'opérande Destination. Impossible sur

segment.
XCHG R1 , R2
XCHG [adr] , R
XCHG R , [adr]
2.5.2 Les instructions Arithmétiques
Le 8086 permet d'effectuer les Quatre opérations arithmétiques de base,

l'addition, la soustraction, la multiplication et la division. Les opérations
peuvent s'effectuer sur des nombres de 8 bits ou de 16 bits signés ou non
signés. Les nombres signés sont représentés en complément à 2. Des
instructions d'ajustement décimal permette de faire des calculs en décimal
(BCD).
Addition :
ADD Od , Os Additionne l'opérande source et l'opérande destination avec

résultat dans l'opérande destination,
Od + Os Od
ADD AX,123 ADD AX,BX ADD [123],AX ADD BX,[SI]
ADC Od , Os Additionne l'opérande source, l'opérande destination et le

curry avec résultat dans l'opérande destination,
Od + Os + C Od
INC Op Incrémente l'opérande Op

Op + 1 Op
Attention, l’indicateur C n’est pas positionné quand il y a débordement,
C'est l’indicateur Z qui permet de détecter le débordement
Pour incrémenter une case mémoire, il faut préciser la taille :
INC byte [ ]
INC word [ ]
Soustraction :
SUB Od , Os Soustrait l'opérande source et l'opérande destination avec

résultat dans l'opérande destination.
Od - Os Od
SBB Od , Os Soustrait l'opérande source et le curry de l'opérande

destination avec résultat dans l'opérande destination.
Od - Os - C Od
21
DEC Op Décrémente l'opérande Op

Op - 1 Op
NEG Op Donne le complément à 2 de l'opérande Op : remplace Op par

son négatif
Cà2(Op) Op
CMP Od , Os Compare (soustrait) les opérandes Os et Od et positionne

les drapeaux en fonction du résultat. L’opérande Od n’est pas modifié
Multiplication
MUL Op instruction à un seul opérande. Elle effectue une multiplication

non signée entre l'accumulateur (AL ou AX) et l'opérande Op. Le résultat
de taille double est stocké dans l'accumulateur et son extension (AH:AL ou
DX:AX).
MUL Op8 AL x Op8 → AX
MUL Op16 AX x Op16 → DX:AX
• L'opérande Op ne peut pas être une donnée, c’est soit un registre soit
une position mémoire, dans ce dernier cas, il faut préciser la taille (byte ou
word)
MUL BL ; AL x BL → AX
MUL CX ; AX x CX → DX:AX
MUL byte [BX] ; AL x (octet pointé par BX) → AX
MUL word [BX] ; AX x (word pointé par BX) → DX :AX
• Les drapeaux C et O sont positionnés si la partie haute du résultat est

non nulle. La partie haute est AH pour la multiplication 8 bits et DX pour la
multiplication 16 bits
IMUL Op (Integer Multiply ) Identique à MUL excepté qu'une

multiplication signée est effectuée.
Division
DIV Op Effectue la division AX/Op8 ou (DX|AX)/Op16 selon la taille de Op

qui doit être soit un registre soit une mémoire. Dans le dernier cas il faut
préciser la taille de l’opérande, exemple : DIV byte [adresse] ou DIV word
[adresse].
DIV Op8 ;AX / Op8 , Quotient → AL , Reste → AH

DIV S16 ;DX:AX / S16 , Quotient → AX , Reste → DX
- S ne peut pas être une donnée (immédiat)
22
- Après la division L'état des indicateurs est indéfini

- La division par 0 déclenche une erreur
IDIV Op Identique à DIV mais effectue une division signée
CBW (Convert Byte to Word) Effectue une extension de AL dans AH. On

écrit le contenu de AL dans AX 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.
+5 = 0000 0101 ⇒ 0000 0000 0000 0101

5 = 1111 1011 ⇒ 1111 1111 1111 1011
CWD (Convert Word to Double Word ) effectue une extension de AX dans

DX en respectant le signe. On écrit AX dans le registre 32 bits obtenu en
collant DX et AX
2.5.3 Les instructions logiques
NOT Op Complément à 1 de l'opérande Op
AND Od , Os ET logique
Od ET Os Od
OR Od , Os OU logique
Od OU Os Od
XOR Od , Os OU exclusif logique

Od OUX Os Od
TEST Od , Os Similaire à AND mais ne retourne pas de résultat dans Od,
seuls les indicateurs sont positionnés
2.5.4 Les masques logiques :
Le 8086 ne possède pas d'instructions permettant d'agir sur un seul bit.

Les masques logiques sont des astuces qui permettent d'utiliser les
instructions logiques vues si dessus pour agir sur un bit spécifique d'un
octet out d'un word
Forcer un bit à 0 :
23
Pour forcer un bit à 0 sans modifier les autres bits, on utilise l'opérateur
logique AND et ces propriétés :
- x AND 0 = 0 (0 = élément absorbant de AND)

- x AND 1 = x (1 = élément neutre de AND)
On fait un AND avec une valeur contenant des 0 en face des bits qu'il faut
forcer à 0 et des 1 en face des bits qu'il ne faut pas changer
Forcer un bit à 1 :
Pour forcer un bit à 1 sans modifier les autres bits, on utilise l'opérateur
logique OR et ces propriétés :
- x OR 1 = 1 (1 = élément absorbant de OR)

- x OR 0 = x (0 = élément neutre de OR)
On fait un OR avec une valeur contenant des 1 en face des bits qu'il faut
forcer à 1 et des 0 en face des bits qu'il ne faut pas changer
Inverser un bit :
Pour inverser la valeur d'un bit sans modifier les autres bits, on utilise
l'opérateur logique XOR et ces propriétés :
- X XOR 1 = X
- X XOR 0 = X (0 = élément neutre de XOR)
Donc, on fait un XOR avec une valeur contenant des 1 en face des bits
qu'il faut inverser et des 0 en face des bits qu'il ne faut pas changer
24
2.5.5 Les instructions de décalage
Dans les instructions de décalage, l'opérande k peut être soit une

constante (immédiat) soit le registre CL :
INST AX,1 ; décaler AX de 1 bit

INST BL,4 ; décaler BL de 4 bits
INST BX,CL ; décaler BX de CL bits
On peut aussi décaler le contenu d'une case mémoire mais il faut préciser
la taille
INST byte [BX],1 ; décaler une fois le contenu de la case

mémoire d'adresse BX
SHL R/M,k (SHift Logical Left) décalage logique à gauche de k bits
SAL R/M,k (SHift Arithmé Left) décalage arithmétique à gauche
SHR R/M,k (SHift Logical right ) décalage logique à droite
SAR R/M,k (SHift Arithmetic right ) décalage arithmétique à droite
Les décalages arithmétiques permettent de conserver le signe. Ils sont

utilisés pour effectuer des opérations arithmétiques comme des
multiplications et des divisions par 2.
ROL R/M,k (Rotate Left ) Rotation à gauche
25
ROR R/M,k (Rotate Right ) Rotation à droite
RCL R/M,k (Rotate Through CF Left ) Rotation à gauche à travers le Carry
RCR R/M,k (Rotate Through CF Right) Rotation à droite à travers le Carry
2.5.6 Instructions agissant sur les indicateurs
CLC (CLear Carry) positionne le drapeau C à 0

STC (Set Carry) positionne le drapeau C à 1
CMC Complémente le drapeau C
CLD Positionne le Drapeau D à 0
STD Positionne le Drapeau D à
CLI Positionne le Drapeau I à 0
STI Positionne le Drapeau I à 1
LAHF Copier l'octet bas du registre d'état dans AH.
SAHF Opération inverse de LAHF : Transfert AH dans l'octet bas du
registre d'état
PUSHF Empile le registre d'état,
POPF Dépile le registre d'état,
26
2.5.7 Les instructions de contrôle de boucle
LOOP xyz L'instruction loop 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 xyz, sinon il continue le programme à la ligne
suivante
Remarque sur l'étiquette :
L'étiquette est une chaîne quelconque qui permet de repérer une ligne. Le
caractère ':' à la fin de l'étiquette n'est obligatoire que si l'étiquette est
seule sur la ligne
LOOPZ xyz (Loop While Zero) Décrémente le registre CX (aucun flag

n'est positionné) on reboucle vers la ligne xyz tant que CX est différent de
zéro et le flag Z est égal à 1. La condition supplémentaire sur Z, donne la
possibilité de quitter une boucle avant que CX ne soit égal à zéro.
LOOPNZ xyz Décrémente le registre CX et reboucle vers la ligne xyz tant

que CX est différent de zéro et le flag Z est égal à 0. Fonctionne de la
même façon que loopz,
JCXZ xyz branchement à la ligne xyz si CX = 0 indépendamment de

l'indicateur Z
2.5.8 Les instructions de branchement
2 types de branchement sont possibles :
Branchements inconditionnels
Branchements conditionnels
Appel de fonction ou d’interruptions
Tous ces transferts provoquent la poursuite de l'exécution du programme

à partir d'une nouvelle position du code. Les transferts conditionnels se
27
font dans une marge de -128 à +127 octets à partir de la position de

transfert.
• Branchements inconditionnels
JMP xyz Provoque un saut sans condition à la ligne portant l'étiquette xyz.
CALL xyz Appel d'une procédure (sous programme) qui commence à la

ligne xyz.
La position de l'instruction suivant le CALL est empilée pour assurer une

poursuite correcte après l'exécution du sous programme.
RET Retour de sous programme. L'exécution du programme continue à la

position récupérée dans la pile.
INT n appel à l’interruption logicielle n° n
• Branchements conditionnels
Les branchements conditionnels sont conditionnés par l'état des

indicateurs (drapeaux) qui sont eux même positionnés par les instructions
précédentes.
Dans la suite nous allons utiliser la terminologie :
- supérieur ou inférieur pour les nombres non signés

- plus petit ou plus grand pour les nombres signés
- + pour l'opérateur logique OU JE/JZ xyz (Jump if Equal or Zero ) Aller à
la ligne xyz si résultat nul ou si égalité. C'est-à-dire si Z=1
JNE/JNZ xyz (Jump if Not Equal or Not Zero ) Aller à la ligne xyz si
résultat non nul ou si différent. C'est-à-dire si Z=0
28
JA xyz (Jump if Above ) aller à la ligne xyz si supérieur (non signé). C'est-
à-dire si
C+Z=0
JAE xyz (Jump if Above or Equal ) aller à la ligne xyz si supérieur ou égal
(non signé). C'est-à-dire si C = 0
JB xyz (Jump if Bellow) Branche si inférieur (non signé). C'est-à-dire si C =

1
JBE xyz (Jump if Bellow or Equal ) aller à la ligne xyz si inférieur ou égal
(non signé). C'est-à-dire si C + Z = 1
JC xyz (Jump if CArry ) aller à la ligne xyz s'il y a retenu. C'est-à-dire si C

=1
JNC xyz (Jump if No CArry) aller à la ligne xyz s'il n'y a pas de retenu.
C'est-à-dire si C = 0
JG xyz (Jump if Grater) aller à la ligne xyz si plus grand (signé). C'est-à-
dire si (S ⊕ O) + Z = 1
JGE xyz (Jump if Grater or Equal ) aller à la ligne xyz si plus grand ou égal
(signé). C'est-à-dire si S ⊕ O = 0
JL xyz (Jump if Less) aller à la ligne xyz si plus petit (signé). C'est-à-dire si
S⊕ O=1
JLE xyz (Jump if Less or Equal) aller à la ligne xyz si plus petit ou égal
(signé).
C'est-à-dire si (S ⊕ O) + Z = 1
JO xyz (Jump if Overflow) aller à la ligne xyz si dépassement. C'est-à-dire

si O = 1
JNO xyz (Jump if No Overflow) aller à la ligne xyz s'il n'y a pas de
dépassement O = 0
JP/JPE xyz (Jump if Parity or Parity Even) aller à la ligne xyz si parité
paire. C'est-àdire si P = 1
JNP/JPO xyz (Jump if No Parity or if Parity Odd) aller à la ligne xyz si

parité impaire. C'est-à-dire si P = 0
JS xyz (Jump if Sign) aller à la ligne xyz si signe négatif. C'est-à-dire si S =

1
29
JNS xyz (Jump if No Sign) aller à la ligne xyz si signe positif. C'est-à-dire si
S=0
2.5.9 Instructions d'accès aux ports d'E/S
IN AL/AX,port lire un port d’entrée sortie.

IN AL , port ; charge le contenu du port d’adresse port dans AL
IN AX , port ; charge le contenu du port d’adresse port dans AL et le
contenu du port d’adresse port+1 dans AH
Si l'adresse port tient sur 8 bits, elle peut être précisée immédiatement,
sinon il faut passer par le registre DX
IN AL , 4Dh MOV DX , 378h

IN AL , DX
OUT port , AL/AX Ecriture dans un port d’E/S

L’adressage du port se fait de la même façon que pou IN
Out port , AX ; écrit AL dans port et AH dans port+1
30
Tableau récapitulatif des jeux d’instruction
* : Positionné selon le résultat

? : Modifié, résultat non défini
31
3. L’ASSEMBLEUR NASM
La syntaxe des mnémoniques que nous avons utilisée jusqu’à présent est
la syntaxe de l’assembleur NASM. Rappelons que le rôle de l’assembleur
est de convertir le programme source écrit en mnémonique en codes
machines compréhensible par le processeur.
3.1 LES DIRECTIVES DE NASM
Les directives ne sont pas des instructions du 8086, elles sont destinées à
l'assembleur qui les utilise pour savoir de quelle manière il doit travailler.
• BITS
Cette directive indique à NASM s'il doit produire un code 16 bits ou un

code 32 bits.
Elle est utilisée sous la forme : BITS 16 ou BITS 32
• ORG
Cette directive indique à l'assembleur l'adresse à partir de laquelle le

programme sera implanté dans la RAM. Pour les programmes ".com",
cette adresse doit être 100h
• SEGMENT
Cette directive précise dans quel segment, les instructions ou les données
qui la suivent seront assemblées :
SEGMENT .text
Les instructions ou les données initialisée (par db ou dw) qui suivent cette
'déclaration' seront placé dans le segment programme (Code segment)
SEGMENT .data
Les données (initialisée) déclarée après cette directive sont placée dans le
segment de données (Data segment)
SEGMENT .bss
Les données déclarées après cette directive seront placées dans le

segment de données mais cette partie est réservée à la déclaration des
variables non initialisée.
32
• %INCLUDE
Comme en langage C, cette directive permet d'inclure un fichier source
avant la compilation.
• EQU : Définition de constante mille EQU 1000
Chaque fois que l'assembleur rencontrera la chaîne mille, il la remplacera

par le nombre 1000 (tout simplement).
• %DEFINE
La directive %define permet de définir une constante un peut de la même

façon que la directive EQU. La différence subtile est que %define définit
une macro qu'on peur redéfinir dans la suite du programme ce qui n'est
pas possible avec EQU.
3.2 LES PSEUDO INSTRUCTION DE NASM
Les pseudo instructions ne sont pas des instructions du 8086. Elles ne

seront donc pas traduites en langage machine lors de l'assemblage. NASM
les interprète et réalise les fonctions correspondantes. Les pseudo
instructions les plus courantes servent à la déclaration des variables
initialisées ou non initialisées, définition de constantes et la répétition des
instructions :
db : (define byte) définit une variable initialisée de 1 octet

dw : (define word) définit une variable initialisée de 2 octets
resb : réserve un octet pour une variable non initialisée
resw : réserve un mot de 2 octets pour une variable non initialisée
3.3 LES EXPRESSIONS
NASM peut évaluer des expressions entre constantes. Les opérateur

reconnus sont : +, - , * : addition, soustraction et multiplication
/ : division non signée

// : division signée
% : modulo non signé
%% : modulo signé
~ : complément logique
& : ET logique
| : OU logique
^ : XOR logique
≪ : décalage à gauche
≫ : décalage à droite
x equ 0F00h
33
mov ax,(2*x+6)/2
mov ax,x << 4
mov ax,(x >> 8)+(x << 4)
mov ax,x & x >> 4; >> est prioritaire sur &
mov ax,x | x >> 4; >> est prioritaire sur |
Attention, les expressions ne peuvent être utilisés qu’avec des constantes.

On ne peut pas avoir des choses du genre : MOV AX , DX+2
4. LES ENTREE SORTIES
Pour faire des entrées sorties (essentiellement avec l’écran et le clavier),

on passe par des interruptions du BIOS ou du DOS. Nous n'allons voir ici
que ce dont nous avons besoin.
4.1 L'interruption 10h du BIOS
Le BIOS est de relativement bas niveau et dépend fortement de la

machine.
L'interruption 10h peut effectuer beaucoup de fonctions différentes, le
numéro de la fonction désirée doit être place dans AH avant l'appel de
l'interruption. Nous ne parlerons ici que de quelques fonctions.
• Fonction 00
Cette fonction permet de choisir un mode texte ou un mode graphique. En

changeant de mode, on peut effacer l'écran, ce qui fait que l'on peut
appeler cette fonction pour effacer l'écran et rester dans le même mode.
Paramètre :
AH = 00
34
• Pour les modes texte, on peut doubler le nombre de ligne en chargeant

un jeux de caractère de hauteur 8 pixels. Voir fonction 11
• Pour ne pas effacer l'écran, placer le bit 7 de AL à 1 (Ajouter 80h)
• Fonction 09
Cette fonction permet d'écrire un caractère
- Permet les répétitions,

- Gère la couleur en mode texte et en mode graphique,
- Ne gère pas le curseur.
Paramètres : AH = 09h
AL = caractère à écrire
BH = page écran
BL = attribut de couleur (RVB :111=Blanc, 000=Noir)
CX = nombre de fois
35
Les caractères spéciaux ne sont pas reconnus (le 7 ne fait pas bip). Le bit
7 de la couleur fait un ou exclusif en mode graphique et un clignotement
(uniquement en mode plein écran) en mode texte.
En mode graphique, l'attribut de couleur ne concerne que le caractère ou

le pixel, il n'agit pas sur la couleur de l'arrière plan. Ceci est valable pour
les autres fonctions qui gèrent la couleur.
• Fonction 0Eh
Cette fonction permet d'écrire un caractère,
- Fonctionne en mode graphique,

- Gère le curseur
- Gère la couleur seulement en mode graphique. Seule la couleur du
caractère est gérée, la couleur du fond n’est pas gérée.
Paramètres : AH = 0Eh
AL = code ascii du caractère à écrire

BL = couleur du caractère (mode graphique uniquement).
Les caractères spéciaux sont reconnus :

- 10 (LF : Line Feed ) descend le curseur d'une ligne
- 13 (CR : Carriage Return ) ramène le curseur en début de lignes
- 08 (BS : Back Space ) ramène le curseur d'une position à gauche
- 07 (BEL) fait bip
mov ah,0Eh ; affiche le caractère A à la position courante du curseur

mov al,'A'
int 10h
• Fonction 02
Cette fonction permet de positionner le curseur où on le désire, dans la

page courante ou dans une page cachée.
36
BH = numéro de la page
DH = ligne (ordonnée)
DL = colonne (abscisse)
En mode 25x80 les cordonnées vont de (0,0) à (24,79).
• Fonction 05
Cette fonction permet de sélectionner la page active de l'affichage.

AL = numéro de la page
• Fonction 11h, sous fonction 12h
Cette fonction permet de charger le jeu de caractère de hauteur 8 pixels

pour avoir un écran de 50 lignes. (Cette fonction doit être appelée après la
fonction 00)
Paramètres
AX = 1112h
BL = 30h (08h semble marcher aussi)
• Fonction 0Ch : allumer un pixel
AH = 0Ch
BH = 0 (numéro de page)
AL = couleur du pixel
si bit 7 = 1 on trace en mode XOR sauf en mode 256 couleur
CX = x (abscisse)
DX = y (ordonnée)
4.2 L'interruption 21h du DOS
Normalement le DOS est de relativement haut niveau et ne dépend pas de

la machine.
Il fait souvent appel au bios qui fonctionne à un niveau plus proche de la
machine.
L'interruption 21h peut réaliser plusieurs fonctions différentes. Nous ne
citerons ici que celles que nous utiliserons.
• Fonction 02
Cette fonction permet d'écrire un caractère. Le caractère est envoyé vers

la sortie standard, l'écriture peut donc être redirigée dans un fichier.
DL = Caractère à écrire
37
• Fonction 09
Cette fonction permet en un seul appel, d'écrire une suite de caractères.

DX = Adresse de la chaîne de caractères
La chaîne doit être terminée par le caractère $
Remarque : Cette interruption retourne $ dans le registre AL et ceci

même si la documentation officielle affirme le contraire. Donc attention,
si vous avez quelque chose dans AL avant d'appeler cette interruption,
ce sera perdu
Exemple : (phrase.asm)
;*********************************************************
; affiche une phrase … l'aide de int21_fct09
;*********************************************************
BITS 16
ORG 0x0100
SEGMENT .data
txt db 'MON PREMIER PROGRAMME NASM$'
SEGMENT .text
MOV AH,9 ; fonction 9 de int21
MOV DX,txt ; adresse du début de la phrase
INT 21h ; écrit la phrase
MOV AX,4C00h ; fin programme
int 21h
Remarque :
• Pour revenir à la ligne à la fin de la chaîne : ’Bonjour’,10,13 ,’$’

• Si la chaîne contient apostrophe : ’Ecole d’ingénieurs’ → ’Ecole
d’,39,’ingénieurs$’
• Fonction 07
Cette fonction permet de lire un caractère du clavier sans qu'il n'y ait
d'écho à l'écran.
Paramètre passé : AH = 07
Paramètre retourné : AL = caractère lu
Les touches fonction retourne 2 caractères, d'abord un octet nul, puis le
code étendu de la touche, il faut donc faire 2 appels consécutifs de la
fonction 07.
• Fonction 0Bh
38
Cette fonction permet de savoir si un caractère est disponible dans la

mémoire tampon du clavier. Elle est l'équivalente de la fonction kbhit (du
C) ou de Keypressed (du Pascal). Il ne faut pas oublier de vider le buffer
par une lecture à l'aide de la fonction 07 ou 08, sinon on risque d'avoir des
surprises à la prochaine lecture du clavier.
Paramètre passé : AH = 0B
Paramètre retourné : AL = 0 ⇒ aucun caractère n'a été tapé
AL = 255 (-1) ⇒ au moins un caractère a été tapé
• Fonction 0Ah
Permet de saisir une chaîne de caractère au clavier. La saisie s'arrête

quand on tape la touche , le caractère CR (13) est mémorisé avec la
chaîne
Paramètre :
DX : adresse du buffer (zone mémoire tampon) où seront stockés la
longueur de la chaîne ainsi que la chaîne saisie
[DX] : longueur max. avant d'appeler la fonction, il faut placer dans le
premier octet du buffer la longueur max à ne pas dépasser, il faut
compter le CR.
Une fois la saisie terminée, la fonction place dans le deuxième octet du
buffer le nombre de caractère effectivement saisi. La chaîne saisie est
placée tous de suite derrière.
4.3 ACCES DIRECT A LA MEMOIRE VIDEO
La mémoire vidéo est une zone mémoire qui constitue une image de
l’écran. Si on écrit quelque chose dans cette mémoire, elle apparaît à
l’écran.
En mode texte, à chaque position de l’écran, correspondent deux positions

(octets) de la mémoire vidéo. Le premier octet correspond au caractère
affiché, le deuxième correspond à son attribut de couleur. La première
39
paire d'octets représente le caractère en haut à gauche de l'écran Pour le

codage de la couleur, voir int 10h, fonction 09.
La mémoire écran commence à l’adresse B8000h correspondant à

l’adresse Segment:Offset = B800:0000
Si l’écran est configuré en mode 80 caractères par ligne. Chaque ligne

correspond à
160 octets dans la mémoire vidéo. Pour écrire un "A" en rouge sur noir à la
colonne 20 de la ligne 10, il faudra écrire ‘A’=65=41h (code ascii de A) à
la position 10*160 + 20*2 = 1640 et 04 dans la position suivante. La ligne
0 débute à la position mémoire 0, la ligne 1 à la position 160..., la ligne 10
à la position 1600 …
Quand on programme en assembleur sur un PC, la modification de la

valeur du segment DS peut donner des résultats inatendus. Nous
utiliserons donc le registre segment ES pour accéder à la mémoire vidéo.
4.4 LES TEMPORISATIONS
On peut faire une temporisation en répétant plusieurs fois des instructions

qui ne font rien. Cette méthode à l'inconvénient de dépendre de l'horloge
système et ne donnera pas le même effet sur des machines différentes.
Une autre méthode consisterait à se servir du balayage de l'écran qui est

à peu près le même sur toutes les machines. L'écran d'un ordinateur est
balayé ligne par ligne, de haut en bas, par un spot d'électrons. Le
balayage de tout l'écran dure à peu près 1/60 s. quand le spot arrive au
coin bas-droite, il remonte directement au point haut-gauche pour
recommencer. Pendant le balayage de l'écran, le bit 3 (4ème) du port
03DAh est égal 0, pendant le retour 'vertical' du spot, ce bit est placé à 1.
40
On peut donc essayer de faire une temporisation de l'ordre de 1/70 s en

surveillant le retour du spot. Dans ce qui suit, le bit 3 du port 03DAh sera
désigné par 'spot'.
Un appel unique à cette temporisation n'est pas intéressant car il peut

contenir une erreur importante dépendant de la position du spot dans
l'écran au moment de l'appel.
Mais si on la répète plusieurs fois pour faire des temporisations plus
longues, l'erreur est minimisée car c'est seulement le premier appel qui ne
donne pas une temporisation précise. Si on la répète N fois on obtient une
temporisation de l’ordre de N x 1/70 s
41

Syllabus Assembleur

Transféré par

Droits d'auteur :

Formats disponibles

Syllabus Assembleur

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Syllabus Assembleur

Transféré par

Droits d'auteur :

Formats disponibles

Première année / 2010

Pourquoi un cours sur les Microprocesseurs et l'assembleur ? : Parce que

d'autres langages plus évolué comme le Pascal, le C/C++, et les langages

Pourquoi le 8086 d'Intel ? : Parce que la majeure partie des Ordinateurs

Attention : Le 8086 est un microprocesseur qui était destiné à fonctionner

Les processeurs actuels fonctionnent en mode protégé. Ils interagissent

élémentaire comme une addition par exemple. Avec un langage de haut

Un processeur quel qu'il soit sait exécuter un ensemble bien défini de

Par exemple, l'instruction (assembleur) MOV BP,41h qui signifie : placer le

En fait, les lignes de programme que nous écrivons constituent ce qu'on

L'intérêt du langage assembleur est que chaque instruction que nous

Quand on demande l'exécution d'un programme, celui-ci est chargé par le

1. STRUCTURE D’UN PROCESSEUR EN GENERAL

Les différents constituants du Processeur peuvent être regroupés dans

1.1 L'UNITE DE CALCUL

Elle est constituée de l’Unité Arithmétique et logique UAL et d’un certain

Ce sont des mémoires élémentaires pouvant contenir chacun un

1.2 L'UNITE DE CONTROL

C'est l'unité de control qui supervise le déroulement de toutes les

C'est l'horloge qui génère les signaux qui permettent le cadencement et la

Le compteur programme (PC : program counter) est un registre (pointeur)

incrémenté automatiquement chaque fois qu'un élément d'instruction est

C'est là où le CPU stocke l'instruction en cours d'exécution.

C'est lui qui va "décoder" l'instruction contenue dans RI et générer les

Il gère le séquencement des opérations et génère les signaux de

Le registre d'état est formé de plusieurs bits appelés drapeaux ou

L’indicateur C indique que l'opération a généré une retenue. Le bit N

Disponible depuis 1987, le 8086 fut le premier microprocesseur 16 bits

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

• Il possède un bus multiplexé adresse/donnée de 20 bits.

• Le bus de donnée occupe 16 bits ce qui permet d'échanger des mots

• Le bus d'adresse occupe 20 bits ce qui permet d'adresser 1 Moctets

• Il est entièrement compatible avec le 8088, le jeu d'instruction est

2.1 LA SEGMENTATION DE LA MEMOIRE

font que 16 bits soit 4 digits au maximum en hexadécimal. La solution

A titre d'exemple, procédons au découpage de la mémoire en 16

Considérons la case mémoire d'adresse 20350, appelée adresse absolue

Se pose maintenant le problème de la représentation de cette adresse au

- Dans le registre segment, on écrit l'adresse segment sans le chiffre de

Dans notre exemple, l'adresse de la case mémoire considérée devient

L'adresse absolue est calculée ainsi :

2.2 LES REGISTRES DU 8086

Tous les registres et le bus interne du 8086 sont structurés en 16 bits.

2.2.1 Les registres généraux

Les registres généraux participent aux opérations arithmétiques et

2.2.2 Les registres d'adressage (offset)

Ces registres de 16 bits permettent l'adressage d'un opérande à l'intérieur

• Utilisé pour l'accès à la pile. Pointe sur la tête de la pile.

SI : Registre d'index (source)

• Certaines instruction de déplacement de donnés l'utilise comme index

DI : Registre d'index (destination)

2.2.3 Les registres de segment

Définit le début de la mémoire programme. Les adresses des différentes

Début de la mémoire de données dans laquelle sont stockées toutes les

Début d'un segment auxiliaire pour données

2.2.4 Le registre d'état (flags)

Six bits reflètent les résultats d'une opération arithmétique ou logique et 3

C : (Carry) indique le dépassement de capacité de 1 sur une opération 8

P : (Parité) indique que le nombre de 1 est un nombre pair. Ce flag est