1ère Année - ENISO

Chapitre 4

Assembleur x86
 Les entrées Sorties en assembleur

• Pour réaliser les opérations standards (affichage, saisie), le sustème d’exploitation (ici
DOS) forunit 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
i t 21h
int ; appell au DOS

• Affichage d’un chaine de caractères: mov DX, offset chaine; pointe vers l’adresse du premier
caratère de la chaine de caractères chaine
mov AH, 09h; fonction no. 9
int 21h;
• Saisie d’un caratère: mov AH, 1; fonction no. 1
(avec écho) int 21h ; résultat est mis dans AL

2
 Les entrées Sorties en assembleur
(suite)

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

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

• Saisie d’une chaîne de caractère qui se termine par un retour chariot

mov AH, 0Ah ; fonction 0Ah et le mettre en mémoire pointé
;par DX
int 21h ; BL contient le code ascii du caractère saisie

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

Ell ontt pour effet

Elle ff t de
d retourner
t au DOS

3
 APPLICATION

Soit
i la
l déclaration
d l i dud segment de
d données
d suivante
i :

Data Segment
Chaine DB 15 dup(?)
p( )
message_1 DB ‘Bonjour$’
message_2 DB ‘Nous somme les étudiant LF2 STIC de l’ISIMM$’
Data ends

11. Pourquoi
P i on utilise
tili lel symbole
b l $
2. Ecrire un programme assembleur qui permet l’affichage des 2 message avec retour au ligne
5
 Opérations arithmétiques (entiers)

¾ ADD : addition
¾ ADC : addition avec retenue de 1 ajoutée si CF = 1
¾ SUB : soustraction
¾ SBB : soustraction avec retenue de -1 ajoutée si CF = 1
¾IMUL : multiplication avec entiers signés (résultat sur taille
double)
¾ MUL : multiplication avec entiers non signés (résultat sur taille
double)
¾ IDIV : division entière signée
¾ DIV : division entière non signée
¾ INC : incrémentation de 1
¾ DEC : décrémentation de 1
¾ NEG : opposé
¾ CMP : comparaison sous forme de soustraction sans
stockage résultat
 Les instructions d’addition
Instruction
Instr ction ADD : Addition
Fonction : Exécute une addition. Le résultat est dans « destination »
Syntaxe : Add Destination, Source ; Destination= Destination + Source

Instruction ADC : Addition with carry

Fonction : Exécute une addition avec retenu.
retenu Le résultat est dans
« destination »
Syntaxe : Add Destination, Source ; Destination
Destination= Destination + Source
Source+ carry (CF)

Instruction INC
Fonction : incrémentation
Syntaxe : Inc Destination ; Destination= Destination + 1
Exemple :
OF DF IF TF SF ZF AF PF CF
ADD BL,17
ADD CL,BL ** ‐‐ ‐‐ ‐‐ ** ** ** ** **
ADC CH, BH 7
 Les instructions de Soustraction
Instruction SUB : Subtract
Fonction : Exécute une soustraction. Le résultat est dans « destination »
S t
Syntaxe : SUB Destination
D ti ti ,Source
S ; Destination=
D ti ti Destination
D ti ti - Source
S

Instruction SBB : Subtract with carry

F
Fonction
i : Exécute
E é soustraction
i avec le
l retenu le l résultat
é l est dans d « destination
d i i »
Syntaxe : SBB Destination, Source ; Destination= Destination – Source - carry (CF)

IInstruction
t ti DEC
Fonction : décrémentation
Syntaxe : DEC Destination ; Destination= Destination - 1
Exemple :
SUB BL,17
SUB CL
CL,BL
BL
OF DF IF TF SF ZF AF PF CF
SBB CX, BH
** ‐‐ ‐‐ ‐‐ ** ** ** ** ** 8
 Instruction NEG : Negateg
