Cours Up Beguenane 3

1/53
Chapitre 3 : Instructions Arithmétiques et Logiques,

nombres signés, chaînes et tables
Section 3.1: Addition et Soustraction en non signe
Section 3.2: Multiplication et Division en non signe
Section 3.3: Instructions logiques et quelques exemples
Section 3.4: Instructions ASCII et BCD
Section 3.5: Opérations au niveau bit dans le langage C
Section 3.6: Opérations arithmétiques non signées
Section 3.7: Instructions des chaînes et des tables de

données
R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs
2/53
Objectives
Les objectifs de ce chapitre sont:
- Montrer comment des nombres non signés de 8-bits et 16-bits sont additionnés avec les
P80x86.
- Convertir des données vers l’une de ces formes: ASCII, BCD Paqueté, et BCD Non Paqueté.
- Expliquer l’effet des instructions arithmétiques non signées sur le registre FLAG.
- Montrer comment additionner, soustraire, multiplier et diviser des nombres non signés avec les
instructions: ADD/ADC, SUB/SBB, MUL, et DIV respectivement.
- Expliquer les instructions arithmétiques en ASCII et BCD: DAA, DAS, AAA, AAS, AAM, et AAD.
- Coder avec les instructions logiques AND, OR, XOR, SHR, SHL, ROR/ROL/RCR/RCL et CMP.
- Expliquer comment les nombres signés de 8-bits et 16-bits sont représentés avec les P80x86.
- Convertir un nombre signé en complément à 2.
- Montrer comment additionner, soustraire, multiplier et diviser des nombres signés avec les
instructions: ADD, SUB, IMUL, et IDIV respectivement, et comment ces arithmétiques affectent le
registre FLAG.
- Éviter les erreurs de dépassement avec la notion de données au signe étendu avec les
instructions CBW et CWD.
- Les instructions de décalage arithmétique SAR et SAL et les instructions de décalage logiques,
SHR, SHL.
- L’instruction de comparaison CMP en arithmétique signé et son effet sur le registre flag RF.
- Décrire le bit direction flag DF dans les instructions de chaînes de caractères et l’utilisation de
CLD et STD pour contrôler ce bit.
- Expliquer comment manipuler les chaînes de caractères, et décrire l’opération de l’instruction
préfixe REP.
3/53
Section 3.1 Addition et Soustraction en non signé
ADDITION NON SIGNÉE

Un nombre non signé est défini comme une donnée ou tout ses bits sont utilisés pour la
représenter, i.e. aucun bit n’est réservé pour représenter son signe, négative ou positive. Par
exemple un opérande sur 8-bits peut prendre des valeurs de 00H a FFH (de 0 a 256 en
décimale).
ADD destination, source ;Opérande dest. = Opérande dest. + Opérande source

ADC destination, source ;Opérande dest. = Opérande dest. + Opérande source + CF
Un opérande dest. peut être un registre ou dans la mémoire. Un opérande source peut être un
registre, dans la mémoire, ou une valeur immédiate. Les opérations de mémoire à mémoire non
permises dans le langage assembleur du 80x86. L’instruction ADD peut changer les indicateurs
ZF, SF, AF, CF ou PF du registre FLAG. Le OF concerne les opérations signées.
MOV AL, 0F5H 1111 0101

ADD AL, 0BH + 0000 1011
--------------
1 0000 0000  ZF = 1, CF = 1, AF = 1, PF = 1, SF = 0 (bit D7 est 0)
ADC AL, 0BH 0000 0000

+ 1
--------------
0 0000 0001  ZF = 0, CF = 0, AF = 1, PF = 0, SF = 0 (bit D7 est 0)

4/53
Addition et Soustraction en non signé

ADDITION de données en octets
PAGE 60, 132

TITLE prog3_1.asm: Addition de 5 octets (125, 235, 197, 91, et 48) ou la somme dépasse le maximum d’un octet (> 255)
.MODEL SMALL
.STACK 64
.DATA
COUNT EQU 05 Assembleur  Hex
DATA DB 125, 235, 197, 91, 48 7DH, 0EBH, 0C5H, 5BH, 30H  02B8H
SUM DW ?
.CODE
MAIN PROC FAR
MOV AX, @DATA
MOV DS, AX
MOV CX, COUNT
MOV SI, OFFSET DATA
MOV AX, 00
ENCORE: ADD AL, [SI] ENCORE: ADD AL, [SI]

JNC SURPASSE Plus efficace
INC AH ADC AH, 00 ; 00+AH+CFAH
Pas de pipeline
SURPASSE: INC SI INC SI
DEC CX
JNZ ENCORE
MOV SUM, AX
Résultat stocké dans un
mot mémoire dans le DS
MOV AH, 4Ch
INT 21h
MAIN ENDP
END MAIN
5/53

ADDITION de données en mots
PAGE 60, 132

TITLE prog3_1b.asm: Addition de 5 mots (27345, 28521, 29533, 30105, et 32375) ou la somme dépasse le maximum d’un mot (> 65535)
.MODEL SMALL
.STACK 64
.DATA
COUNT EQU 05
ORG 0010H
DATA DW 27345, 28521, 29533, 30105, 32375 ; 6AD1H + 6F69H + 735DH + 7599H + 7E77H  241A7H
ORG 0020H
SUM DW 2 DUP(?)
.CODE
MAIN PROC FAR
MOV AX, @DATA
MOV DS, AX
MOV CX, COUNT
MOV SI, OFFSET DATA
MOV AX, 00
MOV BX, AX ; BX  pour les retenues
ENCORE: ADD AX, [SI] ; Ajouter le contenu de AX au prochain mot
ADC BX, 0 ; ajouter la retenue a BX

INC SI
INC SI ; deux fois car c’est l’addition des mots
DEC CX
JNZ ENCORE
MOV SUM, AX
MOV SUM+2, BX ; stocker les retenues
MOV AH, 4Ch INT 21h
MAIN ENDP
END MAIN

6/53

ADDITION de données en multimots
PAGE 60, 132
TITLE prog3_2.asm: Addition de 2 multimots (548FB9963CE7h et 3FCD4FA23B8Dh)
.MODEL SMALL
.STACK 64
.DATA
DATA1 DQ 548FB9963CE7H ; DQ est choisit car elle représente une donnée large de 8 octets
ORG 0010H
DATA2 DQ 3FCD4FA23B8DH
ORG 0020H
SUM DQ ? ; = 945D09387874H
.CODE
MAIN PROC FAR
MOV AX, @DATA
MOV DS, AX
CLC ; reset la retenue
MOV SI, OFFSET DATA1 ; SI est pointeur vers l’opérande DATA1

MOV DI, OFFSET DATA2 ; DI est pointeur vers l’opérande DATA1
MOV BX, OFFSET SUM ; BX est pointeur vers la somme SUM
MOV CX, 04 ; compteur de boucle
ENCORE: MOV AX, [SI] ; déplace le 1er opérande vers AX
ADC AX, [DI] ; add. le 2eme opérande vers AX en tenant compte de la retenue
précédente MOV [BX], AX ; stocke la somme dans la case mémoire pointée par BX
INC SI INC SI ; pointe sur le prochain mot de l’opérande DATA1
INC DI INC DI ; pointe sur le prochain mot de l’opérande DATA2
INC BX INC BX ; pointe sur le prochain mot de de SUM
LOOP ENCORE P8086/80286
; Instruction équivalente a [ DEC CX, JNZ ENCORE P] PentiumIII
MOV AH, 4Ch INT 21h 4 ITERATIONS avec registres 16-bit MAIS 1 ITERATION avec registres 64-bit
MAIN ENDP
END MAIN
7/53
SOUSTRACTION NON SIGNÉE
SUB destination, source ;Opérande dest. = Opérande dest. - Opérande source

Pour la soustraction, les P80x86 utilisent la méthode complément à 2 (Cà2), pour éviter un
circuit soustracteur (économie de transistors oblige). Les étapes à suivre par le hardware de
la CPU pour mener l’instruction SUB, pour les nombres non signés, sont:
1- Prendre le Cà2 de l’opérande source.
2- Ajouter a l’opérande destination.
3- Inverser la retenue CF.
MOV, AL, 3FH, MOV, BH, 23H, SUB AL, BH 0011 1111 - 0010 0011
+ 1101 1101 (Cà2 de 0010 0011)
--------------
1 0001 1100  CF  0, ZF = 0, PF = 0, SF = 0 (bit D7 est 0)
Si CF = 0, le résultat est positive. Sinon il est négative. Dans ce cas l’opérande destination contient le
Cà2 du résultat. Normalement, ce résultat est laissé tel quel, sinon on peut utiliser les instructions
NOT et INC pour le changer si on veut par un programme:
MOV DH, 4CH

SUB DH, 6EH
JNC PROCHAINE
NOT DH
INC DH
PROCHAINE: MOV AH, DH

