Les Instructions Arithmétiques

Les Instructions Arithmétiques

Les Instructions Arithmétiques
Les Instructions Arithmétiques
 Les instructions logiques
Ce sont des instructions qui permettent de manipuler des données au niveau des bits.
Les opérations logiques de base sont :
 ET;
 OU;
 OU exclusif ;
 complément à 1;
 complément à 2;
 décalages et rotations.

Les différents modes d’adressage sont disponibles.

ET logique : AND opérande1,opérande2

L’opération effectuée est : opérande1 ← opérande1 ET opérande2.
Exemple :
Application : masquage de bits pour mettre à « 0 » certains bits dans un mot.
Exemple : masquage des bits 0, 1, 6 et 7 dans un octet :

OU logique : OR opérande1,opérande2
L’opération effectuée est : opérande1 ← opérande1 OU opérande2.
Application : mise à 1 d’un ou plusieurs bits dans un mot.
Exemple : dans le mot 10110001, on veut mettre à « 1 » les bits 1 et 3 sans modifier les
autres bits.

Les instructions correspondantes peuvent s’écrire :

mov ah,10110001B
or ah,00001010B
 Complément à 1 : NOT opérande
L’opération effectuée est :
Exemple :

Complément à 2 : NEG opérande

L’opération effectuée est :
Exemple :

OU exclusif : XOR opérande1,opérande2

L’opération effectuée est : opérande1 ← opérande1 ⊕ opérande2.
Exemple : mise à zéro d’un registre : initialiser le registre
Instructions de décalages et de rotations : ces instructions déplacent d’un certain
nombre de positions les bits d’un mot vers la gauche ou vers la droite.
Dans les décalages, les bits qui sont déplacés sont remplacés par des zéros. Il y a les
décalages logiques (opérations non signées) et les décalages arithmétiques (opérations
signées).
Dans les rotations, les bits déplacés dans un sens sont réinjectés de l’autre coté du mot.

Décalage logique vers la droite (Shift Right) : SHR opérande,n

(AL,CL) ou (AX,CX)
Cette instruction décale l’opérande de n positions vers la droite.Exemple :

 entrée d’un 0 à la place du bit de poids fort ; le bit sortant passe à travers l’indicateur
de retenue CF.
Remarque : si le nombre de bits à décaler est supérieur à 1, ce nombre doit être placé
dans le registre CL ou CX.
Exemple : décalage de AL de trois positions vers la droite :

Décalage logique vers la gauche (Shift Left) : SHL opérande,n

Cette instruction décale l’opérande de n positions vers la droite.
Exemple :

 entrée d’un 0 à la place du bit de poids faible; le bit sortant passe à travers
l’indicateur de retenue CF.
Même remarque que précédemment si le nombre de positions à décaler est supérieur à
1.
 Décalage arithmétique vers la droite : SAR opérande,n
Ce décalage conserve le bit de signe bien que celui-ci soit décalé.
Exemple :

 le bit de signe est réinjecté.

Décalage arithmétique vers la gauche : SAL opérande,n est absurde

Applications des instructions de décalage :

 Cadrage à droite d’un groupe de bits
Exemple : on veut avoir la valeur du quartet de poids fort du registre AL :
 Test de l’état d’un bit dans un mot
Exemple : on veut déterminer l’état du bit 5 de AL :

avec un décalage de 6 positions vers la droite ou 4 positions vers la gauche, le bit 5 de

AL est transféré dans l’indicateur de retenue CF. Il suffit donc de tester cet indicateur.
 Multiplication ou division par une puissance de 2
un décalage à droite revient à faire une division par 2 et un décalage à gauche, une
multiplication par 2.
Exemple :

Rotation à droite (Rotate Right) : ROR opérande,n (AL,CL) ou (AX,CX)

Cette instruction décale l’opérande de n positions vers la droite et réinjecte par la
gauche les bits sortant.
Exemple :

 réinjection du bit sortant qui est copié

dans l’indicateur de retenue CF.
 Rotation à gauche (Rotate Left) : ROL opérande,n