Fonction : L'instruction NEG soustrait l'opérande de 0, en prenant son
complément à 2; elle affecte les flags à un de la même façon que
ll'instruction
instruction SUB, selon les conditions suivantes (sinon ils restent à 0):
Syntaxe : NEG Opérande ; Opérande = 0 - Opérande
Instruction CMP: Compare p
Fonction : L'instruction CMP effectue la même opération que SUB,
mais n'altère pas les opérandes et ne garde pas le résultat, elle a simplement
pour but le positionnement des flags à l'intention
l intention des instructions de saut
saut.
Syntaxe : CMP Destination,Source
OF DF IF TF SF ZF AF PF CF
Exemple : ** ‐‐ ‐‐ ‐‐ ** ** ** ** **
NEG AL ;complément à 2 de AL
CMP DX 27
DX,27

9
 Les instructions de Multiplication
Instruction MUL : Multiply
Fonction : Dans cette instruction, la source est un registre (double-
mot, mot ou octet) ou bien un emplacement mémoire, le second opérande
doit se trouver, s'il s'agit d'un octet, dans AL et dans AX pour un mot. Le
produit à double longueur, pour une multiplication à octets, est retourné dans
AX (octet haut dans AH et octet bas dans AL) et pour des mots mots, dans DX (mot
haut) et AX (mot bas)
Syntaxe : MUL Source
Instruction IMUL : Multiply signed
Fonction : Multiplication signé
OF DF IF TF SF ZF AF PF CF
Syntaxe : IMUL Source
** ‐‐ ‐‐ ‐‐ ? ? ? ? **
Exemple :
MOV AL,6 ;AL=6
MOV CL,8 ;on ne p
peut pas
p utiliser de valeur immédiate
IMUL CL ;AX= AL*CL
10
 Les instructions de division
Instruction DIV : Divide
Fonction : La source est un diviseur octet, mot ou double- mot se
trouvant dans un registre général ou un emplacement mémoire. Le dividende
est un opérande de double longueur se trouvant, soit dans AH et AL pour une
opération 8 bits, soit dans DX et AX pour une opération 16 bits. Dans le
premier cas,
cas le quotient est retourné dans AL et le reste dans AH; dans le
second cas le quotient est retourné dans AX et le reste dans DX.
Syntaxe : DIV Source
Instruction IDIV : Divide signed
Fonction : Division signé
OF DF IF TF SF ZF AF PF CF
Syntaxe : IDIV Source
** ‐‐ ‐‐ ‐‐ ? ? ? ? **
Exemple :
MOV AL,6 ;AL=6
MOV CL,8 ;on ne p
peut pas
p utiliser de valeur immédiate
IDIV CL ;AX= AL*CL
11
 Opérations logiques
4 opérations logiques : fonctionnement bit à bit
¾ AND : Et logique
¾ Application d'un masque sur une donnée : garde les bits de
la
¾donnée pour lesquels le masque est à 1, sinon met le bit à 0
¾ OR : OU logique
¾ XOR : XOR logique
¾ NOT : inverse les bits

¾ Exemples
¾ 0110 AND 0011 = 0010
¾ 0110 OR 0011
0011= 0111
¾ 0110 XOR 0011 = 0101
¾ NOT 0110 = 1001
 Les instructions de manipulation de bit

OF DF IF TF SF ZF AF PF CF
Instruction And: Et logique
0 ‐‐ ‐‐ ‐‐ ** ** ? ** 0
S t
Syntaxe :A
Andd destination,Source
d ti ti S
Fonction : Permet l’exécution de l’opération logique AND entre sourc
et destination et le résultat sera stocké dans destination.
Instruction OR: OU logique
Syntaxe : OR destination,Source
Fonction : Permet l’exécution
l exécution de l’opération
l opération logique OR entre source
destination et le résultat sera stocké dans destination.
Instruction XOR: OU exclusive
S t
Syntaxe : XOR destination,Source
d ti ti S
Fonction : Permet l’exécution de l’opération logique XOR entre sourc
et destination et le résultat sera stocké dans destination.

13
 Les instructions de manipulation de bit

Instruction NOT: opérateur