8/53
SBB destination, source ;Opérande dest. = Opérande dest. - Opérande source – CF
Cette instruction concerne les nombres « multi-mots » qui prend en compte la retenue ’’empreint =
borrow’’ de l’opérande (mot) précédent. Si CF=0, SBB est équivalente a SUB. Si CF=1, SBB
soustrait 1 du résultat.
DATA_A DD 62562FAh
DATA_B DD 412963Bh
RESULTAT DD ?
… … …
MOV AX, WORD PTR DATA_A ; AX = 62FAh Note: la directive PTR demande a l’assembleur
; d’assigner a DATA_A le type WORD même si elle est déclarée
DD
SUB AX, WORD PTR DATA_B ; SUB 963Bh de (AX = 62FAh)
MOV WORD PTR RESULTAT, AX ; stocker le résultat
MOV AX, WORD PTR DATA_A + 2 ; AX = 0625h

SBB AX, WORD PTR DATA_B + 2 ; SUB 0412h avec l’empreint (retenue)
MOV WORD PTR RESULTAT, AX + 2 ; stocker le résultat
Le résultat:
SUB  AX = 62FA – 963B = CC3B et CF =1 

SBB  625 – 412 –1 = 212
RESULTAT  0212CCBFh
9/53
Multiplication et Division en non signé

P8080/85  P8086: introduction des instructions de (x) et de (/)  utilisation de AX, AH, AL et DX.
MULTIPLICATION NON SIGNÉE MUL reg. (ou mém.)
-Octet x Octet:
RESULTAT DW ? ; résultat est définit dans le DS
… … …
MOV AL, 23H ; l’un des opérandes (ici une donnée immédiate) toujours dans AL
MOV BL, 65H ; 2eme opérande (ici une donnée immédiate) dans le registre BL
MUL BL ; AX = BL (65h) x AL (23h)
MOV RESULTAT, AX ; le résultat (dans AX) est stocké dans un mot mémoire ( DS )
Noter que plusieurs modes d’adressage peuvent être utilisés.

; ------------------ du segment de données -----------------------------------------------------------------------------------------------------
DATA1 DB 25H
DATA2 DB 65H
RESULTAT DW ?
; ------------------ du segment de code -----------------------------------------------------------------------------------------------------
MOV AL, DATA1 ; l’un des opérandes (ici dans la mémoire DS) toujours dans AL
MOV BL, DATA2 ; 2eme opérande (ici dans la mémoire DS) dans le registre BL Ici BL est utilisé mais
MUL BL ; AX = BL x AL  mode d’adressage registre autre registre 8bit peut
MOV RESULTAT, AX ; le résultat (dans AX) est stocké dans un mot mémoire ( DS ) être utilisé.
MOV AL, DATA1

MUL DATA2 ; AX = AL x DATA2  mode d’adressage direct
MOV RESULTAT, AX Ici ptr SI est utilisé mais
autre registre pointeur
MOV AL, DATA1 comme BX ou DI.
MOV SI, OFFSET DATA2 ; 2eme opér. ici dans la mémoire DS pointé par le registre SI
MUL BYTE PTR [SI] ; AX = AL x [SI]  mode d’adressage registre indirect BYTE PTR  opérande
MOV RESULTAT, AX pointé par SI est un Octet

10/53
MULTIPLICATION NON SIGNÉE MUL reg. (ou mém.)

- Mot x Mot: Les registres AX (mot LSB) et DX (mot MSB) sont utilisés pour stocker les résultat
DATA3 DW 1B25H
DATA4 DW 2D65H
RES_MUL DW 2 DUP(?)
MOV AL, DATA3 ; charger l’un des opérandes (ici dans la mémoire DS) dans AX
MUL DATA2 ; le multiplier par le 2eme opérande (dans la mémoire DS)
MOV RES_MUL, AX ; le LSB du résultat (dans AX) dans la mémoire DS (RES_MUL)
MOV RES_MUL+2, DX ; le MSB du résultat (dans DX) dans la mémoire DS (RES_MUL+2)
- Mot x Octet: De même les registres AX (mot LSB) et DX (mot MSB) sont utilisés pour stocker les résultat.
Mais AL contient l’opérande en octet et AH est mis a zéro.
DATA5 DB 0B6H
DATA6 DW 12C3H
RES_MUL2 DW 2 DUP(?)
MOV AL, DATA5 ; charger l’un des opérandes (ici dans la mémoire DS) dans AL
SUB AH, AH ; AH est mis a zéro
MUL DATA6 ; Multiplier le 1er par le 2eme opérande (les 2 se trouvant la mémoire DS)
MOV BX, OFFSET RES_MUL2 ; BX pointe sur la location mémoire de RES_MUL2
MOV [BX], AX ; le LSB du résultat (dans AX) dans la location mémoire pointée par
BX
MOV [BX]+2, DX ; le MSB du résultat (dans DX) dans la location mémoire pointée par
BX+2
11/53
MULTIPLICATION NON SIGNÉE
Multiplication Opérande 1 Opérande 1 Résultat

Octet x Octet AL Reg. ou mem. AX
Mot x Mot AX Reg. ou mem. DX, AX
Mot x Octet AL=Octet, Reg. ou mem. DX, AX
AH=0

12/53
DIVISION NON SIGNÉE DIV reg. (ou mém.)
Dans la division des nombres non signées, 4 cas sont considérés:

Octet/Octet Mot/Mot Mot/Octet DoubleMot/Mot.
Deux cas « exception » ou la CPU ne peut effectuer une division: division par « 0 » ou si le
quotient est plus large que la taille du registre. Un signal d’interruption est activé et le PC
affiche un message d’erreur.
- Octet / Octet: Num.  AL; 0  HL Denom. ne peut être une valeur immédiate
Après DIV, Quotient  AL; Reste  AH.
; ------------------ du segment de données ------------------------------------------------------------------
DATA7 DB 95
DATA8 DB 10
QOUT1 DB ?
ROUT1 DB ?
; ------------------ du segment de code ------------------------------------------------------------------
MOV AL, DATA7 ; le numérateur (ici dans la mémoire DS) toujours dans AL
SUB AH, AH ; AH toujours mis à 0
DIV 10 ; Adressage immédiat n’est pas permis  message d’ERREUR

13/53
- Octet / Octet: Les modes d’adressage permis
- Adressage direct:
MOV AL, DATA7 ; le numérateur (ici dans la mémoire DS) toujours dans AL
SUB AH, AH ; AH toujours mis a 0
DIV DATA8 ; AX / DATA8
MOV QOUT1, AL ; Quotient = AL (09)
MOV ROUT1, AH ; Reste = AH (05)
- Adressage registre:
MOV AL, DATA7 ; le Num.  AL

MOV BH, DATA8 ; Denom.  BH
DIV BH ; AX / BH
MOV ROUT1, AH ; Reste = AL (05)
- Adressage registre indirect:
MOV AL, DATA7 ; le Num.  AL

MOV BX, OFFSET DATA8 ; Denom.  BH
DIV BYTE PTR [BX] ; AX / BH, noter la directive BYTE PTR sinon ERREUR car BX est sur 16-bit
MOV ROUT1, AH ; Reste = AL (05)

14/53
- Mot / Mot: (Num.  AX; 0  DX. Denom.  Reg./Mem.) Après DIV : (Quot.  AX; Reste  DX)
QOUT2 DW ?
ROUT2 DW ?
MOV AX, 10050 ; Num.  AX

SUB DX, DX ; 0  DX
MOV BX, 100 ; Denom.  BX
DIV BX ; AX / BX
MOV QOUT2, AX ; Quotient = AX (100)
MOV ROUT2, DX ; Reste = DX (50)
- Mot / Octet: (Num.  AX; Denom.  Reg./Mem.) Après DIV : (Quot.  AL; Reste  AH)
MOV AX, 2050 ; Num.  AX
MOV CL, 100 ; Denom.  CL
DIV CL ; AX / CL
MOV ROUT1, AH ; Reste = AH (50)
- DoubleMot / Mot: (Num.  [DX,AX]; Denom.  Reg./Mem.) Après DIV : (Quot.  AX; Reste  DX)
DATA9 DD 105432
DATA10 DW 10000
QOUT, ROUT DW ?
MOV AX, WORD PTR DATA9 ; mot LSB du Num.  AX Noter WORD PTR sinon ERREUR
MOV DX, WORD PTR DATA9 + 2 ; mot MSB du Num.  DX Noter WORD PTR DATA9 + 2  DX
DIV DATA10 ; [DX,AX] / DATA10

MOV QOUT, AX ; Quotient = AX (10)
MOV ROUT, DX ; Reste = DX (5432)
Remarque: Si le Dénominateur est un Mot  P80x86 utilise automatiquement [DX, AX] comme numérateur

15/53
Section 3.3: Instructions logiques
et quelques exemples
Instruction AND: AND destination, source (Destination = Reg. ou Mem.Source = Reg., Mem., ou donnée immédiate)
MOV BL, 35H

AND BL , 0FH ; BL AND 0Fh  BL (05h). X Y X and Y
0 0 0
Avec AND seuls les indicateurs ZF, SF et PF sont affectés et (CF, OF)  0.
L’instruction AND est utilisée pour: 0 1 0
- Masquer (mise à 0) certains ou tout les bits (AND AL, 00h) 1 0 0
- Application: Tester si un opérande est “0” comme dans:
1 1 1
AND DH, DH
JZ xxxx
….
xxxx: ….
Instruction OR: OR destination, source (Destination = Reg. ou Mem.Source = Reg., Mem., ou donnée immédiate)
MOV AX, 0504H