Cette instruction décale l’opérande de n positions vers la gauche et réinjecte par la
droite les bits sortant.
Exemple :
réinjection du bit sortant qui est
copié dans l’indicateur de retenue
CF.

Rotation à droite avec passage par l’indicateur de retenue

(Rotate Right through Carry) : RCR opérande,n
Cette instruction décale l’opérande de n positions vers la droite en passant par
l’indicateur de retenue CF.
Exemple :

 le bit sortant par la droite est copié

dans l’indicateur de retenue CF et la
valeur précédente de CF est
réinjectée par la gauche.
 Rotation à gauche avec passage par l’indicateur de retenue
(Rotate Left through Carry) : RCL opérande,n
Cette instruction décale l’opérande de n positions vers la gauche en passant par
l’indicateur de retenue CF.
Exemple :

 le bit sortant par la gauche est copié

dans l’indicateur de retenue CF et la
valeur précédente de CF est réinjectée
par la droite.

R. BESROUR Cours Architecture & µprocesseur 21

 TD1/EX3
• 5/ Ecrire un programme qui permet de
combiner les quatre bits de poids faible des
contenus des cases mémoires d’adresse DS :
0200H et DS :0201H en un mot qui sera rangé
à l’adresse DS :0202H. Les quatre bits de poids
faible de l’adresse DS :0200H seront les quatre
bits de poids fort du mot obtenu.
Jeu d’instructions RTL : Register
Transfer Level
 Les 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. Il existe 3 types de saut :
 saut inconditionnel ;
 sauts conditionnels ;
 appel de sous-programmes.

Instruction de saut inconditionnel : JMP label

Cette instruction effectue un saut (jump) vers le label spécifié. Un label ou étiquette est
une représentation symbolique d’une instruction en mémoire :
Remarque : l’instruction JMP ajoute au registre IP (pointeur d’instruction) le nombre
d’octets (distance) qui sépare l’instruction de saut de sa destination. Pour un saut en
arrière, la distance est négative (codée en complément à 2).

Instructions de sauts conditionnels : Jcondition label

Cmp al,bl : comparer le contenu de al et bl (AL-BL)
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 des indicateurs d’état du microprocesseur :

CF : indicateur de retenue (carry) ;

PF : indicateur de parité;
ZF : indicateur de zéro ;
SF : indicateur de signe ;
OF : indicateur de dépassement (overflow).
Remarque : les indicateurs sont positionnés en fonction du résultat de la dernière
opération.
Exemple :

Remarque : il existe un autre type de saut conditionnel, les sauts arithmétiques. Ils
suivent en général l’instruction de comparaison : CMP opérande1,opérande2
Déclaration des
variables
Les variables se déclarent dans le Data Segment de la manière suivante:

datas1 db ? ; datas1 est un byte non initialisé

datas2 db 0FFh ; datas2 est un byte initialisé à FF (255 en hexadécimal)

datas3 dw ? ; datas3 est un word (16 bits)

cst db 0 ; cst est une constante égale à 0

tab1 db 5 dup (?) ; tab1 est un tableau de 5 bytes non initialisés

tab2 dw 10 dup (15) ; tab2 est un tableau de 20 byte initialisés à 15

msg db "la somme des termes de tab est : $" ; msg est une chaine de caractère
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
 Réalisation pratique d’un programme assembleur :
 Rédaction du code source en assembleur à l’aide d’un éditeur (logiciel de
traitement de texte ASCII) :
edit sous MS-DOS,
notepad (bloc-note) sous Windows,
 Assemblage du code source (traduction des instructions en codes binaires) avec un
assembleur :
MASM de Microsoft,
TASM de Borland,
A86 disponible en shareware sur Internet, ...
pour obtenir le code objet : code machine exécutable par le microprocesseur ;
 Chargement en mémoire centrale et exécution : rôle du système d’exploitation ou
d’un moniteur (carte de développement à base de microprocesseur).

Pour la mise au point (débogage) du programme, on peut utiliser un programme d’aide