p logique
g q inverseur
Syntaxe : NOT Opérande
Fonction : Inverse les bits, forme le complément à 1 de l’opérande.
L’opérande
L opérande peut être un registre ou en mémoire
Instruction TEST: Comparaison logique
Syntaxe : TESTdestination,Source OF DF IF TF SF ZF AF PF CF
0 ‐‐ ‐‐ ‐‐ ** ** ? ** 0
Fonction : Compare les deux opérandes bit à bit sans fournir le
résultat TEST positionne les FLAGS. L
L’opération
opération de comparaison se
fait par un ET logique
Exemple:
suivant: Mov Ah,01; utilisé la fonction 01 de l’int 21h pour lire le clavier
Int 21H
TEST AL,”$” ; comparer le caractère lit à $
JNZ suivant;
i t sii all ne contient
ti t pas le
l code
d ascii ii de
d $ refaire
f i l’opération
l’ é ti de
d lecture
l t

14
 Décalage et rotations

8 opérations
1.
1 SAR : décalage arithmétiques droite
2. SHR : décalage logique droite
3. SAL : décalage arithmétique gauche
4. SHL : décalage logique gauche
5. ROL : rotation gauche
6. ROR : rotation droite
7. RCL : rotation gauche de la donnée + la retenue
8
8. RCR: rotation droite de la donnée + la retenue

¾ Dans les 8 cas : CF contient le bit q

qui sort de la donnée
 Les instructions de manipulation de bit

OF DF IF TF SF ZF AF PF CF
** ‐‐ ‐‐ ‐‐ ** ** ? ** **
Instruction SAL/SHL: Shift Arithmetic Left / Shift Logical Left
S t
Syntaxe : SAL destination,
d ti ti compteur
t / SHL destination,
d ti ti compteur
t
Fonction : décalage arithmétique ou logique à gauche. Le nombre
de décalage est spécifié par le compteur. Chaque décalage à
gauche est équivalent a une multiplication par 2
CF SAL/SHL (8‐16 bits) 0

Instruction SAR: Shift Arithmetic Right

Syntaxe : SAR destination, compteur
Fonction : décalage arithmétique à droite. Le nombre de décalage
est spécifié par le compteur.

SAR(8‐16 bits) CF
16
 Les instructions de manipulation de bit

Instruction SHR: Shift Logic Right

Syntaxe : SHR destination, compteur
F
Fonction
i : décalage
dé l logique
l i à droite.
d i Le L nombre
b ded décalage
dé l est
spécifié par le compteur. Chaque décalage à droite est équivalent a
une division par 2
0 SHR (8‐16 bits) CF

Exemple
p
Mov AX, 003Fh
Mov BX, 27E3H
SAL AL
AL,1
1
SHL AX,CL
SAR AL,Cl
SHR BX,1
17
 Les instructions de manipulation de bit

OF DF IF TF SF ZF AF PF CF
** ‐‐ ‐‐ ‐‐ ‐‐ ‐‐ ‐‐ ‐‐ **
Instruction RCL: Rotate Left through Carry
S t
Syntaxe : RCL d
destination,
ti ti compteur
t
Fonction : Rotation à gauche via l’indicateur de retenue CF.

CF RCL (8‐16 bits)

Instruction RCR: Rotate Right through Carry

Syntaxe : RCR destination, compteur
Fonction : Rotation à droite via CF.

RCR (8‐16 Bits) CF

18
 Les instructions de manipulation de bit

OF DF IF TF SF ZF AF PF CF
Instruction ROL: Rotate Left ** ‐‐ ‐‐ ‐‐ ‐‐ ‐‐ ‐‐ ‐‐ **
Syntaxe : ROL destination, compteur
Fonction : Rotation à gauche

CF ROL (8‐16 bits)

Instruction ROR: Rotate Right

Syntaxe : ROR destination, compteur
Fonction : Rotation à droite

ROR (8‐16 Bits) CF

19
 Les instructions de branchement

Instruction JMP: Jump

S t
Syntaxe : JMP cible
ibl
Fonction : cette instruction de saut inconditionnel à une adresse
autre que la suivante.
Instruction Call: Appel d’une procédure
Syntaxe : Call cible
F
Fonction
ti : l’appel
l’ l d’
d’une procédure.
éd C
Cette
tt iinstruction
t ti dédéclenche:
l h
Le rangement de CS puis IP dans la pile
Instruction Ret: Retour de procédure
Syntaxe : Ret
Fonction : Termine une procédure.