OR AX, 0DA68H ; AX OR DA68Fh  AX (DF66h).
Avec OR seuls les indicateurs ZF, SF et PF sont affectés et (CF, OF)  0. X Y X or Y

L’instruction OR est utilisée pour:
0 0 0
- Mettre à 1 certains ou tout les bits (OR BL, FFh).
- Tester si un opérande est “0” comme dans ( OR BL, 0  ZF=1 si BL=00h) ou encore: 0 1 1
OR DH, DH 1 0 1
JZ xxxx
…. 1 1 1
xxxx: ….

16/53
Instructions logiques et quelques exemples
Instruction XOR: XOR destination, source (Destination = Reg. ou Mem.Source = Reg., Mem., ou donnée immédiate)
X Y X xor Y
MOV DH, 54H
XOR DH , 78H ; DH XOR 78h  DH (2Ch). 0 0 0
0 1 1
Avec l’instruction XOR, si les bits sont égaux, le bit résultant est 0 et vice versa.
Avec XOR, seuls les indicateurs ZF, SF et PF sont affectés et (CF, OF)  0. 1 0 1
Application: L’instruction XOR est utilisée pour: 1 1 0
- Mettre à 0 le contenu d’un registre (XOR AL, AL), le résultat, toujours 00h, AL
- Comparer deux registres si leur contenus sont égaux (XOR AX, CX).
Si c’est les cas ZF  1 et le résultat est sauvegardé dans la destination (0000
AX)
- Basculer (toggle) ou inverser un ou plusieurs bits (0 1 ou 1 0):
MOV AH, 54H

XOR AH , 04H ; bit 2 de AH s’inverse (50h  AH)

17/53
Instructions de DECALAGE  Logique (opérandes non signés) et Arithmétique (opérandes signés)
Les instructions de décalage logiques affectent les indicateurs OF, SF, PF et ZF.
Les opérandes à décaler peuvent être dans un registre ou dans la mémoire mais jamais en mode immédiat.
Instruction SHR (Décalage à droite logique)

0 MSB  LSB CF
MOV BX, 0FFFFH ; FFFFh  BX
SHR BX , 1 ; 7FFFh  BX et CF = 1
DATA1 DB 9AH
FOIS EQU 3
MOV CL, FOIS
SHR AL , CL ; AL est décalé à droite CL (3) fois : CF = 0, ensuite 1 et enfin 0
Instruction SHL (Décalage à gauche logique) CF MSB  LSB 0
MOV DH, 6 ; 06h  DH

MOV CL, 4
SHR DH , CL ; DH est décalé à gauche CL (4) fois : 60  DH et CF = 0 à chaque fois

18/53

Instruction CMP (Compare) CMP destination, source
Compare CF ZF
L’instruction CMP affecte les indicateurs AF, OF, SF, PF, CF et ZF Opérandes
mais seuls CF et ZF sont utilisés.
Dest. > Src. 0 0
L’opérande destination peut être dans un registre ou dans une mémoire. Dest. = Src. 0 1
L’opérande source peut être dans un registre, dans une mémoire, ou en mode immédiat.
Les opérandes (destination et source) ne changent pas. Dest. < Src. 1 0
DATA1 DW 235FH
…
MOV BX, 7888H ; 7888Hh  BX
MOV CX, 9FFFH
CMP BX, CX ; BX < CX  CF=1  JNC est exécutée  PASSE
JNC PASSE ; Note: les contenus de (BX, et CX) ne changent pas après CMP
ADD BX, 4000H
PASSE: ADD CX, DATA1 ; mais CF est toujours vérifié pour (< ou >). Pour (=) on utilise ZF.
TEMP DB ?
…
MOV AL, TEMP ; TEMP  AL
CMP AL, 99 ; TEMP = 99?. Avec (SUB AL, 99), la même chose mais 0  AL
JZ PROCHAIN ; Si ZF=1 (TEMP=99), Saute a PROCHAIN:
INC BX ; Sinon incrémente BX
PROCHAIN: HLT ; Arrêt du programme
19/53

TITLE prog3_3.asm: Exemple sur CMP, Trouver l’octet le plus grand parmi 5 notes d’élèves
PAGE 60, 132
.MODEL SMALL
.STACK 64
;----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.DATA
NOTES DB 18, 06, 19, 11, 08
ORG 0008H
PLUS_G DB ?
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.CODE
MAIN PROC FAR
MOV AX, @DATA
MOV DS, AX

MOV BX, OFFSET NOTES ; BX pointe vers les données GRADES
XOR AL, AL ; Initialise AL qui va héberger la plus grande note
ENCORE: CMP AL, [BX] ; compare la note prochaine a la note la plus élevée
JA PROCHAIN ; Sauter si AL est encore la note la plus élevée
MOV AL, [BX] ; sinon AL retient la plus élevée
PROCHAIN: INC BX ; pointe vers la prochaine note
LOOP ENCORE ; CX décrémente jusqu’à 0 pour sortir de la LOOP
MOV PLUS_G, AL ; sauvegarde de la note la plus élevée dans PLUS_G
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
MOV AH, 4Ch Noter l’utilisation de JA a la place de JC ou JNC.
INT 21h En effet JA et JB sont préférées a JC et JNC, car plus
MAIN ENDP facile a assimiler et que DEBUG désassemble JCJB et
END MAIN JNC  JA.

20/53

TITLE prog3_4.asm: Exemple sur CMP, Conversion MINUSCULE  MAJUSCULE d’un texte
PAGE 60, 132
.MODEL SMALL
.STACK 64 L Hex Binaire L Hex Binaire
;----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.DATA A 41 01000001 a 61 01100001
TEXTE1 DB ‘mOn Nom eST BEGueNanE’ A
B 42 01000010 b 62 01100010
ORG 0020H S
TEXTE2 DB 21 DUP(?) . ………… C . …………
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
I
. ………… . …………
.CODE
I
MAIN PROC FAR Y 59 01011001 y 79 01111001
MOV AX, @DATA
Z 5A 01011010 z 7A 01111010
MOV DS, AX
MOV SI, OFFSET TEXTE1 ; SI pointe sur le texte original
MOV BX, OFFSET TEXTE2 ; BX pointe sur le texte en MAJUSCULE
ARRIERE: MOV AL, [SI] ; prochain caractère
CMP AL, 61H ; Si < ‘a’ (61H est le code ASCII de ‘a’)
JB PASSE ; donc pas besoin de convertir
CMP AL, 7AH ; Si > ‘z’ (7AH est le code ASCII de ‘z’)
JA PASSE ; donc pas besoin de convertir
AND AL, 11011111B ; masque le bit 5 pour convertir en MAJUSCULE
PASSE: MOV [BX], AL ; sauvegarde le caractère MAJUSCULE
INC SI ; incrémente le “pointeur vers le texte original”
INC BX ; incrémente le “pointeur vers le texte en MAJUSCULE”
LOOP ARRIERE ; Continuer a boucler tant que CX > 0 CMP AL, ‘a’
;----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- JB K61
MOV AH, 4Ch CMP AL, ‘z’
INT 21h JA
MAIN ENDP SUB AL, ‘a’-’A’
END MAIN IBM BIOS Méthode pour la conversion  K61: MOV [BX], AL

21/53

Instructions de ROTATION  ROR/ROL/RCR/RCL reg/mem 1/CL
ROR RCR
MSB  LSB CF MSB  LSB CF
ROL RCL
CF MSB  LSB CF MSB  LSB
MOV BX, 0C7E5H ; 1100011111100101B  BX

ROR BX , 1 ; 1110001111110010  BX et CF = 1 MOV CL, 2
ROR BX , 1 ; 0111000111111001  BX et CF = 0 ROR BX, CL
MOV BH, 72H ; 01110010B  BH

ROL BH , 1 ; 11100100B  BH et CF = 0 MOV CL, 2
ROL BH , 1 ; 11001001B  BX et CF = 1 ROL BL, CL
CLC ; CF = 0
MOV BX, 0C7E5H ; 1100011111100101B  BX
MOV CL, 2 ; 0110001111110010  BX et CF = 1
RCR BX, CL ; 1111000111111001  BX et CF = 0
STC ; CF = 1
MOV BH, 72H ; 01110010B  BH
MOV CL, 2 ; 11100101B  BH et CF = 0
RCL BL, CL ; 11001010B  BX et CF = 1

22/53

Exemple d’utilisation
TITLE prog3_5.asm: Exemple sur ROL, Trouver le nombre de ‘1’ dans un mot
PAGE 60, 132
.MODEL SMALL
.STACK 64
;----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.DATA
DATA1 DW 5F97H
COMPTE DB ?
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.CODE
MAIN PROC FAR
MOV AX, @DATA
XOR BL, BL ; Mettre BL a 0 (ou bien SUB)

MOV DL, 16 ; rotation 16 fois
MOV AX, DATA1
ENCORE: ROL AX, 1 ; Rotation a gauche (a droite aussi si on préfère)
JNC PROCHAIN ; Test si CF=0
INC BL ; Si CF = 1, incrémenter le compteur du nombre de ‘1’
PROCHAIN DEC DL ; répéter 16 fois
JNZ ENCORE ; encore une fois si ce n’est pas fini
MOV COMPTE, BL ; sauvegarder le résultat dans la case mémoire COMPTE
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
MOV AH, 4Ch
INT 21h
MAIN ENDP
END MAIN