À la mise au point (comme DEBUG sous MS-DOS) permettant :
l’exécution pas à pas;
la visualisation du contenu des registres et de la mémoire ;
la pose de points d’arret …
 TD1/Ex3
• 6/ Trouver le plus grand (puis le plus petit) des deux nombres qui se trouve en 40H et 41H et mettre le
plus grand dans 42 H et le plus petit dans 43h
Jeu d’instructions
Mov al,[40h]
Mov bl,[41h]
Cmp al,bl
Ja l1
Jb l2
L3:HLT ; marque la fin du programme
L1:mov [42h],al
Jmp L3
L2:mov [43h],bl
Jmp L3
 TD1/EX4
1/ Ecrire un jeu d’instruction qui permet de faire
la somme des valeurs allant de 0 à 9.

9 opérations d'addition = 9 itérations donc

CX=9 à l'état initial qui sera décrémenter
pour créer une boucle
AL reçoit la somme à chaque itération
BL est un pointeur à incrémenter qui sera
ajouter à la somme à chaque itération
Jeu d’instructions

Correction
 TD1/EX4
2/ Ecrire un jeu d’instruction qui permet de faire la multiplication (15*6) en décimal.
Jeu d’instructions

2/ Ecrire un jeu d’instruction qui permet de faire la l’addition successive de la valeur 6, 15

fois
Jeu d’instructions
 Autres exemples
Ecrire un jeu d’instruction qui vous permet d’additionner des
nombres décimaux de plusieurs chiffres. La longueur des
nombres est en DS : 0300, les nombres commencent (octet du
plus faible poids) en DS : 0301 et DS : 0305, la somme sera
rangée à partir de DS : 0309 (en décimal). On suppose que la
portion mémoire contient ces valeurs
(27348268+19354092=46702360)
 Correction
Jeu d’instructions
 Corriger, s’il y a des erreurs, les instructions
suivantes :
Autres Exemples
MOV DX , 23FH:Bonne
MOV AX , DX :Bonne
SUB [DX} , [DX} : Fausse (sub dx,dx ou mov dx,
[BX];
Sub dx,[BX])
SHR DX , 5 : Fausse (mov CX,5; MOV AX,DX;
SHR AX,CX)
MOV CL , 20H : Bonne
MOV BX , DL :Fausse ( MOV BL,DL ou MOV
BX,DX)
ADD AX , CL :Fausse (ADD AX,CX ou ADD
AH,CL)
 Autres Exemples
Dans le cas où ces registres ont les valeurs suivantes :
BX=324A, BP=2500, AX=36C1, CX=3000,
DX=2478, DS=5000, SS=7000,
SI=2000, DI=4000.
Calculer l’adresse physique de la mémoire où l’opérande
est sauvegardé, ainsi que le contenu des locations
mémoires dans chacun des modes d’adressage suivants :
A-MOV [SI] , AL b- MOV [SI+BX+10] , AH c-MOV [BX] , AX
d- MOV [2540] , AX e- MOV [BX+25] , DX f- MOV [BP+150] , AX
g- MOV [DI+30] , BX h- MOV [DI+BX+19] , CX
 Correction
instruction Adresse physique contenu
A-MOV [SI] , AL
b- MOV [SI+BX+10] , AH
c-MOV [BX] , AX
d- MOV [2540] , AX
e- MOV [BX+25] , DX
f- MOV [BP+150] , AX
 Structure de code Source pour générer un
programme assembleur exécutable .com (64Ko)
Voici ci-dessous un exemple simple de programme source :
;*************Partie Déclaration des directives*************************************
code segment ; Marque le début du segment de code
assume cs:code ,ds=code, es=code, ss=code ; Définit le segment de code et fusionner tous les
segments
ORG 100h ; Le programme sera rangé à 100h octets à partir du début du segment
; de code
START: jmp debut ; Branchement inconditionnel à la première instruction à exécuter
;************ Déclaration des variables ****************************************
;************ Début du programme *******************************************
debut :
….
….
….

