École Nationale des Sciences de

l’Informatique

Module :Architecture des Ordinateurs

Chapitre 5: Programmation Assembleur 8086

A.U. 2019-2020
 Méthodes de programmation

Etapes de la réalisation d’un programme :

 Définir le problème à résoudre : que faut-il faire exactement ?
 Déterminer des algorithmes, des organigrammes : comment faire? Par quoi
commencer, puis poursuivre ?
 Rédiger le programme (code source) :
utilisation du jeu d’instructions (mnémoniques) ;
création de documents explicatifs (documentation).
 Tester le programme en réel ;
 Corriger les erreurs (bugs) éventuelles : déboguer le programme puis refaire des
tests jusqu’à obtention d’un programme fonctionnant de manière satisfaisante.

Langage machine et assembleur :

 Langage machine : codes binaires correspondant aux instructions ;
 Assembleur : logiciel de traduction du code source écrit en langage assembleur
(mnémoniques).
Les directives: Déclaration des variables
 Autres instructions
L'instruction XCHG.
Syntaxe: XCHG opérande1,opérande2
opérande1 = registre de donnée/case mémoire
opérande2 = registre de donnée
Exemple: XCHG AX,Somme: échange des contenus de AX et de Somme
Les instructions d'incrémentation et décrémentation: INC et DEC.
Syntaxe: INC Opérande
DEC Opérande
Opérande = registre/case mémoire
Fonction: INC fait +1 sur l'opérande
DEC fait -1 sur l'opérande
Exemples:
INC AX ; AX:= AX + 1
DEC CX ; CX:= CX - 1
DEC WORD PTR Valeur ; Valeur:= Valeur - 1

4
Les instructions de boucle: LOOP, LOOPE et LOOPNE
Ces instructions permettent de programmer les structures itératives:
do { instructions } While (condition), While (condition) {instructions},...
Elles utilisent le registre CX comme décompteur. Aussi il est recommandé de ne
pas modifier CX à l'intérieur de la boucle. Ce registre CX doit être initialisé à
une valeur positive avant l'entrée dans la boucle.

Syntaxe:
LOOP etiquette
LOOPE etiquette
LOOPNE etiquette

LOOP décrémente le contenu de CX et le compare à 0; si CX est encore positif, il y

a branchement à étiquette.

LOOPE décrémente le contenu de CX et le compare à 0; si CX est encore positif et

le flag Z est à 1, il y a branchement à étiquette.

LOOPNE décrémente le contenu de CX et le compare à 0; si CX est encore positif

et le flag Z est à 0, il y a branchement à étiquette.
5
Ecrire un programme qui permet de remplir 4
octets d’un tableau tab avec la valeur 55h

Autre façon pur débuter un tableau

tab db 4 dup(?)
mov cx,4
mov si,0
et1:mov tab
[si],55h
inc si
loop et1
hlt
Interruptions de saisie et d’affichage
Pour réaliser les opérations standards (affichage, saisie), on utilise les fonctions pré-
écrites suivantes:

Saisie d’un caratère: mov AH, 1 ; fonction no. 1

(avec écho) int 21h ; résultat est mis dans AL

Saisie d’un caractère mov AH, 7 ; fonction no. 7

(sans écho) int 21h ; résultat dans AL

Affichage d’un caratère: mov DL, “A”; caractère A est transfére dans DL
mov AH, 2; fonction no. 2
int 21h ; appel au DOS
Affichage d’une chaine de caractères:
mov DX, offset chaine; ou bien Lea DX, offset chaine
mov AH, 09; fonction no. 9
int 21h;
Arrêt de programme: hlt ou bien int 20h;
À mettre à la fin de chaque fin programme; c’est l’équivalent du return (0) en C. Ces
instructions ont pour effet de retourner au DOS
Saisie d’un caratère: Saisie du caractére avec affichage
code ASCI I du caractére est mis dans AL
mov AH, 1;
int 21h ;

8
Saisie d’un caractère Saisie du caractére sans affichage
code ASCI I du caractére est mis dans AL
mov AH, 7 On va saisir la lettre A
int 21h

Pour saisir et afficher A

Pour réaliser les opérations standards (affichage, saisie), le système
d’exploitation (ici DOS) fournit les fonctions pré-écrites suivantes:

Affichage d’un caratère:

mov DL, “A”; caractère A est transfére dans DL
mov AH, 2; fonction no. 2
int 21h ;

10
exemple
mov ah,07
Int 21h;
Mov dl,al
Mov ah,02
Int 21h

Arrêt de programme: mov AX, 4C00h;

int 21h;
À mettre à la fin de chaque fin programme; c’est l’équivalent du
return (0) en C. Ces instructions ont pour effet de retourner au DOS
11
 Exemples
Affichage d’une chaine de caractères:
mov DX, offset chaine; adresse de caractère de la
chaîne de caractére
mov AH, 09h; fonction no. 9
int 21h; mov DX, offset message
mov ah,09h
int 21h
message db " Bonjour ing2D $"
ret
Exemple1 : afficher en binaire la suite :10110110b

Exemple2: afficher les lettres alphabets

mov bl,10110110b mov dl,"A“

mov cx,8 mov cx,26
boucle:shl bl,1 encore: mov ah,2
jc affich1 int 21h
mov dl,'0' inc dl
mov ah,2 loop encore
int 21h mov ax,4C00H int 21h
loop boucle
jmp fin
affich1: mov dl,'1'
mov ah,2
int 21h
loop boucle
fin:ret
Somme de deux nombre en hexa et affichage en binaire

jmp start
TAB dw 2 dup(0xFD33h,0xE355h)
somme dw ?
start:
mov cx,2
mov si,0