23/53
Section 3.4: Instructions ASCII et BCD

INSTRUCTIONS ASCII et BCD
Touche ASCII (en Binaire) BCD NonPaqueté
Note:
0 011 0000 0000 0000
1 011 0001 0000 0001
2 011 0010 0000 0010
3 011 0011 0000 0011 “89” en BCD NonPaqueté est:
4 011 0100 0000 0100 “0000 1000 0000 1001”
5 011 0101 0000 0101 Alors qu’en BCD Paqueté est:
6 011 0110 0000 0110
« 1000 1001 ».
7 011 0111 0000 0111
8 011 1000 0000 1000
9 011 1001 0000 1001
ASCII  BCD (NonPaqueté)

ASC DB ‘9562481273’ ; convertir 10 nombres ASCII en BCD NonPaqueté
ORG 0010H
NONPAQ DB 10 DUP (?)
…
MOV CX, 5 ; compteur de 5 mots  10 octets (nombres ASCII)
MOV BX, OFFSET ASC ; BX pointe vers les nombres en ASCII a convertir
MOV DI, OFFSET NONPAQ ; DI pointe vers les nombres en BCD NonPaqueté
ENCORE: MOV AX, WORD PTR [BX] ; Déplacer les prochains 2 nombres ASCII vers AX
AND AX, 0F0FH ; Masquer (Enlever) les 3s d’ASCII (les 3 MSB bits)  la conversion
MOV WORD PTR [DI], AX ; sauvegarder le résultat (le BCD NonPaqueté)
ADD BX, 2 ; pointe vers le prochain nombre ASCII
ADD DI, 2 ; pointe vers le prochain nombre en BCD NonPaqueté
LOOP ENCORE ; encore une fois si ce n’est pas fini jusqu’a ce que CL = 0

24/53
Instructions ASCII et BCD

Note:
Les pointeurs BX et DI ont été utilises pour pointer vers une matrice de données de dimension 2. Q’en est-
il si cette matrice est multidimensionnelle?
La solution est d’utiliser un seul pointeur et le mode d’adressage Base ou Index Relatif.
ASC DB ‘9562481273’ ; convertir 10 nombres ASCII en BCD NonPaqueté

ORG 0010H
NONPAQ DB 10 DUP (?)
…
MOV CX, 10 ; compteur de 10 octets puisque AL est utilisé
SUB BX, BX ; BX pointe vers les nombres en ASCII a convertir
ENCORE: MOV AL, ASC[BX] ; Déplacer vers AL le contenu de [BX + ASC].
; A la place de BX, les pointeurs BP/DI/SI peuvent être utilisés.
AND AL, 0FH ; Masquer le quartet (nibble) MSB
MOV UNPAQ[BX], AL ; Déplacer vers la case mémoire [BX + UNPAQ] le contenu de AL
INC BX ; pointe vers le prochain OCTET
Ou encore:
MOV CX, 5 ; compteur de 5 octets puisque AX est utilisé

SUB BX, BX ; BX pointe vers les nombres en ASCII a convertir
ENCORE: MOV AX, WORD PTR ASC[BX] ; Déplacer vers AX les contenus de [BX + ASC] et [BX + ASC]+1.
; A la place de BX, les pointeurs BP/DI/SI peuvent être utilisés.
AND AX, 0F0FH ; Masquer les quartets (nibbles) MSB des 2 octets du mot
MOV WORD PTR UNPAQ[BX], AL ; Déplacer vers la case mémoire [BX + UNPAQ] le contenu de AX
ADD BX, 2 ; pointe vers le prochain MOT

25/53

ASCII  BCD (Paqueté) le passage par la conversion “ASCII  BCD NonPaqueté“ est nécessaire
TITLE prog3_6.asm: Convertir les touches ASCII ‘47’ en BCD Paqueté

PAGE 60, 132
.MODEL SMALL
.STACK 64
;----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.DATA
ORG 0010H
VAL_ASC DB ’47’
VAL_BCD DB ? ; le directive DB met 34 dans “0010” et 37 dans “0011”
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.CODE
MAIN PROC FAR
MOV AX, @DATA
MOV AX, WORD PTR VAL_ASC ; le contenu de VAL_ASC dans AX: (37)AH, 34AL
AND AX, 0F0FH ; Masquer 3 pour avoir le DCB NonPaqueté
XCHG AH, AL ; Échanger AH et AL
MOV CL, 4 ; 04  CL to décaler 4 fois
SHL AH, CL ; décaler a gauche AH pour obtenir 40HAH
OR AL, AH ; pour obtenir le BCD paqueté équivalent a ’47’
MOV VAL_BCD, AL ; sauvegarder le résultat dans la case mémoire
VAL_BCD
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
MOV AH, 4Ch
INT 21h
MAIN ENDP
END MAIN

26/53

BCD (Paqueté)  ASCII le passage par la conversion “ BCD Paqueté  BCD NonPaqueté“ est nécessaire
TITLE prog3_6b.asm: Convertir le nombre BCD Paqueté 29H en ASCII

PAGE 60, 132
.MODEL SMALL
.STACK 64
;----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.DATA
V_BCD DB 29H ; le directive DB met 29H dans l’offset “0000”
V_ASC DB ?
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.CODE
MAIN PROC FAR
MOV AX, @DATA
MOV AL, V__BCD

MOV AH, AL ; 29HAH , 29HAL
AND AX, 0F00FH ; Masquer 9 de AH et 2 de AL
MOV CL, 4 ; 04  CL to décaler 4 fois
SHR AH, CL ; décaler a droite AH pour obtenir le BCD NonPaqueté
OR AX, 3030H ; Combiner avec 30H pour obtenir le code ASCII
XCHG AH, AL ; Échanger AH et AL
MOV V_ASC, AX ; sauvegarder le code ASCII dans la case mémoire
V_ASC
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
MOV AH, 4Ch
INT 21h
MAIN ENDP
END MAIN

27/53

ADDITION BCD ET CORRECTION
Additionner deux nombres BCD (Paqueté) ne donne pas forcement un nombre BCD, car
nous risquons d’avoir les digits A, B, … F. Pour y remédier le programmeur doit corriger en
ajoutant 6 (0110). Les P-CISC sont menés d’une instruction spécifique, comme DAA
d’Intel.
DAA travaille uniquement avec le registre AL. Ses actions sont:
- Si après ADD ou ADC, le Quartet (Nibble) LSB est >9 ou si AF = 1  ajouter 0110 au
Quartet LSB. Sinon l’instruction DAA laisse le résultat tel qu’il est après ADD/ADC.
- Si le Quartet (Nibble) MSB est >9 ou si CF = 1  ajouter 0110 au Quartet MSB.
Exemples:
47H + 25H (LSB >9) , 29H + 18H (AF = 1), 42H + 85H (MSB >9) , 93H + 81H (CF = 1)  DAA
DATA1 DB 47H
DATA2 DB 25H
DATA3 DB ?
MOV AL, DATA1 ; 1er opérande BCDAL

MOV BL, DATA2 ; 2eme opérande BCDBL
ADD AL, BL ; Addition BCD
DAA ; Ajuster pour la correction BCD
MOV DATA3, AL ; Sauvegarder le résultat (72H) BCD

28/53

Exemple:
Il s’agit d’écrire un programme, qui a partir de 2 ensembles de touches ASCII, tapées a partir du clavier, permet
de:
1. Les convertir du code ASCII vers BCD Paqueté.
2. Additionner les deux multimot en BCD Paqueté et sauvegarder le résultat.
3. Convertir ce résultat, en BCD paquetee, vers le code ASCII.
TITLE prog3_7.asm: ASCII   BCD Paqueté et Addition BCD Paqueté

PAGE 60, 132
.MODEL SMALL
.STACK 64
;----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.DATA
DATA1_ASC DB ‘0649147816’
ORG 0010H
DATA2_ASC DB ‘0072687188’
ORG 0020H
DATA1_BCD DB 5 DUP(?) ; 5 car chaque octet est l’équivalent de 2 ASCII  5 mots
ORG 0028H
DATA2_BCD DB 5 DUP(?)
ORG 0030H
DATA3_BCD DB 5 DUP(?)
ORG 0040H
DATA3_ASC DB 10 DUP(?) ; 10 car chaque caractère ASCII (et il y’a 10) est un octet
;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.CODE
MAIN PROC FAR
MOV AX, @DATA Suite
MOV DS, AX
29/53
MOV BX, OFFSET DATA1_ASC ; BX pointe sur les données de la première série ASCII
MOV DI, OFFSET DATA1_BCD ; DI  les données de la première série convertie en
BCD
MOV CX, 10 ; CX contient le nombre d’octets équivalents aux 10
ASCII
CALL CONV_BCDP ; Procédure de conversion d’ASCII en BCP Paqueté
MOV BX, OFFSET DATA2_ASC ; BX pointe sur les données de la deuxième série ASCII
MOV DI, OFFSET DATA2_ BCD ; DI  les données de la deuxième série convertie en
BCD
MOV CX, 10 ; CX contient le nombre d’octets équivalents aux 10
ASCII
CALL CONV_BCDP ; Procédure de conversion d’ASCII en BCP Paqueté
CALL ADD_BCD ; Procédure d’addition des opérandes BCP Paqueté
MOV SI, OFFSET DATA3_BCD ; SI  les résultats issus de la conversion en BCD