hlt; Appel d’un service du DOS (Fin normale d'un programme)

code ends ; Marque la fin du segment de code
end START ; Fin du programme
 code Source d’affichage ?
Voici ci-dessous un exemple simple de programme source :
;*************************************************************************
; point.asm
;Programme d’affichage d’un point d’interrogation
;Version1 : Avril 2020
;Exécutable : point.com
;Fonctions utilisées : AH,02h INT 21h
;*************************************************************************
code segment ; Marque le début du segment de code
assume cs:code ; Définit le segment de code et fusionner tous les segments
ORG 100h ; Le programme sera rangé à 100h octets à partir du début du segment
; de code
START: jmp debut ; Branchement inconditionnel à la première instruction à exécuter
;************ Déclaration des variables ****************************************
;************ Début du programme *******************************************
debut : mov dl, 3Fh ; Place la valeur 68 dans le registre dl
mov ah,2h ; Place la valeur 2h dans le registre ah
int 21h ; Appel d’un service du DOS
hlt; Appel d’un service du DOS (Fin normale d'un programme) ou int 20h
code ends ; Marque la fin du segment de code
end START ; Fin du programme
 Code d’affichage ? sur Emulateur Emu8086

ORG 100h ; Le programme sera rangé à 100h octets à partir du début du segment de code
;************ Déclaration des variables ****************************************
;************ Début du programme *******************************************
mov dl,3fh ; Place la valeur 3fh dans le registre dl
mov ah,2h ; Place la valeur 2h dans le registre ah
int 21h ; Appel d’un service du DOS
int 20h ; Appel d’un service du DOS (Fin normale d'un programme)

ret
Exemple 2 avec Emul86
Table ASCI
 TD1 (EX5)
un programme assembleur permettant d’afficher (mov AH=02, int 21H)
l’alphabet en majuscule.
code segment
assume cs:code
ORG 100h
START: jmp debut
;************ Déclaration des variables ****************************************
;************ Début du programme *******************************************

Debut : mov dl, 41h

Mov ah,02
L1: Int 21h;afficher A
Inc dl
Cmp dl, 5Bh
Jne l1
hlt
Code ends
End start
1/ un programme permettant de saisir par (int 21H, AH=07) un caractère et
de l’afficher (int 21h, AH=02).
code segment
assume cs:code
ORG 100h
START: jmp debut
;************ Déclaration des variables ****************************************
;************ Début du programme *******************************************
• 2/ Un programme permettant l’affichage d’un octet en binaire : afficher la valeur
contenue dans un registre 8 bits de BL.(AH=02h, int 21h)
Exemple BL= 11110011
3/ Un programme qui affiche deux chaines de caractères
SESAME
ING3B
Utilisant (AH=09 et int 21h)

;************ Déclaration des variables ****************************************

Mess1 db ‘SESAME$’
Mess2 db ‘ING3B$’
;************ Début du programme *******************************************
 4/ Un programme qui lit des caractères par fonction (AH=07) affiche deux chaines de caractères
comme suit utilisant(AH=09 et int 21h) (AH=02 et int 21h) :
ING3B
Le nombre de caractères dans cette chaine est : 5

;************ Déclaration des variables ****************************************

Tab db 128 dup ?
Mess db ‘le nombre …..est : $’
;************ Début du programme *******************************************
 TD2/EX1
5/ Ecrire un programme qui vous permet de :
 saisir par clavier de 3 valeurs : A, B et C (comprises entre 0 et 9 ) en utilisant al fonction
AH=07 int 21h
vérifier si les trois valeurs représentent les longueurs de cotés d’un triangle.
 afficher l’un des deux messages : OUI, A B et C peuvent former un triangle ou bien NON,
vérifier vos valeurs.
 Rappel : A, B, C forment un triangle ssi : A+B>=C et A+C>=B et B+C>=A.

code segment
assume cs:code
ORG 100h
START: jmp debut
;************ Déclaration des variables ****************************************
Tab db 3 dup (?) ; tab db 3 ?
A db ?
B db ?
C db ?
Mess1 db ‘OUI, A B et C peuvent former un triangle $’
Mess2 db’ NON, vérifier vos valeurs.$’
6/ Faire la somme des éléments d’un tableau (10,20,30;40,50,60,70,80,90) et afficher : La somme des éléments de ce tableau est : 450
=01C2hvec AH=09 et AH=02 de interruption int 21h

;************ Déclaration des variables ****************************************

tab1 db 9 dup(10,20,30,40,50,60,70,80,90)
Mess db ‘La somme des éléments de ce tableau est : $’
Som dw ?
Tab2 db 5 dup (?)
;************ Début du programme *******************************************
7/ Faire la somme de deux nombres hexadécimaux 6Ch et AFh trouvés respectivement dans deux variables A et B déclarées et
afficher le résultat : La somme de ces deux nombres est : 11Bh avec AH=09 et AH=02 de interruption int 21h

;************ Déclaration des variables ****************************************

A db 6Ch
B db FAh
resultat db ?
Mess2 db ‘La somme de ces deux nombres est : $’
; procédures
;************ Début du programme *******************************************
 Appel de sous-programmes : pour éviter la répétition d’une même séquence
d’instructions plusieurs fois dans un programme, on rédige la séquence une seule fois
en lui attribuant un nom et on l’appelle lorsqu’on en a besoin. Le programme appelant
est le programme principal. La séquence appelée est un sous-programme ou procédure.
Ecriture d’un sous-programme : une procédure peut être de type NEAR si elle se trouve
dans le même segment type FAR si elle se trouve dans un autre segment.

Appel d’un sous-programme par le programme principal : CALL procédure

la pile (Segment ss) et le programme croissent en sens inverse pour diminuer le risque
de collision entre le code et la pile dans le cas où celle-ci est placée dans le même
segment que le code (SS = CS).Lors de l’appel à un sous-programme, l’adresse de retour
au programme appelant (contenu de IP) est empilée et le pointeur de pile SP est
automatiquement décrémenté de 2 octets. Lors de l’exécution de l’instruction RET, le
pointeur d’instruction IP est rechargé avec la valeur contenue sommet de la pile et SP
est incrémenté de 2 octets.

Note Bien : Lorsque la

pile est vide SP=FFFEh
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 :

Remarque : la valeur du pointeur de pile (SP) doit être initialisée par le programme
principal avant de pouvoir utiliser la pile.

Utilisation de la pile pour le passage de paramètres : pour transmettre des paramètres à une
procédure, on peut les placer sur la pile avant l’appel de la procédure, puis celle-ci les
récupère en effectuant un adressage basé de la pile en utilisant le registre BP.
Exemple : soit une procédure effectuant la somme de deux nombres et retournant le
résultat dans le registre AX .
 programme principal :  procédure somme :

L’instruction ret 4 permet de retourner au programme principal et d’incrémenter le

pointeur de pile de 4 unités pour dépiler les paramètres afin de remettre la pile
dans son
état initial.
Correction TD3
;************ Déclaration des variables ****************************************
 tab1 db 9 dup(0,1,2,3,4,5,6,7,8)  
tab2 db 5 dup(?)
mess1 db ‘La somme des termes est :$’
;************ Début du programme *******************************************
Correction TD3
;************ Déclaration des variables ****************************************
 tab1 db 9 dup(0,1,2,3,4,5,6,7,8)  
tab2 db 5 dup(?)
mess1 db ‘La somme des termes est :$’
;*************Ecriture des procédures**************************************

;************ Début du programme *******************************************

:*********************Programme Principal*******************
Correction TD3
;************ Déclaration des variables ****************************************
 tab1 db 9 dup(0,1,2,3,4,5,6,7,8)  
mess1 db ‘La somme des termes est :$’
;************ Début du programme *******************************************
Correction TD3
;************ Déclaration des variables ****************************************
 tab1 db 9 dup(0,1,2,3,4,5,6,7,8)  
mess1 db ‘La somme des termes est :$’ CX=1
36

Pile

Sommet
Correction TD3
;************ Déclaration des variables ****************************************
 

;************ Début du programme *******************************************

Correction TD3
;************ Déclaration des variables ****************************************
 

;************ Début du programme *******************************************