20
 Instructions de contrôle

¾ Par défaut, exécution séquentielle des instructions

¾ Possibilité de sauter à d'autres endroits du programme de 2
façons
1. Saut à une adresse du programme
2 Saut conditionnel à une adresse du programme
2.
 Instructions de contrôle

Dans le code du programme en assembleur

Pe t placer des labels pour
Peut po r marquer
marq er un
n endroit de la
séquence d'instructions
Instruction de saut : JMP
JMP label
Exemple
MOV AX, [1000h]
MOV BX, [1004h]
JMP calcul
Suite: MOV [BX],AX
..
Calcul: ADD AX, BX
JMP suite
 Instructions de contrôle
Sauts conditionnels
¾ En fonction de l'état de drapeaux positionnés par
l' é ti d'
l'exécution d'une
¾Opération
¾ Ou après une opération de comparaison : CMP
¾ 33 types de saut conditionnel !

Exemples de quelques instructions de sauts

conditionnels
1 JE : saut si égal
1.
2. JZ : saut si résultat est zéro
3. JG : saut si plus grand
4. JEG : saut si plus grand ou égal (equal or above)
5. JNGA : saut si pas égal ou pas plus grand (not equal or
above)
6. JL : saut si plus petit (less)
7 JC : saut si retenue (carry)
 Les instructions de branchement

Instruction Jx : Jump conditionnel