ET1:mov bx,TAB[SI]
add somme,bx ;1110000010001000
add si ,2
loop et1
mov cx,16
boucle:shl somme,1
jc affich1
mov dl,'0'
mov ah,2
int 21h
loop boucle
jmp fin
affich1: mov dl,'1'
mov ah,2
int 21h
loop boucle
fin:ret
Avec affichage
bl=10101010
;si le bit 7=1 on faitune serie de 4 decalage de al vers gauche
;sinon un seul decalage vers la droire de bl

mov bl,00101010b
mov al,bl
and bl,10000000b ;X0000000
JZ dec_shr
mov bl,al
mov cl,4
shl bl,cl;bl=A0
mov cx,8
boucle:shl bl,1
jc affich1
mov dl,'0'
mov ah,2
int 21h
loop boucle
jmp fin
affich1: mov dl,'1'
mov ah,2
int 21h
loop boucle

jmp fin

dec_shr: mov bl,al

shr bl,1
mov cx,8
boucle1:shl bl,1
jc affich2
mov dl,'0'
mov ah,2
int 21h
loop boucle
jmp fin
affich2: mov dl,'1'
mov ah,2
int 21h
loop boucle1
fin: ret
 PUSH source : (la pile)←(source).
POP destination : (destination)←(la pile)
source destination Exemples
Registre de travail 16 bits Mémoire (mot) Registre de travail 16 bits Mémoire (mot) PUSH AX; POP AX
Registre de segment Registre de segment (sauf CS) Push DS ; pop DS
Push CS ;
Push ES ; pop ES
Push SS ; pop SS
Le pointeur de pile (en combinaison avec le segment de pile SS) pointe vers le dessus de la pile (TOS : top
of stack) en mémoire. Une pile est un ensemble de données placées en mémoire de manière à ce que
seulement la donnée du "dessus" soit disponible à un instant donné. Le pointeur de pile (SP) donne donc
l'adresse en mémoire de cette pile temporaire.
Les  piles  offrent  un  nouveau  moyen  d'accéder  à  des  données  en mémoire principale, qui est très
utilisé pour stocker temporairement des valeurs.
Le schéma suivant montre comment une valeur est stocker dans la pile (pushed) et comment elle est
récupérée (poped) :
La pile peut également servir à sauvegarder le contenu de registres qui ne sont pas
automatiquement sauvegardés lors de l’appel à un sous programme :
 instruction d’empilage : PUSH opérande
 instruction de dépilage : POP opérande
où opérande est un registre ou une donnée sur 2 octets (on ne peut empiler que des
mots de 16 bits).
Exemple :

MOV AX, 1212h ; store 1212h in AX.

MOV AX, 1234h
PUSH AX ; store value of AX in stack.
MOV AX, 5678h ; modify the AX value.
POP AX ; restore the original value of AX.
MOV BX, 3434h ; store 3434h in BX
PUSH AX ; store value of AX in stack.
PUSH BX ; store value of BX in stack.
POP AX ; set AX to original value of BX.
POP BX ; set BX to original value of AX.
 Exercice 1
Déterminer le contenu des registres AX, BX, CX et DX dans chaque ligne de
la séquence d’instructions ci-dessous sachant que ces registres contiennent
initialement les valeurs suivantes :
AX=9897H BX=5678H CX=1BCEH DX=4532H
La pile contient une seule valeur = 1F8BH
mov AX,9897H BX=FFFFH
mov BX,5678H SS:SP=FFFFH
mov CX,1BCEH AX=0
mov DX,4532H DX=0
OR BX,0xFFFFh AX=000Eh
PUSH BX AX=0DF2h
XOR AX,AX CX=FFFFh
AND DX,0000H SS=0DF2h
MOV AX,000EH DX=0DF2h
MUL BL BX=FFFFh
POP CX
PUSH AX
POP DX
OR BX,0100H 22
mov [200h],42h
mov [201h],3Bh

Mov al,[201h]
Mov bl, 0Fh
And al,bl
mov dl,al
mov al,[200h]
Mov bl, 0Fh
And al,bl ;
Mov cl,4
Shl al,cl
add al,dl

Mov [202h],al
 Exercice

jmp debut
TAB1 db 6 dup(05h,33h,00h,45h,0xEA,00h)
debut:
mov cx,6
mov si,0
mov bx,0
ET1:mov al,TAB1[SI]
cmp al,00h
jz null
inc si
loop ET1 ; dex cx cmp cx avec 0 si dif de
zero elle fait saut vers et1
jmp fin
null: inc bx
inc si
loop ET1
mov [400h],bx
fin: ret
 jmp debut
tab db 10h, 5h, 3h ,2h, 1h, 0h, 0XFh, 5h,
12h,10h
maxi db 0
adrmaxi db ?
debut:
mov cx, 10
mov si, 0
boucle: mov al, tab[si]
cmp al, maxi
jb etiqu
mov al, tab[si]
mov adrmaxi, si
mov maxi, al
etiqu: inc si

loop boucle
ret
 Affichage en héxa
jmp debut
var db 0

debut: mov ax,0xA8h;

mov var,ax
mov bl,var
and bl,0xF0h
mov cl,4
shr bl,cl
cmp bl,9h
jg affich_octet1
add bl,30h

mov dl,bl
mov ah,2
int 21h

jmp octet0
affich_octet1:add bl,37h
mov dl,bl
mov ah,2
int 21h

octet0: mov bl,var

and bl,0x0Fh
cmp bl,9h
jg affich_octet0
add bl,30h
mov dl,bl
mov ah,2
int 21h

jmp fin
affich_octet0:add bl,37h
mov dl,bl
mov ah,2
int 21h

fin:ret