MOV DI, OFFSET DATA3_ASC ; DI  les résultats convertis en ASCII
MOV CX, 5 ; CX contient le nombre de MOTS (5) a convertir en
ASCII
CALL CONV_ASC ; Procédure de conversion de BCD Paqueté en ASCII
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
MOV AH, 4Ch
INT 21h Suite
MAIN ENDP
END MAIN
30/53

; Cette procédure convertit ASCII  BCD Paqueté
CONV_BCDP PROC
ENCORE: MOV AX, [BX] ; BX  données ASCII
XCHG AH, AL
AND AX, 0F0FH ; masque les 3s (MSB) d’ASCII
PUSH CX ; sauvegarder le compteur CX, puisqu’on l’utilisera
MOV CL, 4 ; pour décaler 4 fois
SHL AH, CL ; décaler 4 fois a gauche, pour être prêt au paquetage
OR AL, AH ; combinaison pour la conversion en BCD Paqueté
MOV [DI], AL ; DI  données BCD
ADD BX, 2 ; pointer au prochains 2 octets ASCII
INC DI ; pointer pour la prochaine donnée (mot) BCD
POP CX ; retrouver la valeur du compteur de boucle
LOOP ENCORE
RET
CONV_BCDP ENDP
;---------------------------------------------------------------------------------------------------------------------------------------------------
; Cette procédure additionne 2 opérandes multimots en BCD Paqueté
BCD_ADD PROC
MOV BX, OFFSET DATA1_BCD ; BX  les opérandes 1 (de la 1ere série converties en
BCD)
MOV DI, OFFSET DATA2_BCD ; DI  les opérandes 2 (de la 2eme série converties en
BCD)
MOV SI, OFFSET DATA3_BCD ; SI  les résultats de l’addition en BCD
MOV CX, 5 ; CX contient le nombre de mots (5) a additionner en BCD
CLC ; CF  0
ARRIERE: MOV AL, [BX]+4 ; obtenir les prochain octet de l’opérande 1
ADC AL, [DI]+4 ; additionner avec les prochain octet de l’opérande 2
DAA ; correction pour l’addition BCD
MOV [SI]+4, AL ; sauvegarder le résultat de l’addition BCD
DEC BX ; pointer sur le prochain octet de l’opérande 1
DEC DI ; pointer sur le prochain octet de l’opérande 2
DEC SI ; pointer sur le prochain octet de la somme
31/53

LOOP ARRIERE
RET
BCD_ADD ENDP
;---------------------------------------------------------------------------------------------------------------------------------------------------
; Cette procédure convertit BCD Paqueté  ASCII
CONV_ASC PROC
REPETER: MOV AL, [SI] ; SI  les données en BCD
MOV AH, AL ; Dupliquer pour dépaqueter
AND AX, 0F00FH ; SI  les résultats de l’addition en BCD
PUSH CX ; Sauvegarder le compteur
MOV CL, 04 ; pour décaler
SHR AH, CL ; décaler a droite de 4 fois pour obtenir le quartet MSB
OR AX, 3030H ; conversion vers ASCII en ajoutant les 3s
XCHG AH, AL ; permuter pour retrouver les codes ASCII
MOV [DI], AX ; sauvegarder la donnée ASCII
INC SI ; pointe sur la prochaine donnée BCD
INC DI, 2 ; pointe sur la prochaine donnée ASCII
POP CX ; retrouver le CX original du compteur
LOOP REPETER ; répéter jusqu’à ce que CX=0
RET
CONV_ASC ENDP
;-----------------------------------------------------------------------------------------------------------------------------------------------------------

32/53

SOUSTRACTION BCD ET CORRECTION
De même que l’addition, soustraire deux nombres BCD (Paqueté) ne donne pas
forcement un nombre BCD, car nous risquons d’avoir les digits A, B, … F. Pour y
remédier le programmeur doit corriger en soustrayant 6 (0110). Les P-CISC sont
menés d’une instruction spécifique, comme DAS d’Intel.
De même que DAA, DAS travaille uniquement avec le registre AL. Ses actions
sont:
- Si après SUB ou SBB, le Quartet (Nibble) LSB est >9 ou si AF = 1  soustraire

0110 au Quartet LSB. Sinon l’instruction DAS laisse le résultat tel qu’il est après
SUB/SBB.
- Si le Quartet (Nibble) MSB est >9 ou si CF = 1  ajouter 0110 au Quartet MSB.
Exemple:
47H - 29H (AF = 1) DAS

33/53

SOUSTRACTION BCD ET CORRECTION
BUDGET DT 87965141012 ; La Directive DT (Ten ou 10 Octets) pour représenter les

DEPENSES DT 31610640392 ; nombres BCD, de 0 a 1020-1. Pas besoin de spécifier H.
BALANCE DT ? ; BALANCE = BUDGET - DEPENSES
MOV CX, 10 ; Compteur = 10

MOV BX, 00 ; pointeur BX  0
CLC ; CF = 0 pour la 1ere itération
REPETER: MOV AL, BYTE PTR BUDGET[BX] ; saisir un octet du BUDGET
MOV AL, BYTE PTR DEPENSES[BX] ; saisir un octet du DEPENSES
DAS ; Corriger le résultat pour la soustraction BCD
MOV BYTE PTR BALANCE[BX], AL ; Sauvegarder dans BALANCE
INC BX ; Incrémenter pour le prochain Octet
LOOP REPETER ; Continuer la boucle jusqu’à CX = 0
Noter
l’utilisation du mode d’adressage « Base relatif : BX + depl.» pour permettre l’accès d’un
tableau a 3 dimension avec un seul registre pointeur BX. C’est l’avantage que procure ce
type de mode d’adressage.
La directive BYTE PTR est pour indiquer que les données pointées par BX sont des Octets et par
des Mots. Sans cette directive, le P prendra en considération deux bytes au lieu d’un.

34/53

ADDITION ET SOUSTRACTION ASCII
Il est possible d’effectuer une addition et une soustraction en ASCII sans le besoin de masquer
les 3s (011), moyennant les instructions AAA et AAS qui utilisent également le registre AL.
MOV AL, ‘5’ ; 35h  AL

ADD AL, ‘2’ ; 35h + 32h  67h (dans AL)
AAA ; 67h  07h
OR AL, 30h ; AL OR 30H  37h (code ASCII de ‘7’)
Si l’addition est >9, AAA applique la correction en ajoutant 0110 et le bit extra  CF  AH
SUB AH, AH ; AH = 00
MOV AL, ‘5’ ; 35h  AL
MOV BL, ‘7’ ; 37h  BL
ADD AL, BL ; 35h + 37h  6Ch (dans AL)
AAA ; 6Ch  02h (dans AL) et CF=AH=1
OR AX, 3030h ; AX OR 3030H  3137h (code ASCII de ‘12’)
Remarque: la donnée a ajouter peut bien être en BCD NonPaqueté au lieu d’ASCII.
MOV AX, 105H ; 0105h  AX (BCD NonPaqueté de 15)

ADD CL, 06 ; 06H  CL
SUB AL, CL ; FFH  AL (5-6 = -1)
AAS ; FFh – 06h  09h et AH –1  AH  0009H  AX

35/53

ADDITION ET SOUSTRACTION ASCII: Exemple
TITLE prog3_8.asm: Additionner des nombres ASCII
PAGE 60, 132
.MODEL SMALL
.STACK 64
;----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.DATA
VAL_1 DB ‘0649147816’
ORG 0010H
VAL_2 DB ‘0072687188’
ORG 0020H
RES_1 DB 10 DUP(?) ; réserver 10 cases mémoire pour le résultat
RES_1 ORG 0030H
RES_2 DB 10 DUP(?) ; réserver 10 cases mémoire pour le résultat
RES_2
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.CODE
MAIN PROC FAR
MOV AX, @DATA
MOV DS, AX
CALL ASC_ADD ; Appeler la procédure d’addition des nombres AS
CALL BCDNP_ASC ; Appeler la procédure de conversion vers ASCII
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
MOV AH, 4Ch
INT 21h
MAIN ENDP
END MAIN Suite
36/53

;---------------------------------------------------------------------------------------------------------------------------------------------------
; Cette procédure permet d’additionner des nombres ASCII et prend le résultat en BCD NonPaqueté
ASC_ADD PROC
CLC ; 0  CF
MOV CX, 10 ; compteur de boucle (10 octets)
MOV BX, 9 ; BX  l’Octet LSB
ARRIERE: MOV AL, VAL_1[BX] ; Prendre le prochain octet de l’opérande 1
ADC AL, VAL_2[BX] ; Additionner le prochain octet de l’opérande 2
AAA ; Ajustant pour le rendre ASCII
MOV RES_1[BX], AL ; Sauvegarder la somme ASCII
DEC BX ; pointe sur le prochain octet ASCII
LOOP ARRIERE ; répéter jusqu’à ce que CX=0
RET
ASC_ADD ENDP
;---------------------------------------------------------------------------------------------------------------------------------------------------
; Cette procédure permet de convertir le BCD NonPaqueté vers ASCII
BCDNP_ASC PROC
MOV BX, OFFSET RES_1 ; BX  Données BCD NP
MOV SI, OFFSET RES_2 ; SI  Données ASCII
MOV CX, 5 ; compteur de boucle (5 mots)
ARRIERE2: MOV AX, WORD PTR[BX] ; Prendre les 2 prochains octets ASCII
OR AX, 3030H ; Insérer les 011s (3s) d’ASCII
MOV WORD PTR[BX], AX ; Sauvegarder la conversion en ASCII
ADD BX,2 ; Incrémenter le pointeur BCD NP
ADD SI,2 ; Incrémenter le pointeur ASCII
LOOP ARRIERE2 ; répéter jusqu’à ce que CX=0
RET
BCDNP_ASC ENDP
;---------------------------------------------------------------------------------------------------------------------------------------------------