Syntaxe
y : Jx label-court ((label se trouve à -128/+127
octets de Jx)
Fonction : cette instruction de saut conditionnel à une
adresse
d autre
t que lal suivante.
i t

Dans le tableau suivant un résumé des instructions de

branchement conditionnel

24
Mnémonique Sens Equivalent OF SF PF ZF CF
Nombre non signés
JA Jump if Above JNBE ‐‐ ‐‐ ‐‐ 0 0
JNA Jump if Not Above JBE ‐‐ ‐‐ ‐‐ 1 1
JAE Jump if Above or Equal JNB ‐‐ ‐‐ ‐‐ ‐‐ 0
JNAE Jump
p if Not Above or JB/JC ‐‐ ‐‐ ‐‐ ‐‐ 1
Equal
JB Jump if Below JNAE/JC ‐‐ ‐‐ ‐‐ ‐‐ 1
JNB J
Jump if N
Not Below
B l JAE ‐‐ ‐‐ ‐‐ ‐‐ 0
JBE Jump if Below or Equal JNA ‐‐ ‐‐ ‐‐ 1 1
JNBE Jump if Not Below or JA ‐‐ ‐‐ ‐‐ 0 0
Equal
JC Jump if Carry ‐‐ ‐‐ ‐‐ ‐‐ 1
JNC Jump if Not Carry ‐‐ ‐‐ ‐‐ ‐‐ 0
JCXZ Jump if CX=0 ‐‐ ‐‐ ‐‐ ‐‐ ‐‐
JE Jump if Equal JZ ‐‐ ‐‐ ‐‐ 1 ‐‐
JNE Jump if Not Equal JNZ ‐‐ ‐‐ ‐‐ 0 ‐‐ 25
Mnémonique Sens Equivalent OF SF PF ZF CF
JZ Jump if Zero (ZF=1) JE ‐‐ ‐‐ ‐‐ 1 ‐‐
JNZ Jump if Not Zero JNE ‐‐ ‐‐ ‐‐ 0 ‐‐
JPE Jump if on Parity Even JP ‐‐ ‐‐ 1 ‐‐ ‐‐
(paire)
JP Jump on Parity JPE ‐‐ ‐‐ 1 ‐‐ ‐‐

JNP Jump if No Prity JPO ‐‐ ‐‐ 0 ‐‐ ‐‐

(impaire)
JPO Jump if Parity Odd JNP ‐‐ ‐‐ O ‐‐ ‐‐
(impaire)

26
Mnémonique Sens Equivalent OF SF PF ZF CF
Nombre signés
JG Jump if Greater JNLE ** ** ‐‐ 0 ‐‐
JNG Jump if Not Greater JLE ** ** ‐‐ 1 ‐‐
JGE Jump if Greater or JNL ** ** ‐‐ ‐‐ ‐‐
Equal
JNGE Jump if Not Greater or JL ** ** ‐‐ ‐‐ ‐‐
Equal
JL Jump
p if Less JNGE ** ** ‐‐ ‐‐ ‐‐
JNL Jump if Not Less JGE ** ** ‐‐ ‐‐ ‐‐
JLE Jump if Less or Equal JNG ** ** ‐‐ 1 ‐‐
JNLE Jump if Not Less or JG ** ** ‐‐ 0 ‐‐
Equal
JS Jump if Sign ‐‐ 1 ‐‐ ‐‐ ‐‐
JNS Jump if Not Sign ‐‐ 0 ‐‐ ‐‐ ‐‐
JO Jump on Overflow 1 ‐‐ ‐‐ ‐‐ ‐‐
JNO Jump on Not Overflow 0 ‐‐ ‐‐ ‐‐ ‐‐
27
 Les instructions de boucle

Instruction LOOP: Loop until count complete

Syntaxe : LOOP cible
Fonction : boucler jusqu’à exécution du compte situé
obligatoirement
g dans CX.

Instruction LOOPE/LOOPZ: Loop if Equal / Loop if zero

Syntaxe : LOOPE cible / LOOPZ cible
Fonction : Boucler si égal/si zéro. Bouclage conditionnel a lieu si
ZF=1 et si registre compteur CX n’est pas à zéro.

Instruction LOOPNE/LOOPNZ: Loop if Not Equal / Loop if Not Zero

Syntaxe : LOOPNE cible / LOOPNZ cible
F
Fonction
ti : Boucler
B l sii non égal/si
é l/ i non zéro.
é Bouclage
B l conditionnel
diti l
a lieu si ZF=0 et si registre compteur CX n’est pas à zéro.

28
 Instructions de contrôle
On peut avec des sauts conditionnels reproduire des
instructions de contrôle de plus haut niveau
¾ If ... then ... Else
¾ if (AX = 3) then
BX = 5
else
BX = DX

CMP AX, 3
JNE else
l ; sii pas égal,
é l on saute à else
l
MOV BX, 5 ; sinon on est dans le then
JMP endif ; on saute le then pour aller à la fin du
if
else: MOV BX,, DX
endif:
 Instructions de contrôle
for (cx=0; cx<5; cx++)
ax = ax + cx

MOV AX,0
AX 0 ; initialisation
i iti li ti de d AX ett CX à 0
MOV CX,0 ; CX est le compteur de boucle
for: CMP CX,
CX 5 ; compare CX à 5
JGE endfor ; si CX >= 5, on sort de la boucle
ADD AX,, CX ; fait le calcul
INC CX ; CX est incrémenté de 1
JMP for ; on reprend au début de la boucle
endfor:
df
 Instructions de contrôle

Pour boucle for précédente, peut utiliser une autre

instruction
LOOP label
Décrémente CX et fait le saut à label si CX > 0

for (cx=5; cx>0; cx--)

ax = ax + cx

MOV AX,0
MOV CX,5 ; CX est le compteur de boucle
For: ADD AX,CX ; fait le calcul
LOOP for ; décrémente CX. CX Si CX > 0 fait
; le saut à for
 Structure d’un programme
¾Dans segment de données : peut définir des
variables
¾Assume
VariableCS:Code,
= zone mémoire
CS:Code DS:Donnees ; CS est le segment
Code
; DS est le segment Donnees
Donnees SEGMENT ; définit segment
données
var1 dw 12 ; var1 : variable sur 16 bits (dw) init à
12
var2 db ? ; var2 : variable sur 8 bits (db) non initialisé
Donnees ENDS ; fin de déclaration du segment
Code SEGMENT ; définit segment
g code
main: ; main sera le début du programme
...
MOV AX, var1 ; copie de var1 dans AX
MOV var2, DH ; copie de DH dans var2
 Instructions de contrôle
Exemple avec saut sur drapeau

ADD AX,
AX BX
JO erreur
...
erreur: MOV AX, 0

Si débordement (overflow) lors de l'addition de AX et BX,

on saute au label erreur
 Procédures
¾ On peut définir des procédures en assembleur x86
¾ Pour les paramètres des procédures et la valeur de retour,
2 méthodes
éh d
Utiliser des registres
• Simple
• Mais registres peu nombreux et doit toujours utiliser les
mêmes
à chaque appel donc assez contraignant

Passer par la
P l pile
il
• On empile les paramètres de la procédure
• On appelle la procédure
• On dépile les paramètres et résultats
p q mais p
• Plus compliqué plus g
général
 Gestion de la pile
Gestion de la pile
pile, 4 opérations
PUSH : empiler une valeur sur la pile
POP : dépiler
p une valeur de la ppile
PUSHA : empiler les 8 registres généraux sur la pile
POPA : positionne les valeurs des 8 registres à partir des 8
valeurs
l
au sommet de la pile
PUSHA et POPA permettent de sauvegarder et restaurer
simplement
l'état des registres
g
Avant un appel de procédure par exemple
Egalement des opérations pour dépiler/empiler registre d'état

Pour lire des éléments de la pile sans les dépiler

¾ MOV AX,
AX [SP] ; AX prend la première valeur en sommet de
pile
¾ MOV AX, [SP+2] ; AX prend la deuxième valeur en sommet
 Procédures
Déclaration d'une procédure

nomProc PROC
...
instructions de la procédure
...
RET
nomProc ENDP

• Appel d'une
d une procédure
CALL nomProc
•Quand
Quand appelle une procédure, le registre IP est empilé sur la
pile pour savoir où revenir
 Procédures

Exemple par registre

Procédure q
qui retourne le double de la somme de AX et DX

Calcul PROC
ADD AX, DX ; addition
SHL AX, 1 ; décalage gauche = X 2
RET
calcul ENDP
.....
MOV AX, 10
MOV DX, 20
CALL calcul ; après l'appel, AX contient le résultat
 Procédures

Même exemple avec passage propre par pile

Propre car les registres restent dans le même état

calcul PROC
PUSH BP ; sauvegarde base de la pile
MOV BP, SP ; nouvelle base de pile = sommet pile
PUSH AX ; sauvegarde AX
MOV AX, [BP+4] ; récupère argument 2
ADD AX, [BP+6]
[BP 6] ; addition AX et argument 1
SHL AX, 1 ; décalage gauche = X 2
MOV [BP+6],AX ; remplace argument 1 par résultat
POP AX ; restaure AX
POP BP ; restaure la base de la pile
RET
calcul ENDP
 Procédures

Appel de la procédure du transparent précédent

PUSH 10 ; empile l'argument 1

PUSH 20 ; empile l'argument 2
CALL calcul
POP AX ; dépile l'argument 2
POP AX ; AX contient le résultat
 Interruptions
Interruption
‰ Pour appeler une opération système ou matérielle
‰ Généralement d'entrée/sortie

Exemple d'interuption
d interuption : interruption système DOS 21h
Affectation des registres selon la fonction de l'interruption
à utiliser
Afficher un caract`ere `a l’´ecran
MOV DL, ''E''
MOV AH,AH 2 ; fonction 2 : affichage à l'écran
l écran du caractère
; stocké dans DL
INT 21h ; appel de ll'interruption
interruption
lecture du caractère entré au clavier
MOV AH,1 ; fonction 1
INT 21h ; le caractère lu est placé dans AL
 Conclusion

¾Intérêt de programmer en assembleur de nos jours

ƒ Pour une programmation « standard » : aucun
¾ Les compilateurs produiront toujours un code plus
optimisé que celui qu'on écrirait à la main
¾ Le compilateur est généralement optimisé pour une
architecture de CPU cible, il sait comment optimiser
p le
code pour un type de CPU donné
¾ Mais
M i utiles
til dans
d certains
t i cas précis
é i
• Programmation bas-niveau de pilotes de
périphériques
• Utilisation de processeurs dans des cartes