37/53

TITLE prog3_8b.asm: Additionner des nombres ASCII en Segment Complet (Ancien style de l’assembleur)
PAGE 60, 132
STSEG SEGMENT
DB 64 DUP(?)
STSEG ENDS
;---------------------------------------------------------
DTSEG SEGMENT
VAL_1 DB ‘0649147816’
ORG 0010H
VAL_2 DB ‘0072687188’
ORG 0020H
RES_1 DB 10 DUP(?) ; réserver 10 cases mémoire pour le résultat RES_1
ORG 0030H
RES_2 DB 10 DUP(?) ; réserver 10 cases mémoire pour le résultat RES_2
DTSEG ENDS .CODE
;---------------------------------------------------------
CDSEG SEGMENT
MAIN PROC FAR
ASSUME CS:CDSEG, DS:DTSEG, SS:STSEG
MOV AX, DTSEG
MOV DS, AX
CALL ASC_ADD ; Appeler la procédure d’addition des nombres AS
CALL BCDNP_ASC ; Appeler la procédure de conversion vers ASCII
MOV AH, 4Ch
INT 21h
MAIN ENDP
; Cette procédure permet d’additionner des nombres ASCII et prend le résultat en BCD NonPaqueté
ASC_ADD PROC
CLC ; 0  CF
MOV CX, 10 ; compteur de boucle (10 octets)
MOV BX, 9 ; BX  l’Octet LSB

38/53
ARRIERE: MOV AL, VAL_1[BX] ; Prendre le prochain octet de l’opérande 1

ADC AL, VAL_2[BX] ; Additionner le prochain octet de l’opérande 2
AAA ; Ajustant pour le rendre ASCII
MOV RES_1[BX], AL ; Sauvegarder la somme ASCII
DEC BX ; pointe sur le prochain octet ASCII
LOOP ARRIERE ; répéter jusqu’à ce que CX=0
RET
ASC_ADD ENDP
; Cette procédure permet de convertir le BCD NonPaqueté vers ASCII
BCDNP_ASC PROC
MOV BX, OFFSET RES_1 ; BX  Données BCD NP
MOV SI, OFFSET RES_2 ; SI  Données ASCII
MOV CX, 5 ; compteur de boucle (5 mots)
ARRIERE2: MOV AX, WORD PTR[BX] ; Prendre les 2 prochains octets ASCII
OR AX, 3030H ; Insérer les 011s (3s) d’ASCII
MOV WORD PTR[BX], AX ; Sauvegarder la conversion en ASCII
ADD BX,2 ; Incrémenter le pointeur BCD NP
ADD SI,2 ; Incrémenter le pointeur ASCII
LOOP ARRIERE2 ; répéter jusqu’à ce que CX=0
RET
BCDNP_ASC ENDP
CDSEG ENDS
;------------------------------------------------------------
END MAIN

39/53

MULTIPLICATION ET DIVISION EN BCD NONPAQUETÉ
Les instructions AAM et AAD convertissent le résultat de la ‘X’ et de la ‘/’ en BCD NonPaqueté.
Le manuel d’Intel parle de ASCII Ajust Multiplication et Division pour AAM et AAD. Mais en réalité, il s’agit d’une
correction pour les ‘X’ et ‘/’ en code BCD NonPaqueté.
Les instructions AAM et AAD travaille seulement avec le registre AX.
Si 2 opérandes en BCD NonPaqueté sont a multiplier, AAM convertit le résultat en BCD NonPaqueté. La
conversion vers ASCII est du ressort de l’utilisateur en utilisant OR par exemple. De même pour la division
avec AAD.
MOV AL, ‘7’ ; 37h  AL

AND AL, 0Fh ; 07h  AL en BCD NonPaqueté
MOV DL, ‘6’ ; 36h  DL
AND DL, 0Fh ; 06h  DL en BCD NonPaqueté
MUL DL ; AL x DL  AX (07 x 06 = 002Ah ou 42D)
AAM ; Correction: 0402  AX en BCD NonPaqueté (7x6=42)
OR AX, 3030h ; AX OR 3030H  3432h (code ASCII de ‘42’)
MOV AX, 3539 ; 3539h  AL. ASCII de 59

AND AX, 0F0Fh ; 0509h  (AH, AL) en BCD NonPaqueté
AAD ; Correction: 003Bh  AX (le HEX de 59D)
MOV BH, 08h ; Diviser par 8
DIV BH ; 3B/08  AL= 07 et AH = 03
OR AX, 3030h ; AL = 37H (quotient), AH = 33H (reste), les ASCII de Q et R

40/53
Section 3.5: Opérations Logiques (Niveau Bit) en C
L’avantage du langage C  opérations logiques: A B ~A A&B A|B A^B

- Donnée >> nombre de bits a décaler a droite 0 0 1 0 0 0
- Donnée << nombre de bits a décaler a gauche
0 1 1 0 1 1
/* prog3_9.c Reprends quelques exemples précédents en C */
1 0 0 0 1 1
#include <stdio.h>
main() 1 1 0 1 1 0
{
// Les données HEX en C sont définit en utilisant 0x
unsigned char data_1 = 0x35;
unsigned int data_2 = 0x504;unsigned int data_3 = 0xDA66;
unsigned char data_4= 0x54;unsigned char data_5=0x78;
unsigned char data_6=0x37;unsigned char data_7=0x09A;
unsigned char temp;unsigned int temp_2;
temp=data_1&0x0F; //ET
printf("\nMasque le quartet MSB de %X (hex) nous avons %X (hex)\n",data_1,temp);
temp_2=data_2|data_3; //OU
printf(« Le résultat de %X hex ORé avec %X hex est %X hex\n",data_2,data_3,temp_2);
temp= data_4^data_5; //XOR
printf(" Le résultat de %X hex ORé avec %X hex est %X hex\n",data_4,data_5,temp);
temp=~data_6; //INVERSE
printf(" Le résultat de %X hex inversé est %X hex\n",data_6,temp);
temp=data_7>>3; // DECALAGE DROITE
printf(« Quand %X hex est décalé a gauche 3 fois, nous avons %X hex\n",data_7,temp);
printf(" Quand %X hex est décalé a droite 3 fois, nous avons %X hex\n",0x7777,0x7777>>4);
temp=(0x6<<4); //DECALAGE GAUCHE
printf(" Quand %X hex est décalé a gauche %d fois, nous avons %X hex\n",0x6,4,temp);
}
41/53
Section 3.6: Opérations arithmétiques signées
Températures  +15°C, 0 °C, -21°C  Nombres non signés
Octet Signé 
D7 D6 . . . . . D0
+127 0111 1111 Signe
Magnitude
+126 0111 1110
… …
+2 0000 0010 Nombres positifs
[ - 128  + 127 ]
+1 0000 0001
0 0000 0000
-1 1111 1111
-2 1111 1110
Nombres négatifs  ‘Complément à 2’ des magnitudes de leurs équivalents positifs
… … - n = NOT (+ n) + 1
-127 1000 0001 Exemple: -32  NOT (+32d = 00100000b) + 1  11011111 + 1  11100000b
-128 1000 0000
Mot Signé 
D15 D14 D8 D7 D6 . . . . . D0
+32767 0111 1111 1111 1111
+ Signe
+1 0000 0000 0000 0001 Magnitude
0 0000 0000 0000 0000
-1 1111 1111 1111 1111
-
-32768 1000 0000 0000 0000 [ - 32768  + 32767 ]
42/53
Opérations arithmétiques signées

PROBLEME DU DEPASSEMENT dans l’arithmétique non signée  CBW, CWD
Exemples:
- Avec un P de 8 bits  (+60H) + (+46h) 

+96d + (+70d)  + 166d mais le P donne –90d ?!?!? avec CF=0, SF=1 et OF = 1
- Avec un P de 16 bits 
+ 6E2Fh + (+ 13D4h)  + 8203h mais le P donne –7DFD ?!?!? avec CF=0, SF=1 et OF = 1
OF = 1 si:
- Il existe une retenue de D6 à D7 (SF=1) mais pas de retenue a la sortie de D7 (CF = 0) dans
le cas d’opérations sur octets. Ou une retenue de D14 à D15 (SF=1) mais pas de retenue a
la sortie de D15 (CF = 0) dans le cas d’opérations sur des mots.
- Il y’a une retenue a la sortie de D7 (CF = 1) mais pas de retenue de D6 à D7 (SF=0) dans le
cas d’opérations sur octets. Ou d’une retenue a la sortie de D15 (CF = 1) mais pas de
retenue de D14 à D15 (SF=0) dans le cas d’opérations sur des mots.
En d’autres termes:
OF = CF XOR SF
Règle: si OF=1  le résultat est erroné  Correction avec avec les instructions CBW, CWD
43/53

7 0 7 0
- Instruction CBW
Copie le SF d’un octet vers les bits de AH
AH AL
DATA1 DB +96
DATA2 DB +70
RESLT DW ?
---
SUB AH, AH ; 00h  AH
MOV AL, DATA1 ; Opérande 1
MOV BL, DATA2 ; Opérande 2
ADD AL, BL ; les additionner
JNO PASSE ; Si OF = 0 effectuer l’addition normalement et sauvegarder le résultat de AX
MOV AL, DATA2 ; sinon on corrige avec CBW. On commence avec l’ Opérande 2
CBW ; Note: CBW travaille toujours avec AL
MOX BX, AX ; sauvegarder dans BX
MOV AL, DATA1 ; correction avec l’ opérande 1
CBW ; Note: CBW travaille toujours avec AL
ADD AX, BX ; Additionner les deux opérandes après correction (extension du signe)
PASSE: MOV RESLT, AX ; sauvegarder le résultat de AX
- Instruction CWD 15 0 15 0
Copie le SF d’un mot vers les bits de DX

DX AX
A titre d’exercice on reprend l’exemple précédent avec DW pour DATA1 (+96F4h) et DATA2 (+70C!H),
DD pour RESLT, CWD au lieu de CBW, AX au lieu de AL, AX+DX au lieu de AX (addition multimot).
Note: C’est à l’utilisateur, et non pas le P, d’effectuer la correction dans les opérations non signées.

44/53

MULTIPLICATION ET DIVISION SIGNÉE (IMUL / IDIV) reg. (ou mém.)
Note: Dans les manuels d’Intel IMUL et IDIV pour Integer MULtiplication et DIVision (X et / des
nombres entiers) mais au fait il s’agit de Multiplication et Division des nombres signées.
DIVISION SIGNEE NUM. (> ou <) DENOM. (> ou <) QUOTIENT RESTE
Octet/Octet AL = Octet CBW Reg. ou mem. AL AH
Mot/Mot AX = Mot CWD Reg. ou mem. AX DX
Mot/Octet AX = Mot Reg. ou mem. AL (Erreur si –128>AL>+127) AH
DoubleMot/Mot DXAX = DoubleMot Reg. ou mem. AX (Erreur si –32768>AX>+32767) DX
MULTIPLICATION OPERANDE 1 OPERANDE 2 RESULTAT

SIGNEE (> ou <) (> ou <)
Octet/Octet AL Reg. ou mem. AX (CF=OF=1 si AH possède une partie du résultat,
mais si celui-ci n’est pas large  pas besoin de AH,
le bit de signe est copié aux bits non utilisés de AH et
la CPU force CF=OF=0 pour l’indiquer)
Mot/Mot AX Reg. ou mem. DXAX(CF=OF=1 si DX possède une partie du

résultat, mais si celui-ci n’est pas large  pas besoin
de DX, le bit de signe est copié aux bits non utilisés
de DX et la CPU force CF=OF=0 pour l’indiquer)
Mot/Octet AL = Octet Reg. ou mem. DXAX (même remarque que précédemment)

CBW
DoubleMot/Mot
45/53

TITLE PROG3_10.asm EXEMPLE D’UTILISATION DE IDIV  TROUVER LA TEMPERATURE MOYENNE
PAGE 60,132
.MODEL STMALL
.STACK 64
.DATA
SIGN_DAT DB +13,-10,+19,+14,-18,-9,+12,-9,+16
ORG 0010H
MOYENNE DW ?
RESTE DW ?
.CODE
MAIN PROC FAR
MOV AX,@DATA
MOV DS,AX
MOV CX,9 ; Charger le compteur
SUB BX,BX ; Mettre a 0 le registre BX, utilisé comme accumulateur
MOV SI,OFFSET SIGN_DAT ; SI  SIGN_DAT
ARRIERE: MOV AL,[SI] ; Un octet de donnée  AL
CBW ; Extension du signe  AX
ADD BX,AX ; BX+AXBX
INC SI ; SI+1  SI
LOOP ARRIERE ; Boucler tant que CX > 0
MOV AL,9 ; Le nombre totales des températures  AL
CBW ; Extension du signe  AX
MOV CX,AX ; Sauvegarder le DENOMINATEUR dans CX
MOV AX,BX ; LA somme des températures  AX
CWD ; Extension du signe  AX
IDIV CX ; Trouver la moyenne des températures (AX/CX)
MOV MOYENNE,AX ; Sauvegarder la moyenne (QUOTIENT)
MOV REMAINDER,DX ; Sauvegarder le reste
MOV AH,4CH INT 21H ;Retourner au DOS
MAIN ENDP
END MAIN
46/53

TITLE PROG3_10.lst TROUVER LA TEMPERATURE MOYENNE
PAGE 60,132
0000 .MODEL STMALL
0000 .STACK 64
0000 .DATA
0000 0D F6 13 0E EE F7 0C ED 10 DB +13,-10,+19,+14,-18,-9,+12,-9,+16
0010 ORG 0010H
0010 0000 MOYENNE DW ?
0012 0000 RESTE DW ?
0014 .CODE
0000 MAIN PROC FAR
0000 B8 0000s MOV AX,@DATA
0003 8E D8 MOV DS,AX
0005 B9 0009 MOV CX,9
0008 2B DB SUB BX,BX
000A BE 0000r MOV SI,OFFSET SIGN_DAT
000D 8A 04 ARRIERE: MOV AL,[SI]
000F 98 CBW
0010 03 D8 ADD BX,AX
0012 46 INC SI
0013 E2 F8 LOOP ARRIERE
0015 B0 09 MOV AL,9
0017 98 CBW
0018 8B C8 MOV CX,AX
001A 8B C3 MOV AX,BX
001C 99 CWD
001D F7 F9 IDIV CX
001F A3 0010r MOV MOYENNE,AX
0022 89 16 0012r MOV REMAINDER,DX
0026 B4 4C MOV AH,4CH
0028 CD 21 INT 21H
002A MAIN ENDP
END MAIN
47/53
Décalage et Comparaison arithmétiques signées
DECALAGE ARITHMETIQUE (SAR / SAL) REG NombreDeFois

Note: Contrairement au décalage logique, vue précédemment, dans le décalage arithmétique on tient
compte du bit de signe. SAR est utilisée pour diviser les nombres signées par 2.
L’instruction arithmétique SAL fait la même chose que son équivalente logique SHL vue précédemment.
MOV AX, -9
MOV BL, 2 D7 D6 D0 CF
IDIV BL ; -9 / 2  FCh = - 4 (approximation vers le haut)
MOV AX, -9 SAR
SAR AX, 1 ; -9 /2 avec le décalage arithmétique  FBh = - 5 (approximation vers le bas)
COMPARAISON DES NOMBRES SIGNÉS CMP dest., src avec JG, JGE, JL, JLE et JE
Avec les nombres non signés, les indicateurs CF et ZF sont utilisés avec l’instruction CMP pour la
vérification des conditions J . Alors qu’avec les nombres signés c’est les indicateurs OF, SF et ZF qui
sont utilisés.
dest. > source  OF=SF ou ZF=0

dest. = source  ZF=1
dest. < source  OF=INV(SF)

JG ; Saut si OF=SF ou ZF=0
JGE ; Saut si OF=SF
JL ; Saut si OF=not(SF)
JLE ; Saut si OF=not(SF) ou ZF=1
JE ; Saut si ZF=1

48/53
Décalage et Comparaison arithmétiques signées
TITLE PROG3_11.asm ;TROUVER LA TEMPERATURE LA PLUS BASSE

PAGE 60,132
;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.MODEL SMALL
.STACK 64
;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.DATA
SIGN_DAT DB +13, -10, +19, +14, -18, -9, +12, -9, +16
ORG 0010H
PLUS_BASSE DB ?
;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
.CODE
MAIN PROC FAR
MOV AX,@DATA
MOV DS,AX
MOV CX,8 ; Charger le compteur (nombre total - 1)
MOV SI,OFFSET SIGN_DAT ; SI  SIGN_DAT
MOV AL,[SI] ; La plus basse température trouvée (X) AL
ARRIERE: INC SI ; Incrémenter le pointeur
CMP AL,[SI] ; Comparer le prochain octet a X température
JLE CHERCHE ; Si AL contient X, continuer a chercher
MOV AL,[SI] ; Sinon sauvegarder le résultat
CHERCHE : LOOP ARRIERE ; Boucler tant que CX>0
MOV LOWEST,AL ; Sauvegarder la + basse température trouvée
MOV AH,4CH INT 21H ; DOS
MAIN ENDP
END MAIN

49/53
Section 3.7: Instructions des chaînes et
des tables de données
Les P80x86 possèdent des instructions sur des chaînes de caractères pour effectuer des
opérations avec des opérandes se trouvant dans des locations mémoire.
Instruction Mnémonique Destination Source Préfixe

Dep. Ch. Oct. MOVSB ES:SI DS:SI REP
Dep. Ch. Mot MOVSW ES:SI DS:SI REP
Sav. Ch. Oct. STOSB ES:SI AL REP
Sav. Ch. Mot STOSW ES:SI AX REP
Chg. Ch. Oct. LODSB AL DS:SI /
Chg. Ch. Mot LODSW AX DS:SI /
Cmp. Ch. Oct. CMPSB ES:SI DS:SI REPE/REPNE
Cmp. Ch. Mot CMPSW ES:SI DS:SI REPE/REPNE
Scn. Ch. Oct. SCASB ES:SI AL REPE/REPNE
Scn. Ch. Oct. SCASW ES:SI AX REPE/REPNE
DF (registre flag)  Incrémentation (DF=0) Décrémentation (DF=1) du pointeur utilisé pour les opérations
CLD  DF=0 STD  DF=1
XLAT (translater) est une instruction pour accéder a des éléments d’une table de données

50/53
Instructions des chaînes et des tables de données
Exemple: REP MOVSB et CLD
TITLE PROG3_12.asm ;Transfert un bloc de 20 octets dans la mémoire

PAGE 60,132
.MODEL SMALL
.STACK 64
.DATA
DATA_S DB ‘AQWERTTYUIOPLJKHGFDS’
ORG 0030H
DATA_D DB 20 DUP(?)
.CODE
MAIN PROC FAR
MOV AX,@DATA
MOV DS,AX ; Initialiser le segment de données
MOV ES,AX ; Initialiser le segment Extra
CLD ; DF=0  Auto-incrémentation des pointeurs SI et DI
MOV SI,OFFSET DATA_S ; Charger le pointeur source
MOV DI,OFFSET DATA_S ; Charger le pointeur destination
MOV CX, 20 ; Charger le compteur
REP MOVSB ; Déplacer les octets pointés par SI vers des locations pointés par DI et répéter
jusqu’a ; CX  0, sachant qu’a chaque itération SI et DI sont automatiquement incrémentés
MOV AH,4CH
INT 21H ; DOS
MAIN ENDP
END MAIN

51/53

Exemple: LODSB, REP STOSW et CLD
TITLE PROG3_13.asm ; Stocker une données (CCh) dans 100 locations mémoire et tester leurs contenus
pour ; vérifier si la mémoire est défectueuse, auquel cas un message est affiché
PAGE 60,132
.MODEL SMALL
.STACK 64
.DATA
MESSAGE DB ‘ Mémoire défectueuse’
ESP_MEM DB 100 DUP(?)
.CODE
MAIN PROC FAR
MOV AX,@DATA
MOV CX, 50 ; Charger le compteur avec 50 (50 mots = 100 octets)
MOV DI,OFFSET ESP_MEM ; Charger le pointeur destination
MOV AX, 0CCCCH ; le pattern qui servira de test
REP STOSW ; Placer AAAAH dans 50 locations mémoires pointées par DI (jusqu’à CX0)
; sachant qu’a chaque itération DI est automatiquement incrémenté
MOV SI,OFFSET ESP_MEM ; Charger le pointeur source
MOV CX, 100 ; Charger le compteur avec 100 (100 octets)
ENCORE: LODSB ; Charger de DS:SI vers AL (pas de REP)
XOR AL, AH ; Est ce que le pattern est est le même, sachant que dans AL et AH se trouve CCh
JNZ PASSE ; Sortir du programme si c’est différent  mémoire défectueuse
LOOP ENCORE ; continue jusqu’a CX0
JMP SORTIR
PASSE: MOV DX, OFFSET MESSAGE ; Afficher un message sur écran
MOV AH,09H ; le message est ‘Mémoire défectueuse’
INT 21H ; DOS
SORTIR: HALT
MAIN ENDP
END MAIN
52/53

Exemple: REPE CMPSB et CLD
TITLE PROG3_14.asm ; Vérifier l’orthographe d’un mot et afficher un message

PAGE 60,132
.MODEL SMALL
.STACK 64
.DATA
MOT_EXACT DB ‘EUROPE’
MOT_TAPEE DB ‘EUORPE’
MESSAGE1 DB ‘L’orthographe est juste’ , ‘$’
MESSAGE2 DB ‘L’orthographe est fausse’ , ‘$’
.CODE
MAIN PROC FAR
MOV AX,@DATA
MOV SI,OFFSET MOT_EXACT ; Charger le pointeur source
MOV DI,OFFSET MOT_TAPEE ; Charger le pointeur destination
MOV CX, 6 ; Charger le compteur avec 6 (6 lettres ou octets)
REPE CMPSB ; Répéter tant que les deux lettres sont égales ou jusqu’a C= 0. Si c’est différent le programme
; sort de cette instruction. A noter qu’a chaque itération SI et DI sont automatiquement
incrémentés.
JE PASSE ; Si ZF=1 afficher le message 1 (égalité)
MOV DX,OFFSET MESSAGE2 ; Si ZF=0 afficher le message 2 (différence)
JMP AFFICHAGE
PASSE: MOV DX, OFFSET MESSAGE1

AFFICHAGE: MOV AH,09H ; le message est ‘Mémoire défectueuse’
INT 21H ; DOS
MAIN ENDP
END MAIN

53/53
Exemple: REPNE SCASB et CLD
TITLE PROG3_14.asm ; Balayer une chaîne de caractère et Remplacer une lettre particulière par une autre
PAGE 60,132
.MODEL SMALL
.STACK 64
.DATA
CHAINE DB ‘Mr. Gones’ , ‘$’
.CODE
MAIN PROC FAR
MOV AX,@DATA
MOV DI, OFFSET CHAINE ; Charger le pointeur destination ES:DI
MOV CX, 9 ; Charger le compteur avec 9 (la taille de la chaîne de caractères)
MOV AL, ‘G’ ; le caractère a scanner (balayer)
REPNE SCASB ; Répéter le balayage tant que les deux lettres ne sont pas égales ou jusqu’a C=
0. JNE PASSE ; Saut si ZF=0 afficher le message 1 (égalité)
DEC DI ; Décrémenter DI (a la lettre G) car entre autre DI s’est automatiquement
incrémenté
MOV BYTE PTR[DI], ‘J’ ; Remplacer ‘G’ par ‘J’
PASSE: MOV DX, OFFSET CHAINE
AFFICHAGE: MOV AH,09H ; le message correcte est affiche: ‘Mr. Jones’
INT 21H ; DOS
MAIN ENDP
END MAIN

Cours Up Beguenane 3

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

Cours Up Beguenane 3

Transféré par

Droits d'auteur :

Formats disponibles

1/53

Chapitre 3 : Instructions Arithmétiques et Logiques,

Section 3.1: Addition et Soustraction en non signe

Section 3.2: Multiplication et Division en non signe

Section 3.3: Instructions logiques et quelques exemples

Section 3.4: Instructions ASCII et BCD

Section 3.5: Opérations au niveau bit dans le langage C

Section 3.6: Opérations arithmétiques non signées

Section 3.7: Instructions des chaînes et des tables de

Section 3.1 Addition et Soustraction en non signé

ADDITION NON SIGNÉE

ADD destination, source ;Opérande dest. = Opérande dest. + Opérande source

MOV AL, 0F5H 1111 0101

ADC AL, 0BH 0000 0000

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

Addition et Soustraction en non signé

PAGE 60, 132

ENCORE: ADD AL, [SI] ENCORE: ADD AL, [SI]

Addition et Soustraction en non signé

PAGE 60, 132

ADC BX, 0 ; ajouter la retenue a BX

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

Addition et Soustraction en non signé

MOV SI, OFFSET DATA1 ; SI est pointeur vers l’opérande DATA1

Addition et Soustraction en non signé

SOUSTRACTION NON SIGNÉE

SUB destination, source ;Opérande dest. = Opérande dest. - Opérande source

MOV DH, 4CH

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

Addition et Soustraction en non signé

SBB destination, source ;Opérande dest. = Opérande dest. - Opérande source – CF

MOV AX, WORD PTR DATA_A + 2 ; AX = 0625h

SUB  AX = 62FA – 963B = CC3B et CF =1 

Multiplication et Division en non signé

Noter que plusieurs modes d’adressage peuvent être utilisés.

MOV AL, DATA1

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

Multiplication et Division en non signé

MULTIPLICATION NON SIGNÉE MUL reg. (ou mém.)

Multiplication et Division en non signé

MULTIPLICATION NON SIGNÉE

Multiplication Opérande 1 Opérande 1 Résultat

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

Multiplication et Division en non signé

DIVISION NON SIGNÉE DIV reg. (ou mém.)

Dans la division des nombres non signées, 4 cas sont considérés:

; ------------------ du segment de données ------------------------------------------------------------------

; ------------------ du segment de code ------------------------------------------------------------------

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

Multiplication et Division en non signé

DIVISION NON SIGNÉE DIV reg. (ou mém.)

- Octet / Octet: Les modes d’adressage permis

MOV AL, DATA7 ; le Num.  AL

- Adressage registre indirect:

MOV AL, DATA7 ; le Num.  AL

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

Multiplication et Division en non signé

DIVISION NON SIGNÉE DIV reg. (ou mém.)

MOV AX, 10050 ; Num.  AX

DIV DATA10 ; [DX,AX] / DATA10

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

MOV BL, 35H

MOV AX, 0504H