Polyasm

ASSEMBLEUR 8086
1 Introduction
1.1 Architecture d'un ordinateur
Un ordinateur de type PC est constitue d'elements assurant des fonctions pre-
cises : le calcul, la memoire, la circulation des informations(programmes et donnees),
le contrôle des dierents organes.
Bus d’adresse
Mémoire RAM
Accumulateur Registre Registre

instruction
d’adresse
Registre
UAL mémoire
de données
registres de la mémoire
opérandes
Bus de données
Principe d’une architecture de type PC

Un programme est une suite de codes stockes en memoire. Chaque element de
code en est extrait et stocke, au cours de l'execution d'un programme, dans une
petite memoire elementaire ou registre : le registre d'instructions. Apres decodage,
les donnees sont lues en memoire, circulent le longs de ls qu'on designe sous le
nom de ligne omnibus ou plus simplement de bus : le bus des donnees; puis elles
sont stockees dans des registres de donnees. De la, elles sont injectees dans la cen-
trale de calcul (ou Unite Arithmetique et Logique UAL), qui represente le cur
du microprocesseur. Le resultat est place dans un registre particulier qu'on appelle
l'accumulateur, puis, eventuellement, range en memoire apres avoir parcouru le bus
de donnees. Un contrôle tres n du cadencement des dierentes parties de chaque
operation est realise a l'aide d'une horloge extremement precise qui permet de syn-
chroniser les dierents signaux qui parcourent l'architecture.
1.2 Niveaux de langage
On distingue :
{ le niveau interne qui correspond aux commandes des dierents signaux de
contrôle des circuits.
{ le code machine: code du microprocesseur qu'il sait reconna^tre et auquel il
associe une serie de commandes internes synchronisees par l'horloge.
Par exemple, le code 41 a pour signication: ajouter 1 au contenu d'un registre
appele AL.
1
{ Le mnemonique ou assembleur. Programmer en code machine est peut pra-
tique, et on prefere decrire des operations a realiser a l'aide de mots-cles qui
rappelent la signication de cette operation. Un programme special ( pour
nous TURBO-ASSEMBLEUR) compile ce langage. La compilation est une
operation en 2 phases : apres verication de la validite du programme decrit
en assembleur, ce dernier est traduit en code machine prêt a être execute. ( a
une operation pres qu'on appele l'edition de liens).
Par exemple, incrementer de 1 le registre AL s'ecrit en assembleur 8086: INC
AL
{ les langages evolues : PASCAL, C, ADA, COBOL, .. .En PASCAL, par exemple,
l'operation precedente pourrait s'ecrire : i:= i + 1 ;
1.3 Numeration
1.3.1 Representation des nombres
L'atome d'information s'appele le bit et vaut 0 ou 1. Avec un bit, on peut coder
2 informations dierentes, deux etats : mâle ou femelle, noir ou blanc, .. .
Avec 2 bits, on peut coder 4 (22 ) etats ou congurations dierentes : 00, 01, 10
et 11. soient les 4 saisons, 4 chires, 4 situations particulieres .. .
On a convenu tres tôt de grouper les bits par 8 pour constituer un octet, ce qui
permet de coder 28 nombres ou etats. Un octet permet de coder 256 valeurs die-
rentes, ce qui est susant, en occident, pour representer l'ensemble des caracteres
d'un clavier de machine a ecrire. A chaque valeur sur 8 bits correspond un symbole
alphanumerique. Plusieurs codes existent, mais le plus utilise en informatique, en
tout cas sur un PC est le code ASCII. Dans ce code, le caractere A est code 65, a
est code 97, le chire 0 est code 48.
Enn, on regroupe frequemment les octets par 2, 4 ou plus, pour constituer des
mots, doubles-mots, . . .
On convient que le bit de poids le plus faible d'un nombre sera denomme \bit
0" et que le bit de poids le plus fort sera denomme \ bit 7" ou \bit 15", selon la
longueur de la representation.
1.3.2 Conversion binaire-decimal
Nous travaillons en numeration de position, ce qui signie que, dans n'importe
quelle base de representation, un nombre s'ecrit toujours :
n =
X,
d 1
i
Pi b
k=0
ou d est le nombre de chires, i un poids et b la base. Par exemple, en base 10,
p
2345 s'ecrit : 2 103 + 3 102 + 4 101 + 5 100

: : : :
Un nombre binaire est une suite de 0 et de 1 de poids respectifs : 20, 21, 22 , etc
.. .
Ainsi 1101 a pour valeur en decimal: 1 23 + 1 22 + 0 21 + 1 20 a partir des
: : : :
poids forts, soit 1 + 4 + 8 = 1310

A l'inverse, les divisions successives d'un nombre decimal par 2 donnent les poids
de sa representation binaire.
1.3.3 hexadecimal-decimal
L'hexadecimal est une representation en base 16 tres utilisee quand on pro-
gramme en assembleur. Dans toute base, les poids, ne peuvent aller que de 0 a b-1.
2
De plus, ce sont toujours des chires, car le nombre 13 par exemple, dans une base
b donnee, signie 3 unites et 1 fois la base a la puissance 1. En base 16, on ne peut
plus trouver de chires pour representer les valeurs comprises entre 10 et 15. 10 a
la signication: 0 unites et une seizaine. On utilise donc les lettres A, B,.. .F; A
correspond au 10 decimal, B au 11 decimal, . .. et F au 15 decimal.
Ainsi 2C hexa vaut 2*16+13, soit 4510.
A l'inverse, la division par 16 fournit les poids de la representation hexa d'une
valeur decimale.
1.3.4 hexadecimal-binaire
A un \chire " hexadecimal correspondent 4 bits, car F = 1111. La correspon-
dance est ainsi tres facile.
Partant d'un nombre binaire, il sut de grouper ses bits par 4 a partir des poids
faibles, puis de donner la correspondance hexadecimale de chacun des groupes. Par
exemple:
11 1101 0110 1110 vaut 3D6E
Un programmeur en assembleur doit savoir jongler avec l'ensemble de ces repre-
sentations et codages ( auquels il doit bien souvent ajouter loctal). Ainsi la lettre
À' dont le code decimal en ASCII est 65 a pour representation binaire 01000001b
et 41h en hexadecimal.
1.3.5 Notation des nombres en ASM86
An de permettre a l'assembleur de distinguer les dierentes bases de represen-
tation, les valeurs binaires sont accompagnees d'un b minuscule, les valeurs octales
d'un o minuscules et les valeurs hexa d'un h minuscule. Pour eviter de plus les confu-
sions avec les identicateurs ou mots-cles du langage, les valeurs hexadecimales dont
le premier \chire " est une lettre sont precedees d'un 0.
Exemples :
mov al, 01110100b
mov ah, 75h
mov ax, 0BAD4h
2 Le 8086
2.1 La famille IAPx86
Il s'agit d'une famille de processeurs a compatibilite ascendante, c.a.d. que le
code des plus anciens est toujours compris et correctement execute par les plus
recents.
{ le 8086 dispose d'un bus de 16 bits pour les donnees. sa capacite d'adressage
est de 1Mo et il est cadence a 4.77 ou 8 Mhz.
{ le 8088 est la version 8 bits du 8086. il a les mêmes caracteristiques, mais un
assembleur plus reduit.
{ le 80286 est une machine 16 bits, pouvant adresser 8Mo de code et de donnees,
cadence a 6,8,10,12 ou 16 Mhz. Il introduit 2 modes d'adressage ( reel ou
protege).
{ le 80386 est un faux 32 bits, adressant 4Go et cadence a 16, 20 ou 25 Mhz.
3
{ le 80486 est un vrai 32 bits dote d'une memoire cache integree et d'une unite
de calcul en virgule ottante.
{ le 80586, appele pentium pour des raisons de protection commerciale, dispose
d'un bus de donnees de 64 bits et est muni d'un dispositif de prevision des
branchements. Il est constitue de 2 processeurs en pipe-line paralleles lui per-
mettant d'executer deux instructions en même temps. Son cadencement est
envisage (en 1994) jusqu'a 150 MHZ.
{ le \P6", successeur du pentium, est annonce. Il sera constitue de 6 millions
de transistors ( contre 275 000 pour le 386 , 1 million pour le 486 et 3 pour
le pentium) et la dimension des traits de ses transistors sera de 0.6 microns
(contre 11.5 pour le 386). Il pourra traiter 250 millions d'instructions par
seconde.
Dans la suite, nous ne nous interresserons qu'au 8086.
2.2 Les memoires du 8086
Le 8086 dipose de plusieurs memoires. La plus importante est la memoire de tra-
vail ou RAM (Random Access Memory). C'est elle qui contient la partie active du
systeme, les programmes et les donnees. Il existe une memoire morte (ininscriptible),
la ROM, qui contient le code binaire des instructions assembleur et les sequences
correspondant aux dierentes interruptions.L'ordinateur dispose enn d'une troi-
sieme memoire physiquement distincte de la RAM, la memoire d'Entrees/Sorties,
permettant les echanges avec l'exterieur.
La RAM est un bloc de 1 Mo d'adresses qui est decoupe de la maniere suivante:
La partie basse des adresses est reservee pour le systeme. Au dessus du systeme, on
trouve une zone qui est physiquement limite a 640Ko, dans la quelle on range les
programmes en execution et les donnees actives : le tas. Au dessus du tas se trouve
une pile, destinee a gerer les apels de procedures et les interruptions. Au dessus de
la limite des 640Ko se situe la memoire graphique qui est physiquement situee sur
la carte video.
1 Mo
MEMOIRE
VIDEO
640 Ko
Pile
disponible
pour la pile
ou le tas.
Tas
SYSTEME
4
2.2.1 Mecanisme d'adressage du 8086
Le 8086 peut adresser 1 Mo, soient des adresses allant de 0 a 0FFFFFh. Ceci
pose un pobleme. On a vu que :
{ Un octet peut coder 256 valeurs ( de 0 a 255)
{ Un mot (16 bits) peut en coder 65536 ( de 0 a 65535)
{ Un double-mot (32 bits) peut coder 4 Mo.
Comment a-t-on pu proceder pour qu'une une machine 16 bits puisse adresser da-
vantage que 64 Ko?
En realite, les adresses sont comptees par paquets de 64 Ko. Chacun de ces blocs
d'adresse constitue un SEGMENT. La memoire est donc decoupee en un certain
nombre de segments.
Une adresse logique est constituee de 2 valeurs : un numero de segment et la
valeur de l'oset=deplacemet par rapport au debut du segment.
L'adresse physique du 8086 est representee sur 20 bits (veritable dimension de
son bus d'adresses) soit:
Valeur du segment (16 bits)
* 16 (= d
ecal
ee 4 fois a
gauche)
+ Valeur de l'Offset ( 16 bits)
--------------------------------
= adresse m
emoire sur 20 bits, soit de 0
a 1Mo.
On remarquera que la même adresse absolue peut être obtenue a partir de plu-
sieurs adresses logiques dierentes.
2.3 Les ports d'E/S
En plus de l'espace de 1Mo existe une memoire specialisee de 64 Ko destinee aux
echanges avec l'exterieur (Reseau, imprimantes, ecrans, .. .) Cet echange se fait par
l'intermediaire du port d'Entrees/Sorties (E/S en abrege).
En pratique, on n'utilise qu'un petit nombre d'adresses au sein de cette me-
moire. Les dierents organes connectes a l'ordinateur connaissent la ou les adresses
au niveaux desquelles se font les echanges qui les concernent. Il n'est donc pas
recommande d'ecrire n'importe ou sans precaution.
L'acces a cette memoire se fait a l'aide des instructions IN et OUT.
2.3.1 La memoire Video
Les images video sont implantees en memoire RAM au dela des fatidiques 640 Ko
qui constituent la limite de la memoire centrale ( A l'epoque, vers 1980, il semblait
impossible que l'on ait jamais besoin d'atteindre une limite aussi Kolossale !)
En fait, l'introduction de standards graphiques VGA, VGA etendus, ... a conduit
les architectes a implanter la memoire graphique sur les cartes video elles-mêmes.
Les constructeurs ne s'etant jamais entendu sur un standard, chaque carte a son
propre mode de programmation. Une technique generale existe cependant, assez
lourde, et qui oblige a passer par l'intermediaire d'une zone de la memoire d'E/S et
de registres specialises de la carte graphique.
5
2.3.2 La pile
La programmation d'un ordinateur necessite l'usage (d'au moins) une pile. Une
pile est une structure lineaire dont on ne peut manipuler que le sommet, a l'image
d'une pile d'assiettes : vouloir retirer une assiette du milieu conduit a la catastrophe.
La seule methode d'acces consiste a empiler ou depiler des assiettes a partir du
sommet de la pile. Une telle structure permet de conserver en memoire l'ordre selon
lequel on y a stocke des informations. En les depilant, l'ordinateur se retrouve dans
l'etat ou il etait avant les operations qui ont conduit a des empilements successifs.
L'assembleur vous fera manipuler une pile qui est stockee \en fond de panier",
c.a.d dans les adresses les plus hautes de la memoire. (correspondant aux 640 Ko).
Une petite particularite : La base de la pile se trouve a l'adresse maximale, et elle
s'accroit vers les adresses basses. A l'inverse, les programmes se developpent sur le
\tas", en bas de memoire, juste au dessus de la zone reservee pour le systeme. Pile
et Tas croissent donc a l'inverse l'un de l'autre.
2.4 Les registres
Ce sont des mots de memoire de 16 bits câbles de facon particuliere, qui per-
mettent de retenir des informations au cours de leur manipulation par le programme.
2.4.1 Registres a usage general
4 registres peuvent se decomposer en 2 registres de 8 bits chacun.
{ AX (A pour accumulateur) joue le rôle d'operande implicite dans de nom-
breuses operations : MUL, DIV, INC, . .. La partie de poids forts se nomme
AH et celle de poids faibles AL ( H pour high et L pour low)
15 8 7 0
AH AL
Registre AX
{ BX (B pour base), qui se decompose en BH et BL, sert entre autre a pointer

sur une adresse memoire.
{ CX (C pour compteur) se decompose en CH et CL et est utilise pour les
boucles (loop)
{ DX donne DH et DL
{ il permet de pointer sur l'espace des E/S avec IN et OUT en contenant
la valeur de l'adresse, comme le montre l'exemple suivant:
MOV AL,20
MOV DX,1000
OUT DX, AL
{ il est utilise dans les multiplications et les divisions comme registre d'ex-
tension.
{ SI (Source Index) est souvent utilise comme pointeur sur une adresse memoire:
MOV AL, [SI]
Il est tres utilise avec les instructions de traitement de cha^ne (LODS)
6
{ DI (Destination Index) permet comme SI de pointer sur des adresses memoire.
Il est aussi tres utilise pour les traitements de cha^ne (avec STOS)
{ BP (Base Pointer) sert de pointeur sur l'adresse memoire correspondant a
la base de la pile, et permet en fait d'atteindre n'importe quel element de
celle-ci : MOV AX, [BP+4]
{ SP (Stack Pointer) pointe sur le sommet de la pile. Son contenu est automati-
quement gere par les instructions PUSH et POP d'empilage et de desempilage.
2.4.2 Registres speciaux
{ IP (Instruction Pointer) contient l'adresse de l'instruction qui suit celle qui
est en cours d'execution, c'est-a-dire la prochaine a devoir être executee en
dehors des cas de branchement.
{ DS (Data Segment) pointe sur l'adresse de debut du segment qui contient les
donnees. Un segment est une suite de 65536 adresses. Implicitement, BX et
SI, lorsqu'ils servent de pointeur, sont prexes par DS. Une adresse est donc
completement denie par un couple : DS:BX ou DS:SI
Le nom du segment de donnees standard est DATA. Pour charger DS, il faut
obligatoirement utiliser AX ainsi:
MOV AX, @DATA
MOV DS, AX
{ CS (Code Segment) pointe sur le segment contenant le code du programme.
{ ES (Extra Segment) permet de pointer sur un segment supplementaire deni
par le programmeur. Il se charge par l'intermediaire de AX comme DS.
{ SS (Stack Segment) segment contenant la pile.
2.4.3 Le registre indicateur (Flag Register)
Il est utilise pour stocker des etats particulier du microprocesseur en cours de
fonctionnement (le signe de la derniere operation eectuee, l'existence d'une retenue
en cours de propagation, .. .) Quelques bits seulement de ce registre ont une signi-
cation et sont nommes: CF est l'indicateur de retenue (Carry Flag), OF l'indicateur
de debordement (Over ow Flag), ...
O D I T S Z A P C
Overflow Carry
Direction Parity
Interrupt Auxiliary carry
Trap Sign Zero
Ce registre est contrôle par des instructions particulieres, par exemple:
CLC : mise
a z
ero de CF (Clear C).
STI : mise
a 1 de IF ( Set I)
CLD : mise
a 0 de DF
STD : mise
a 1 de DF
7
Ce registre est modie par les instructions arithmetiques et logiques, ainsi que
par les comparaisons.
2.5 Les interruptions
APPLICATION Les actions sur l’infrastructure
matérielle se font par interruptions.
DOS Le DOS exploite les primitives

du BIOS
BIOS
infrastructure matérielle
Une interruption est generee par l'instruction INT suivie du numero d'un ser-
vice. Le principal service du DOS est 21h. Le BIOS dispose de nombreux services
correspondant aux dispositifs qu'il commande ( ecran, contrôleur de disque).
A chaque interruption est associe un ensemble de fonctions du systeme. Le nu-
mero de la fonction se charge toujours dans AH. Selon la fonction, d'autres registres
peuvent aussi être utilises. Exemples de fonctions :
{ Pour desactiver un programme et revenir au DOS : Fonction 4Ch
{ Attente d'un caractere : Fonction 1 du DOS (service 21h). le caractere recu
est dans AL.
{ Achage d'un octet : Fonction 2 du service 21h. le caractere a acher est
dans DL.
{ Positionner le curseur : Fonction 2 du BIOS ( service 10h); le numero de ligne
est place dans DH, le numero de colonne dans DL et le numero de page d'ecran
dans BH.
8
3 Analyse de programmes en assembleur
3.1 Exemples
3.1.1 Fichier: ADDITION.ASM
; Ce programme realise l'addition de deux nombres rentr
es au
; clavier chiffre apres chiffre et affiche le r
esultat.
; Les chiffres lus sont des caracteres. Il faut restituer
; la valeur decimale de chacun d'eux, stocker les nombres obtenus
; sur 4 octets maximum et additionner les octets correspondants
; de chaque nombre en propageant la retenue.
DOSSEG
.MODEL small
.STACK 100h
.DATA
num1 DB 4 dup(0) ; premier nombre
num2 DB 4 dup(0) ; second nombre
num3 DB 4 dup(0) ; r
esultat
chaine1 DB 'TAPEZ LE PREMIER NOMBRE : ','$'
chaine2 DB 13,10, 'TAPEZ LE SECOND NOMBRE : ','$'
chaine3 DB 13,10,' RESULTAT : ','$'
.CODE
;*********************************************************************
; Procedure de lecture de nombres cod
es sur 4 octets. *
; Les operandes sont lues dans l'ordre des poids d
ecroissants. *
; La pile permet de les utiliser selon les poids croissants. *
;*********************************************************************
lect PROC
mov ah,01 ; code fonction de lecture d'un caractere.
mov cx,0 ; mise
a 0 du compteur.
boucle_lecture:
int 21h ; lecture
cmp al,0Dh ; a-t-on lu un retour-charriot ?
je rangement ; OUI => on range les valeurs lues.
push ax ; sinon on empile le caractere dans un mot.
inc cx ; on compte un ASCII de plus
jmp boucle_lecture
rangement: ; rangement du nombre lu.
add di,3 ; on se place en fin de zone de stockage.
boucle_rangement:
pop ax ; d
epiler un code ASCII
sub al,30h ; conversion en valeur d
ecimale
mov bl,al ; stockage dans BL
dec cx ; on d
ecr
emente CX pour comper l'octet d
epil
e
cmp cx,0 ; si CX =0 ...
je suite ; ... c'est fini
pop ax ; sinon on d
epile l'ASCII suivant.
sub al,30h ; conversion en valeur d
ecimale
push cx ; sauvegarde de CX (compteur d'ASCII lus )
mov cl,4 ; on compte 4 d
ecalages pour le ranger ...
shl ax,cl ; ... dans la partie droite de AL.
pop cx ; restitution de CX
9
or bl,al ; on accole le chiffre au pr
ec
edent
suite:
mov [di],bl ; sauvegarde en m
emoire par position d
ecroisante
cmp cx,0
je fin_lect
dec di ; on pointe sur la position pr
ec
edente
loop boucle_rangement ; jusqu'
a ce que CX soit nul
fin_lect:
ret
lect ENDP
DebutProgramme:
mov ax,@data
mov ds,ax
mov ah,9 ;la fonction de lecture n 9 exige
; des cha^
nes termin
ees par un '$'
mov dx, OFFSET chaine1 ; affichage du 1 message
int 21h
mov di,OFFSET num1
call lect
mov ah,9
int 21h
mov di,OFFSET num2
call lect
mov ah,9
int 21h
call Addition
mov ah,4Ch ; retour au DOS et ...
int 21h ; ... FIN DU PROGRAMME
Addition PROC
mov si,OFFSET num1 ; SI et DI pointent sur les 2 op
erandes
mov di,OFFSET num2
add si,4 ; on se place en queue des op
erandes
add di,4
mov cx,4
mov bx,OFFSET num3 ; BX pointe sur le r
esultat
add bx,4 ; et on se place sur l'octet de poids faible
clc ; mise
a z
ero du bit de retenue (CF)
boucle_addition:
dec si
dec di
dec bx
mov al,[di]
adc al,[si] ; addition avec prise en compte de la retenue
daa ; ajustement en codage BCD
mov [bx],al ; stockage de l'octet du r
esultat
loop boucle_addition
mov di,OFFSET num3 ; on pointe sur le r
esultat pour l'afficher
mov cx,4 ; le r
esultat est sur 4 octets
mov ah,02 ; code fonction d'
ecriture d'un caract
ere
affich: ; boucle d'affichage
10
mov dl,[di]
mov bl,dl
push cx ; sauvegarde du compteur d'octets affich
es
mov cl,4
shr dl,cl ; le demi-octet de gauche (poids forts) est
; decale
a droite
add dl,30h ; transformation du chiffre en son code ASCII
int 21h ; impression sur l'
ecran
mov dl,bl ; on r
ecup
ere l'octet initial
and dl,0Fh ; on masque le demi-octet de gauche d
ej
a trait
e
add dl,30h ; transformation num
erique -> ASCII
int 21h ; affichage
ecran
inc di
pop cx ; r
ecup
eration du nombre de tours de boucle
loop affich
FIN:
ret
Addition ENDP
END DebutProgramme
3.1.2 Fichier: DIAGONALE.ASM

; Trac
e d'une diagonale rouge sur fond bleu-clair
a l'
ecran
; en mode graphique
DOSSEG
.MODEL small
.STACK 200h
.DATA
NUM DB 200
.CODE
mov ax,@data
mov ds,ax
mov ah,0
mov al,4 ; mise de l'
ecran au mode graphique 320*200 couleur
int 10h ; appel au BIOS
mov ah,0Bh ; choix d'une palette de couleurs

mov bh,0
mov bl,9 ; fond bleu-clair
int 10h
mov ah,0Bh ; palette de couleurs

mov bh,1
mov bl,0 ; palette n 0 (vert, rouge,jaune)
int 10h
mov cx,200 ; 200 pixels (largeur de l'
ecran)
a tracer
diag:
push cx
mov ah,0Ch ; affichage d'un point (pixel)
mov al,2 ; couleur du point (rouge = 2
eme de la palette)
push ax ; sauvegardes de registres
mov dx,cx
push dx
11
mov ax,dx ; DX doit contenir le num
ero de la ligne du pixel
mov dh,32 ; on multiplie par 32/20 ...
mul dh ; ... pour tenir compte du caract
ere rectangulaire ...
mov dx,0 ; ... de l'espace d'affichage
mov bx,20
div bx
mov cx,ax ; CX doit contenir le num
ero de la colonne du pixel
pop dx
pop ax
int 10h ; appel au BIOS pour allumer le point
a l'
ecran
pop cx ; r
ecup
eration du nombre de points restant a tracer
loop diag
attente:
mov ah,1
int 21h
fin:
mov ah,0 ; Retour au mode TEXTE
mov al,3
int 10h
mov ah,4Ch ; retour au DOS
int 21h
END
3.1.3 PROGRAMMES MULTI{MODULES

;****************************************************************
;* EXEMPLE DE PROGRAMMATION MULTI-MODULES *
;****************************************************************
;* PROGRAMME PRINCIPAL *
;* Compilation : TASM princip *
;* TASM routine *
;* Edition des liens : TLINK princip + routine *
;****************************************************************
DOSSEG
.MODEL small
.STACK 200h
.DATA
chaine1 DB 'VIVE ',0
chaine2 DB 'LA LICENCE INFO !',0dh,0ah,'$',0
GLOBAL ChaineFinale : BYTE;
ChaineFinale DB 50 DUP5?
.CODE
GLOBAL ConcateneChaine : PROC
mov ax, @data

mov ds,ax
mov ax,OFFSET chaine1
mov bx, OFFSET chaine2
call ConcateneChaine ; Assemble les 2 chaines en une seule
; L'adresse des chaines composantes
; doit ^
etre passee par AX et BX.
mov ah,09h ; Fonction d'
ecriture d'une cha^
ne
; terminee par le caract
ere '$'
mov dx,OFFSET ChaineFinale
12
int 21h ; Affiche la chaine
a l'
ecran.
mov ah,4Ch
int 21h ; Retour au DOS.
END
;****************************************************************
;* Module dans un fichier s
epare *
;* ConcateneChaine *
;* Concat
ene deux cha^nes et range le *
;* r
esultat dans la variable globale *
;* ChaineFinale. *
;* ENTREES : DS:AX = pointeur vers la premiere cha^
ne *
;* DS:BX = pointeur vers la seconde cha^ne *
;* SORTIES : n
eant *
;* REGISTRES MODIFIES : AL, SI, DI, ES *
;****************************************************************
DOSSEG
.MODEL small
.DATA
GLOBAL ChaineFinale : BYTE
.CODE
GLOBAL ConcateneChaine
ConcateneChaine PROC
cld ; on fixe le sens de parcours
; des chaines
mov di,SEG ChaineFinale
mov es,di
mov di,OFFSET ChaineFinale ; ES:DI pointe sur le r
esultat
mov si,ax ; Adresse de la chaine 1 dans SI

boucle1 :
lodsb ; On prend 1 caractere dans chaine1
and al,al ; Est-ce un z
ero ?
jz traitechaine ; OUI -> parcours termin
e
stosb ; NON -> on copie le caractere dans
; ChaineFinale ...
jmp boucle1 ; ... et on recommence
traitechaine :
mov si,bx ; Adresse de la 2eme chaine dans SI
boucle2:
lodsb ; On prend un caractere de la chaine2
stosb ; On le copie dans ChaineFinale, z
ero
; compris.
and al,al ;
etait-ce le z
ero ?
jnz boucle2 ; NON -> on recommence
ret ; OUI -> c'est fini
; On retourne au programme appelant.
ConcateneChaine ENDP
END
13
3.2 Structure d'une ligne
[Label:] [Instruction|Directive] [Op
erandes] [; commentaire]
3.2.1 Les labels

Les labels sont formes de chires, de lettres et des caracteres : , @, $ et?
Il faut s'obliger a ecrire des programmes lisibles. Comparez:
CMP AL, 'O' avec CMP AL, OUI
JZ ET1 avec JZ ReponsePositive
3.2.2 Principales directives

{ ENDdelimite la n du texte source
{ END etiquette permet de lancer le programme a cette etiquette. Par defaut,
la premiere instruction executable est celle qui suit la directive .CODE
{ .MODEL, .DATA, .STACK, .CODE sont des directives qui seront explicitees
par la suite.
3.2.3 Instructions
Elles sont constituees de mnemoniques de 3 a 5 lettres comme: MOV, MOVSB,
MOVSW par exemple.
Les operandes sont des registres, des variables declarees dans la partie delimitee
par .DATA, des constantes.
On trouve des instructions a operande implicite: MUL BH
3.2.4 Expressions et operateurs
{ LENGTH renvoie le nombre d'elements d'une donnee declaree avec l'operateur
de duplication DUP (tableaux).
{ SIZE renvoie le nombre d'octets d'un element de donnees (cha^ne de carac-
teres).
{ WIDTH renvoie la taille d'un enregistrement ou d'un champ d'enregistrement
exprimee en nombre de bits.
{ HIGH et LOW permettent de selectionner les parties hautes et basses d'une
constante, d'une expression ou d'une adresse.
{ OFFSET, SEG permettent de separer les composantes d'une adresse.
{ PTR est utilise pour contrôler le transtypage d'une expression.
{ TYPE renvoit un nombre indiquant la taille ou le type d'un symbole.
{ MOD est l'operateur modulo
{ SHL, SHR sont des operateurs de decalage.
{ EQ, GE, GT, LE, LT, NE sont des operateurs de comparaison.
{ NOT, OR, AND, XOR sont les operateurs logiques classiques.
{ LARGE denit la partie deplacement d'une expression comme etant sur 32
bits, tandis que SMALL la denit sur 16 bits.
14
{ SHORT force une expression a être un pointeur de type proche.
{ on a de plus les operateurs arithmetiques: +, -, *, /
Exemples :
MOV val, 1234h
MOV AH, HIGH val
MOV AL, LOW val
mov AX, OFFSET var+((4*2)-3)
MOV BYTE PTR [BX],1
MOV AL, SIZE var
4 Les directives
Il y a 2 familles de directives selon le mode de segmentation (standard ou sim-
plie)
{ standard : pour de programmes de grande taille, developpes completement en
assembleur.( ca a existe : Systemes, CAO, SGBD)
{ simplie : Pour de petits modules independants, eventuellement associes a un
programme en langage evolue.
C'est ce dernier mode que nous utiliserons et que nous allons exposer.
{ DOSSEG : ordonne les segments selon la convention MICROSOFT et permet
la compatibilite avec MASM. Il faut l'utiliser quand on interface ASM avec
ADA ALSYS.
{ .MODEL selectionne le modele de memoire. Il y a 6 modeles dierents :
{ TINY : Code et donnees sont sur un même segment de 64Ko. Les sauts
se font au sein de ce segment.
{ SMALL : code et donnees sont sur un segment chacun.
{ MEDIUM : Le code est sur plusieurs segments. les donnees sur un seul
segment.
{ COMPACT : Le code est sur 64Ko, les donnees sur plusieurs segments.
{ LARGE: Code et donnees sont multisegment, mais une structure de
donnee ( tableau par exemple) doit tenir sur un seul segment.
{ HUGE : Id. mais les structures de donnees sont multi-segment.
Nous travaillerons toujours en modele SMALL.
{ .STACK permet de dimensionner la pile. Cette pile est indispensable, et sauf cas
exceptionnel, elle doit toujours être presente et susamment dimensionnee.
{ .DATA permet de denir les donnees simples ou complexes de l'application.
{ .CODE precede les instructions du programme qui se termine par la directive
.END
15
5 Declaration des donnees
5.1 Donnees initialisees
5.1.1 Donnees simples
DB (Data Byte) denit une donnee sur 1 octet, DW (Data Word) sur 1 mot ( 2
octets), DD (Data Double) un double mot, DQ pour 8 octets, DT pour 10 octets.
V1 DB 'A'
V2 DW 380
V3 DD 4BFCh
5.1.2 Tableaux
TAB DW 0,1,2,3,4
MATRICE DD 0,1,2
DD 3,4,5
DD 6,7,8
T DW 256 DUP(0)
ChaineVide DB 10 DUP(' ')
Le prexe DUP permet de dupliquer n fois l'argument entre parentheses.

5.1.3 Cha^nes
CH1 DB 'A', 'B', 'C', 'D'
CH2 DB 'ABCD'
CH3 DB 'Bonjour',13,10
CH4 DB 'Salut', 0Dh,0Ah,$
Les declarations de CH1 et CH2 ont le même resultat. les valeurs 0Dh=13, 0Ah=10
correspondent aux codes ASCII commandant le saut a la ligne ( Carriage return et
Line Feed). Le $ est utilise pour acher a l'ecran la cha^ne a l'aide de la fonction 9
du DOS :
MOV AH,9
MOV DX, OFFSET CH4
INT 21h
REM :
BUF DW 10 DUP(0)
PTB DW BUF
initialise la variable PTB utilisee ici comme pointeur avec la valeur de BUF, qui est
l'adresse de BUF(0).
MOV AX, OFFSET BUF
MOV AX,[PTB]
Ces deux instructions chargent dans AX l'adresse de BUF.
16
5.2 Donnees non initialisees
La reservation de place en memoire se fait tres simplement sur le modele suivant:
BUF DB 10 DUP(?) r eserve 10 octets pour BUF.
5.3 Directive EQU
Elle permet d'aecter une valeur a un label ( qui ne pourra plus être modiee)
reponse EQU 'O'
LongueurMax EQU 1000
Il faut s'obliger a utiliser le plus possible des labels lorsqu'on programme en as-
sembleur. Il est en eet plus facile de lire par exemple: CMP AL, REPONSE que:
CMP AL, 'O'
Des constantes peuvent ainsi en denir d'autres :
zone EQU 10
debut EQU (zone +2)
fin EQU (zone + 50
Cette directive est aussi tres utile pour declarer des messages a acher:
message EQU 'Donnez votre r
eponse (O/N) : '
Enn, cette directive permet de rendre plus lisible des manipulations par adres-
sage indirect:
.DATA
temp EQU [BP+2]
i EQU [BP+4]
j EQU [BP+6]
k EQU [BP+8]
.CODE
Somme3 PROC
PUSH BP
MOV BP,SP ; BP pointe sur le sommet de pile
SUB SP,2 ; SP pointe sur le mot pr
ec
edant
MOV AX,i
ADD AX,j
MOV temp,AX
MOV AX,k
ADD AX,temp
MOV SP,BP
POP BP
RET
Somme3 ENDP
Ce programme est certainement plus lisible que s'il presentait explicitement les
manipulations de la pile.
La directive = est identique a EQU, a ceci pres qu'elle permet de modier la
valeur d'initialisation en cours d'execution.
17
5.3.1 Calcul de la longueur d'un vecteur ou d'une cha^ne
Il est dicile et maladroit de compter le nombre de valeurs pour prexer l'opera-
teur DUP. Il est preferable d'utiliser un label. Tout identicateur, en informatique,
represente en general l'adresse de la valeur qu'il represente. Ainsi, un label corres-
pond a la valeur de l'adresse au sein du segment de la position qu'il occupe dans
le programme. Le même rôle est tenu par la variable $, qui represente l'adresse
courante dans le segment en cours d'assemblage. Dans l'exemple qui suit, $ repere
l'adresse du dernier mot de TABLE :
table DW 50 DUP(0)
FinTable Label Word
Longueur DW (FinTable-Table)
ou encore
table DW 50 DUP(0)
longueur EQU ($-table)
6 Transferts de donnees et modes d'adressage

6.1 Transferts
Ils se font par l'instruction MOV destination, source
La destination peut être representee par des registres ou des variables; la source
par des registres, des variables ou des constantes. Des expressions entre crochets
indiquent que l'operande correspond a la valeur contenue a l'adresse calculee dans
les crochets.
Soit Var une cha^ne implantee a l'adresse 100 et qui vaut: 'ABCDEF'. Les 3
instructions suivantes sont equivalentes :
MOV AL, [var+4]
MOV AL, [104]
MOV AL, [100+4]
Toutes les 3 chargent le caractere 'E' dans AL. (le caractere d'adresse 0 est 'A').
Mais,
MOV AL, var
MOV AL, [VAR]
ont le même eet, car le nom d'une variable repere l'adresse de sa valeur.
6.2 Adressage direct
Une position memoire est reperee par le nom d'une variable ou une combinaison
nom-constante.
Ce mode n'est pas tres souple, car l'adresse evaluee reste xe.
MOV AX,[100+12]
MOV BX,DS:[50]
18
6.3 Adressage indirect
On utilise a cet eet un registre contenant l'adresse de base, a laquelle on ajoute
un deplacement. Reprenons l'exemple precedent :
MOV BX, OFFSET var + 4
MOV AL, [BX]
Une fois encore, nous chargeons 'E' dans AL.

D AL
BX
E
104 E
F
Ce mode d'adressage, contrairement au precedent, permet de balayer dynami-

quement une liste d'adresses :
MOV BX, OFFSET chaine
boucle:
MOV AL, [BX]
CMP AL,0 ; le caract
ere est-il nul ?
JZ fin ; si OUI, c'est termin
e
INC BX ; on passe
a l'adresse suivante
JMP boucle ; si NON, on poursuit le balayage
fin:
DEC BX ; on revient sur le dernier caract
ere ...
MOV AL, [BX] ; ... qu'on charge dans AL
cette fois-ci, nous balayons une variable chaine, terminee par le code ASCII nul, et
en sortant, nous placons le dernier caractere non nul dans AL.
Pour l'adressage indirect, on peut utiliser exclusivement les registres : BX, BP,
SI et DI.
Il existe 16 facons d'utiliser le mode indirect. La forme generale est :
[registre de base +/- registre index +/- deplacement]
[depl] [BX+DI] [SI + depl] [BP + DI + depl]
[BX] [BP + SI] [DI + depl]
[SI] [BP + DI] [BX + SI + depl]
[DI] [BP + depl] [BX + DI + depl]
[BX+SI] [BX+depl] [BP + SI + depl]
Les expressions utilisant BX pointent sur la RAM (c-a-d sur le segment courant de
celle-ci, correspondant generalement a la valeur de DS), celles utilisant BP pointent
sur la pile.
ici BX et [BX] ont des signications dierentes; BX correspond au contenu du
registre (qui peut être une adresse), alors que [BX] est la valeur dont l'adresse est
dans BX.
Les expressions qui suivent sont equivalentes :
.DATA
chaine DB 'ABCDEF'
.CODE
MOV AX,@DATA
MOV DS,AX
19
.....
MOV SI,OFFSET chaine+4
MOV AL,[SI]
.......
MOV SI,4
MOV AL, [chaine + SI]
.......
MOV BX, OFFSET chaine
MOV AL,[BX + 4]
.......
MOV SI,4
MOV BX,OFFSET chaine
MOV AL,[BX + SI]
7 Manipulation des donnees

7.1 Implicite
MOV AL, BL ou MOV AL, 1 transf erent necessairement des octets, car le registre
destinataire est un registre 8 bits. De même:
MOV AX, 1 transf ere un mot de valeur 1 dans le registre 16 bits AX. Considerons :
var DB ?
...
MOV [var], 'A'
Cette aectation est sans ambigute non plus, car le nombre d'octets que permet
d'adresser [var] a ete specie a la declaration par la directive DB.
Il susbsite cependant des ambigutes , comme par exemple:
MOV [BX],1 : on ne peut decider ici si l'on range la valeur 1 dans un octet
ou dans un mot. Une telle instruction generera un message d'erreur de la part du
compilateur.
7.2 mecanismes de conversion
On leve les ambigutes a l'aide des operateurs BYTE PTR et WORD PTR
MOV BYTE PTR [BX], 1

MOV WORD PTR [BX], 1
Ces operateurs permettent de traiter une variable selon un format dierent de celui
correspondant a sa declaration :
var DD ?
......
MOV WORD PTR [var], AX
MOV WORD PTR [var+2], DX
La variable var declaree comme double-mot est traitee ici comme si l'on avait en
fait deux mots independants.
7.3 Donnees signees et non signees
C'est au programmeur de faire la distinction, car il ne s'agit que d'une convention
et d'un codage particulier. Ainsi, 0FFFFh peut-il representer aussi bien 65 535 que
-1 !
20
La representation binaire des nombres entiers contenus dans un registre fournit
un nombre continu de valeurs : on passe de 65 535 a 0 en ajoutant 1, en represen-
tation non signee. Et, en representation signee, (dans laquelle le bit de poids fort
designe le signe , positif s'il est nul), 0FFFEh corespond a la valeur decimale -2.
Certaines instructions assembleur ne fonctionne pas de la même maniere selon que
le bit de poids fort est considere comme un bit de signe ou un poids numerique.
7.3.1 Conversion d'un octet non signe en un mot
On force l'octet de poids fort a 0 :
MOV CL, 12
MOV AL, CL
MOV AH, 0 ; le mot de valeur 12 est dans AX
7.3.2 Conversion d'un octet signe en un mot

On utilise l'instruction CBW (Convert Byte to Word). L'octet signe doit-être
obligatoirement dans AL :
MOV DH, -1
MOV AL, DH
CBW
MOV DX, AX ; le mot de valeur -1 est dans DX
7.3.3 Conversion d,un mot signe en double-mot

On utilise l'instruction: CWD, le mot etant au depart dans AX :
MOV AX, -1
CWD ; les poids forts sont dans DX
7.4 Manipulations de la pile

Elles se font par les instructions PUSH (empiler) et POP (depiler) lorsqu'il s'agit
de modier la structure de la pile. Il est possible egalement, pour lire ou modier
des valeurs dans la pile, d'utiliser l'adressage indirect avec : [BP + deplacement].
7.5 Entrees/Sorties
Elles sont eectuees par IN et OUT. Les adresses sont dans DX. AL et AX sont
les seuls registres autorises pour les operandes :
MOV DX, 100h MOV DX, 100h
IN AL, DX MOV AL, 0Fh
OUT DX, AL
8 Instructions arithmetiques
8.1 ADD et SUB
Les additions et soustractions se font sur 8 ou 16 bits selon les operandes. Les
operations 32 bits ou plus doivent être ecrites par le programmeur en eectuant le
transfert des retenues avec ADC (ADd with Cary) et SBB (SuB with Borrow).
ADD AX, BX
21
ADC DX, CX ; r
ealise DX:AX := DX:AX + CX:BX
de même:
SUB AX,BX
SBB DX,CX ; r
ealise DX:AX := DX:AX - CX:BX
8.2 Incrementation/decrementation
Par INC et DEC.
ADD AX, 1 occupe 3 octets; INC AX n'en occupe qu'un et est plus rapide. De
même, il vaut mieux ecrire deux fois de suite INC AX que ADD AX, 2.
8.3 Multiplication/division
La multiplication est une instruction dans laquelle l'accumulateur est un ope-
rande implicite.
MUL var : si var est une variable 8 bits, AL est operande implicite, et les 16 bits
du resultat sont ranges dans AX.
si var est une variable 16 bits, AX est operande implicite et les 32 bits du resultat
sont ranges dans le couple DX:AX
MOV AL, 25 ; AL operande implicite
MOV DH, 40 ; AX r
esultat implicite
MUL DH ; AX contient 1000
.......
MOV AX, 1000
MUL AX ; calcul de AX au carr
e. r
esultat dans DX:AX
Dans le cas de valeurs signees, il faut utiliser IMUL :

MOV AL, -2
MOV AH, 10
IMUL AH ; on a -20 dans AX
8.3.1 Division d'un mot par un octet

Le mot est dans AX, l'octet dans un registre ou en memoire. Le quotient est
stocke dans AL et le reste dans AH :
MOV AX, 51
MOV DL, 10
DIV DL ; le reste 1 est dans AH, le quotient 5 dans AL
8.3.2 Division d'un double-mot par un mot

DX sert de registre d'extension; le double-mot est dans DX:AX, le mot dans un
registre ou en memoire. Le quotient est range dans AX et le reste dans DX :
MOV AX, 2
MOV DX, 1 ; 1002h est dans DX:AX
MOV BX, 10h ; 10h dans BX
DIV BX ; r
esultat 100h dans AX, reste 2 dans DX
22
Pour les donnees signees, il faut utiliser IDIV:
MOV AX, -545
CWD ; place -545 dans DX:AX
IDIV 100 ; quotient -5 dans AX, reste -45 dans DX
8.4 Negation
On utilise l'instruction NEG registre g
en
eral ou m
emoire
9 Operations logiques
L'instruction AND permet de masquer des valeurs :
MOV AL, var
AND AL, 0Fh ; ne retient que les 4 bits de poids faible de AL
l'instruction OR peut être utilisee pour forcer des bits a 1:

MOV AL, var
OR AL, 0Fh ; force les bits de poids faible
a 1
l'instruction XOR permet d'inverser les bits d'un registre ou de les mettre plus
rapidement a zero que ne le fait un MOV :
XOR AX, AX ; remise
a 0 repide de AX
.....
MOV BL, 1011 0001b
NOT BL ; BL = 0100 1110
XOR BL, 0FFh ; BL reprend sa valeur initiale
10 Decalages et rotations
10.1 Logiques
SHL (Shift Left) eectue un decalage a gauche des bits. Le bit de poids fort se
retrouve dans CF et un 0 est introduit en bit de poids faible.
SHL AL, 1 Aucun autre op erande que 1 n'est accepte ! si l'on veut faire plu-
sieurs decalages successifs, il faut ecrire autant de fois SHL registre,1
Une facon plus elegante d'operer consiste a utiliser CL dans son rôle de compteur:
MOV CL,4
SHL AX,CL ; effectue 4 d
ecalages de AX
Le decalage a gauche revient a faire une multiplication par 2 d'une valeur non signee.
SHR (Shift Right) opere de facon analogue a droite. Le resultat est la division
par 2 d'une valeur non signee.
23
10.2 Arithmetiques
SAR(Shift Arithmetic Right): le bit de poids fort est recopie. le bit 0 transfere
dans CF. Cette operation, qui preserve le bit de signe, permet de faire une division
par 2 de valeurs signees. La même operation est realisee a gauche par SAL.
ROR(ROtation Right) eectue une permutation vers la droite. le bit de poids
faible se retrouve dans CF. Cette operation permet de recadrer des bits dans un
mot ou un octet. A gauche, l'instruction est ROL.
RCR(Rotation with Carry Right) permet une permutation avec prise en compte
de la retenue, utile par exemple dans le cas de decalages d'operandes etendus sur
plusieurs mots. L'operation symetrique est RCL.
15 0
SHL CF 0
15 0
SAR CF
15 0
ROR CF
15 0
CF
RCR
Toutes ces instructions n'operent que sur un bit a la fois, ou sur le nombre de
positions speciees par CL.
11 Sauts
11.1 Inconditionnels
JMP(jump) est l'equivalent d'un GOTO. Cette instruction permet de sauter a
une adresse representee sur 16 bits, au sein du segment de code donc. L'adresse
de saut est reperee par une etiquette. Dans les cas ou l'on cherche a economiser
du code, on peut utiliser JMP SHORT etiquette qui correspond a un saut de 127
octets. Hors contrainte de ce type, TASM optimise l'adresse selon le cas.
11.2 Conditionnels
Ils s'eectuent apres une comparaison CMP. CMP est identique a SUB, mais ne
produit pas de resultat; il possitionne seulement les ags. Les sauts sont toujours
courts (127 octets), et il faut prendre garde que l'etiquette puisse eectivement
être atteinte.
24
INSTRUCTION Conditions de saut Indicateurs
pour valeurs non signees
JB/JNAE below/ not above or equal CF = 1
JAE/JNB above or equal/not below CF=0
JBE/JNA below or equal CF=1 et ZF=1
JA/JNBE above/not below or equal
JE/JZ equal/zero ZF=1
JNE/JNZ not equal/not zero ZF=0
pour valeurs signees
JL/JNGE less than/not greater than SF=NOT OF
JGE/JNL greater or equal/not less than SF=OF
JLE/JNG less or equal/not greater than ZF=1 ou SF=NOT OF
JG/JNLE greater than/not less or equal ZF=0 ou SF=OF
JP/JPE Parity even (paire) PF=1
JNP/JNPO Parity odd (impaire) PF=0
JS signe SF=1
JNS non signe SF=0
JC retenue CF=1
JNC pas de retenue CF=0
JO over ow OF=1
JNO pas d'over ow OF=0
Exemples :
MOV AH, 1
INT 21h ; lecture d'un octet rang
e dans AL
CMP AL, 'A'
JE suite ; Si l'octet lu est un 'A' on va
a suite, sinon ...
..... ; on poursuit en s
equence
suite:
.....
Dans l'exemple qui suit, on interprete de 2 facons dierentes l'octet de valeur 130.
En representation non signe, il correspond au code ASCII de 'e'. En representation
signee, il vaut -2. Dans les deux cas, le saut n'a lieu que parce que la valeur dans
AL est bien superieure (au sens de chaque convention de signe) a la constante 127
sur laquelle porte la comparaison:
MOV AL,130 MOV AL,130
CMP AL, 127 CMP AL,127
JA LettreAccentuee JG ValeurNegative
... ...
12 Boucles
12.1 Boucle POUR
On utilise l'instruction LOOP qui necessite l'emploi de CX comme compteur. A
chaque tour de boucle, CX est automatiquement decremente. Si, apres decremen-
tation, CX est nul, on sort de la boucle.
ATTENTION : si CX est nul au premier tour, il est decremente. sa valeur devient
65535, et on peut attendre un bon moment la sortie de boucle !
MOV CX, NbDeTours
25
BouclePour:
... ; corps de boucle
LOOP BouclePour
On peut aussi utiliser LOOPE/LOOPZ qui realisent un melange de boucles POUR

et TANT QUE en permettant de sortir quelque soit la valeur de CX si ZF vaut 1.
LOOPE, par exemple, signie : boucler tant que l'egalite reste veriee et que CX
est dierent de 0.
De même LOOPNE/LOOPNZ dans le cas contraire. L'exemple suivant permet
de lire 8 chires au plus, et d'arrêter la lecture a la frappe du RETURN.
.DATA
buf DB 8 DUP(0)
.CODE
MOV CX,8
MOV BX, OFFSET buf
boucle:
MOV AH,1
INT 21h ; lecture
MOV [BX], AL ; rangement de l'octet lu
INC BX
CMP AL, 0Dh ; a t-on lu un RETURN ?
LOOPNE boucle ; si NON, on continue jusqu'
a ce que CX=0
12.2 Boucle TANT QUE

Elles sont realisees a l'aide de sauts conditionnels. Le probleme est que la lon-
gueur occupee par le corps de la boucle ne peut depasser 127 octets. Il faut donc
souvent coupler saut conditionnel et saut inconditionnel, ce qui revient a inverser
logiquement la condition du TANT QUE :
DebutTQ:
...
var DB 1000 DUP(?)
...
JE suite ; Si on a termin
e, on sort de la boucle
JMP DebutTQ ; sinon, on revient au d
ebut du Tant Que.
suite: ...
13 Traitement des cha^nes

Le 8086 dispose d'instructions tres puissantes de traitement de cha^nes.
13.1 deplacements
La famille des instructions LODS transfere un octet ou un mot de la memoire
vers l'accumulateur. LODSB et LODSW modient SI en fonction de l'indicateur de
direction DF.
SI est incremente si DF=0 (CLD)
SI est deecremente si DF=1 (STD)
LODSB transfere un octet de DS:SI vers AL
26
LODSW transfere un mot de DS:SI vers AX
CLD
MOV SI,OFFSET chaine
LODSB SI est incr
ement
e
...
STD
MOV SI, OFFSET cahine + LongueurChaine
LODSW SI est d
ecr
ement
e
La famille STOS eectue le mouvement inverse, de l'accumulateur vers ES:DI.

STOSB transfere le contenu de AL, tandis que STOSW transfere celui de AX. Les
2 programmes suivant ont le même resultat.
CLD STD
MOV DI,0 MOV DI,1
MOV AL,'A' MOV AX,'AB'
STOSB STOSW
MOV AL, 'B'
STOSB
Voici l'exemple de la copie d'un tampon termine par le caractere nul.

MOV AX, @DATA
MOV DS, AX
MOV ES, AX
MOV SI, OFFSET buf1
MOV DI, OFFSET buf2
CLD
boucle:
LODSB ; r
ecup
ere DS:SI dans AL
STOSB ; transfere AL vers ES:DI
CMP AL, 0
JNZ boucle
fin:
...
La famille des instructions MOVS (MOVSB, MOVSW) realise la même chose

que LODS suivi de STOS, a savoir le transfert de DS:SI vers ES:DI sans paser par
AX.
MOV AX,@DATA
MOV DS,AX
MOV ES,AX
MOV SI,0
MOV DI,0
MOVSW ; transfert d'un mot de DS:SI vers ES:DI
...
PREFIXE DE REPETITION : REP permet d'eliminer la construction d'une boucle

pour transferer n octets ou n mots. Il sut au prealable de charger CX avec le
nombre de valeurs a echanger entre les 2 positions memoire.
MOV CX, TailleBuf
CLD
REP MOVSW
27
si CX vaut 0 au depart, l'instruction n'est pas executee ( et c'est heureux !). REP
peut être utilise avec l'ensemble des instructions de traitement de cha^ne, ainsi
qu'avec SCAS et CMPS.
REPE et REPNE sont aussi disponibles avec les signications respectives : re-
peter tant que egalite ou tant que pas egalite.
SI et DI sont modies apres l'acces en memoire, ce qui fait qu'en n d'echange,
on pointe sur une adresse posterieure (si on a fait CLD) au dernier element de
la cha^ne. Si on a tranfere des mots, on pointe sur une adresse posterieure de 2
positions, les adresses etant toujours comptees en octet.
13.2 Analyse de cha^ne
13.2.1 SCAS
eectue un balayage de la memoire pour chercher la presence ou l'absence d'un
octet ou la valeur d'un mot.
SCASB compare la valeur de l'octet dans AL avec celui situe en ES:DI; DI
est modie selon la valeur de DF. Avec SCASW , c'est le contenu de AX qui est
recherche.
Exemple: recherche du caractere 'a' dans un texte termine par l'ASCII nul
.DATA
texte DB 'texte d''essai',0
dim EQU ($-texte)
.CODE
MOV AX, @DATA
MOV DS, AX
MOV ES, AX
MOV DI, OFFSET texte ; DI pointe sur le d
ebut du texte
MOV AL, 'a'
MOV CX, dim ; CX contient le nombre de caracteres
a balayer.
CLD ; balayage dans l'ordre direct.
REPNE SCASB
JE trouve
JMP PasTrouve
trouve :
DEC DI ; on pointe maintenant sur 'a'
13.2.2 CMPS
Permet de comparer directement 2 cha^nes. CMPSB compare l'octet en DS:SI
avec celui en ES:DI et modie SI et DI simultanement selon DF. CMPSW agit de
même au niveau de mots.
MOV SI, OFFSET tab1
MOV AX, SEG tab1
MOV DS, AX
MOV DI, OFFSET tab2

MOV AX, SEG tab2
MOV ES, AX
MOV CX, longueur

CLD
REPE CMPSW
28
JNE different
....
different:
DEC SI
DEC SI
DEC DI
DEC DI ; on pointe sur les 2
el
ements diff
erents.
14 Sous-programmes
14.1 principe
L'appel d'un sous-programme se fait par CALL label de sous-programme. Soit
un programme implante a l'adresse 1000 et une procedure a l'adresse 1100.
1000 MOV AL,1 ---> 1100 SHL AL, 1
1002 MOV BL,3 | 1102 ADD AL,BL
1004 CALL SP ------------ 1104 AND AL,7
1007 MOV AL,2 <------------- 1106 ADD AL,'0'
1009 INT 21h |-----1108 RET
Le sous-programme contient l'instruction RET qui permet de revenir au programme

appelant. Lors du CALL, IP recoit la valeur 1100, adresse de la prochaine instruction
a executer, tandis que l'adresse de retour 1007 est empilee.
Sur le RET, le sommet de pile de valeur 1007 est depile, et son contenu est range
dans IP.
On trouvera dans les listings des exemples de programmes et sous-programmes.
Le sous-programme ou procedure se declare donc :
nomproc PROC
..
..
RET
nomproc ENDP
La directive ENDP(End of Procedure) s'applique toujours a un label associe a la

directive PROC.
Le debut du programme principal correspond a l'etiquette associee a la directive
END qui clôt le texte source a compiler. S'il n'y en a pas, c'est par la premiere
instruction suivant le .CODE que l'execution demarre.
14.2 Passage des parametres
Il existe deux techniques : par les registres ou par la pile.
14.2.1 par registres
Avant l'appel, on charge les registres avec les valeurs des parametres. Ceci, a
condition qu'ils ne soient pas trop nombreux, et qu'ils soient tous scalaires. Si l'on
a aaire a des tableaux ou des structures, il faut manipuler l'adresse des objets.
Avant le retour, la procedure appelee doit a son tour ranger ses resultats dans les
registres.
Ce mecanisme doit être rigoureusement documente dans le programmelui-même,
sous forme de commentaires. On doit savoir quels sont les registres manipules, ce
qu'ils representent en entree, en sortie, et quels sont ceux qui ont ete modies par
le code. ( cf l'exemple ROUTINE.ASM)
29
14.2.2 par la pile
On utilise a cet eet une structure, c'est a dire l'equivalent d'un enregistrement
(RECORD). La syntaxe de declaration en est :
nom STRUC
champ1 type valeur
champ2 type valeur
...
nom ENDS
Avant l'appel, les parametres sont empiles par une succession de PUSH. Lors du CALL,
l'adresse de retour est rangee dans la pile. Elle est composee des deux registres CS
et IP.
On trouve donc dans la pile :
IP <- SP
CS
par4
par3
par2
par1 <- BP
L'acces a la pile se fait a partir de SP. Il vaut mieux ne pas modier la structure
de la pile en cours d'execution du sous-programme, aussi on ne la depile pas. Mais
on accede et on modie les valeurs qu'elle contient en utilisant des indirections avec
BP.
Il faut se souvenir ici que la pile est logee en haut de la memoire et que ses
adresses croissent a l'inverse des adresses de la memoire. L'adresse du sommet est
inferieure a celle de sa base ! Pour la manipuler comme on en a l'habitude et la
\voir" conformement au schema ci-dessus, on a l'habitude d'intervertir les reperes
que sont BP et SP avec la sequence :
PUSH BP pour sauvegarder la valeur du registre
MOV BP,SP BP contient la valeur de SP (adresses basses), ce qui nous permet
par la suite d' ecrire des expressions avec [BP+depl] ...
On doit egalement se souvenir que les adresses sont comptees en octet, alors que
la pile stocke des mots. Les adresses vont donc de 2 en 2.
L'adresse de par1 devient [BP+2], en adressage indirect, celle de par2 devient
[BP+4], etc ...
L'instruction RET depile en n d'execution l'adresse de retour. L'instruction
RET n permet de d epiler, outre l'adresse de retour les n/2 parametres qui la precede.
L'exemple suivant illustre ce qui vient d'être dit:
TOTO PROC NEAR
parametres STRUC
par1 DW ?
par2 DB ?
par3 DB ? ; ces deux parametres tiennent sur le meme mot dans la pile
par4 DW ?
parametres ENDS
params EQU [BP-par1]

sub SP,2 ; on elimine l'adresse de retour de la zone d'adressage
push BP
mov BP,SP
30
...
mov AX, params.par1
mov BL, params.par2
mul BL
...
POP bp
ADD SP,2
RET 6 ; les parametres occupent 3 mots sur la pile
TOTO ENDP
dans cet exemple, les parametres ont ete depiles avant retour. Pour recuperer des
resultats, il convient de sauver leur valeur dans des registres au prealable.
15 Programmes multi-modules
Il est possible de faire de la compilation separee en assembleur. Le principal
probleme qui se pose est le partage des donnees et du code entre plusieurs modules.
Un exemple de realisation, propose en 3.1.3, illustre ce qui suit.
On distingue le probleme du partage des donnees separement de celui du code.
15.1 Partage des donnees
Les donnees, que ce soit en import ou en export, sont declarees avec la directive
GLOBAL et associees a leur type, dans tous les modules ou on les utilise. Cette
declaration regle uniquement le probleme de l'import-export. La declaration de
reservation de place en memoire se fait ensuite dans le module a qui l'on attribue
le rôle de createur de cette donnee.
;Module du programme principal
...
.DATA
GLOBAL var1:WORD, var2:BYTE ; var1 est d
efini pour l'usage d'un autre module
var1 DW ? ; son implantation est d
ecidee ici
.CODE
GLOBAL P1 : NEAR, P2 : FAR ; La proc
edure P1, d
eclaree "proche", n
ecessite
; un d
eplacement au sein du segment
; Pour P2, on a besoin de CS:IP pour acc eder
; a
un autre segment
...
MOV [var1],BX
MOV AL,[var2]
...
CALL P1
CALL P2
END
-------------------------------------
; Module de P1
.DATA
GLOBAL var2:BYTE ; var2 est d
eclar
ee ici et sera utilisee dans
var2 DB ? ; le programme principal
.CODE
GLOBAL P1 ; cette declaration premet l'export de P1
P1 PROC NEAR ; D
eclaration de P1 dans le segment de code courant
...
31
RET
P1 ENDP
END
15.2 partage du code

Le principe est identique :
une procedure importee est declaree GLOBAL. La dimension du pointeur qui per-
mettra de l'atteindre est associee a cette declaration : NEAR si elle est situee dans le
segment de code courant, FAR si elle est implantee dans un autre segment.
A l'export, on rapelle le partage par GLOBAL. Le type du pointeur est associe a
la declaration proprement dite qui se fait avec la directive PROC. Ce type doit être
compatible avec toutes les procedures qui vont l'importer.
Nous n'ecrivons que de petits modules qui tiennent tous dans un même segment.
Par consequent, la declaration sera toujours NEAR.
16 Commandes de TASM
16.1 compilation
la commande de compilation est : TASM [options] NomDeFichier
Si on utilise * comme nom de chiers, tous les chiers d'extension .ASM sont
compiles. L'option /zi permet de prendre en compte les donnees qui seront utilisees
par TURBO-DEBUGEUR.
16.2 edition des liens
On utilise la commande LINK. L'option /v permet l'utulisation de TURBO-
DEBUGEUR. La commande s'applique a l'ensemble des chiers objets (d'extension
.OBJ) qui compose le logiciel. On a deux solutions pour pr esenter ces arguments sur
la ligne de commande
{ LINK /v a+b+c permet de lier les modules-objet contenus dans les chiers
a.obj, b.obj et c.obj (un même chier peut contenir plusieurs modules-objet).
{ LINK /v @f permet de lier les modules-objet contenus dans le chier f. Ce
dernier est un chier de texte qui contient une liste de type : a + b + . . . +
z. On utilise un tel chier en indirection des lors que le nombre de chiers
composant est eleve.
17 Problemes courants
Les erreurs les plus frequemment rencontrees sont :
{ l'oubli de revenir au DOS
{ l'oubli du RET dans une procedure. Le code continue de se derouler.
{ le fait que les operandes soient stockes a l'envers en memoire.
la valeur 4BA7h stockee en memoire correspond a la valeur A74Bh d'une
variable.
{ l'abscence du dimensionnement de la pile.
{ l'eacement de registres vitaux par une procedure.
32
{ des erreurs de sens de sauts conditionnels.
JA, JB, JAE et JBE traitent des donnees non signees.
JG,JL, JGE et JLE traitent des donnees signees.
le E traite l'egalite; ne pas confondre JA et JAE.
Bien dierencier aussi JC et JNC (problemes de logique)
{ boucles : valeur de CX; veiller a ne pas avoir CX nul en debut de boucle.
{ oubli de retour en arriere sur les cha^nes avec REP.
{ indicateur de direction inverse
{ oubli de preparer les segments de cha^ne (ES)
{ operations arithmetiques avec retenue. Penser a eacer CF avec CLC.
{ attention a la dierence entre compte d'octets et compte de mots.
{ confusion valeur/adresse
supposons que la variable var de valeur 1234h soit implantee a l'adresse 1000h.
MOV BX, OFFSET var charge 1000h dans BX
MOV AX, [BX] charge 1234h dans AX
MOV AX, [var] charge aussi 1234h dans AX
MOV [var], 5678h
MOV AX, var charge 5678h dans AX
33
S.I.O. Travaux pratiques page 34 Documentation de travaux pratiques
INSTRUCTIONS DU 8086 Lorsque la taille des arguments n’est pas indiquée, c’est que l’instruction ac-
cepte des arguments sur 8 ou 16 bits, à condition qu’ils soient de la même
taille.
Lorsqu’un des arguments peut être de plusieurs types, ces différents formats
sont regroupés entre accolades. Exemple: {r+m} signifie registre ou mémoire.
Lecture des instructions: Action sur les indicateurs:

Les trois actions possibles d’une instruction sur les indicateurs sont:
Les pages suivantes présentent le jeu d’instructions du 8086. Chaque
• ?: on ne peut rien dire sur l’état de l’indicateur après l’instruction.
instruction a le format suivant:
• *: l’indicateur sera modifié par l’instruction, et cette modification nous
ADC nom de l’instruction renseignera sur le déroulement de l’instruction.
• 0,1: valeur de l’indicateur après l’instruction.
Addition avec retenue: les deux opérandes et la retenue sont additionnés, et
le résultat est placé dans le premier opérande. action Les indicateurs:
Format: Chacun d’eux joue un rôle particulier:
• ADC r,* format de l’appel • O: overflow. Mis à 1 si une opération provoque un dépassement de ca-
• ADC m,{i+r} pacité.
• D: direction. Fixe le sens dans lequel seront effectuées les opérations
de traitement de chaînes de caractères. STD le met à 1, CLD à 0.
O D I T S Z A P C • I: interruption. Mis à 1, il autorise les interruptions. S’il vaut 0, il les
? ? ? * ? * empêche.
• T: trap. Mis à 1, il force le processeur à fonctionner pas à pas.
• S: signe. Prend la valeur du bit de poids fort de l’accumulateur après un
action sur les indicateurs
calcul.
Format des opérandes: • Z: zéro. Mis à 1 si le résultat d’un calcul (i.e. le contenu de l’accumula-
Les opérandes peuvent être des types suivants: teur) vaut 0.
• r: registre (r8 registre 8 bits, r16 registre 16 bits). • A: retenue auxiliaire. Mis à 1 si un calcul en BCD non compacté pro-
• m: mémoire. duit une retenue.
• i: valeur immédiate. • P: parité. Mis à 1 si les 4 bits de poids faible du résultat contiennent un
• label: étiquette. nombre pair de 1.
• segreg: registre de segment (DS,ES,CS,SS). • C: retenue (carry). Mis à 1 si un calcul produit une retenue.
• ptr 16:16: adresse sous la forme segment:déplacement.
La virgule sépare les arguments lorsqu’il y en a deux.

L’étoile ‘*’ remplace r,m ou i.
Instructions du 8086
AAA AAS
Ajustement ASCII après addition: corrige le contenu de AL après une ad- Ajustement ASCII de AL après soustraction: corrige le contenu de AL
dition de deux nombres en BCD non compacté, pour le mettre au format BCD non après une addition de deux nombres exprimés en BCD non compacté, pour le
compacté. mettre au format BCD non compacté.
O D I T S Z A P C O D I T S Z A P C
? ? ? * ? * ? ? ? * ? *
ADC
AAD
Addition avec retenue: les deux opérandes et la retenue sont additionnés, et
Ajustement ASCII avant division: prépare le dividende ou le diviseur pour le résultat est placé dans le premier opérande.
effectuer une division entre deux nombres exprimés en BCD non compacté. Format:
• ADC r,*
O D I T S Z A P C • ADC m,{i+r}
? * * ? * ?
O D I T S Z A P C
* * * * * *
AAM
Ajustement ASCII après multiplication: corrige le contenu de AX pour le ADD

mettre au format BCD non compacté.
Addition: les deux opérandes sont ajoutés et le résultat est placé dans le pre-
O D I T S Z A P C mier opérande.
Format: le même que pour ADC.
? * * ? * ?
O D I T S Z A P C
* * * * * *
AND CLI
ET logique: Un ET logique est appliqué à chaque bit des opérandes, le résultat Mise à zéro de l’indicateur d’interruption.
est placé dans le premier opérande.
Format: CMC
• AND r,*
• AND m,r Inverse l’indicateur de retenue.
O D I T S Z A P C CMP
0 * * ? * 0
Compare les deux opérandes en soustrayant le deuxième opérande au pre-
mier. Celui-ci n’est pas modifié, mais les indicateurs peuvent être modifiés
Format:
CALL • CMP {r+m},*
• CMP m,{i+r}
Appel de procédure.
Les indicateurs ne sont pas modifiés. O D I T S Z A P C
Format: * * * * * *
• CALL label
• CALL m16
• CALL r16 CMPS,CMPSB,CMPSW
Compare des chaînes de caractères: compare le contenu de DS:SI à celui de

CBW ES:SI, arme les indicateurs en fonction du résultat de la comparaison, puis in-
crémente (si CLD a été exécuté) ou décrémente (si STD a été exécuté) SI et
Conversion d’octet en mot: transforme l’octet signé présent dans AL en un DI. Ces instructions peuvent être préfixées par REP et ses variantes.
mot dans AX en recopiant dans tous les bits de AH le bit de poids fort de AL. Format:
• CMPSB (comparaison d’octets) et CMPSW (comparaison de mots) n’ont
pas de paramètres.
CLC • Pour CMPS: m,m
Mise à zéro de l’indicateur de retenue.

O D I T S Z A P C
CLD * * * * * *
Mise à zéro de l’indicateur de direction (manipulation de chaînes).
DAA DIV
Ajustement décimal de AL après addition: s’utilise après ADD pour reca- Division non signée: effectue la division du contenu de l’accumulateur par la
drer le résultat de l’addition de deux nombres BCD au format BCD compact valeur de l’argument.Si l’argument est sur 8 bits, AL est le dividende, le quo-
(un octet contient deux chiffres décimaux, chacun codé sur quatre bits). tient est placé dans AL et le reste dans AH, si l’argument est sur 16 bits, AX
est le dividende, le quotient est placé dans AX et le reste dans DX.
O D I T S Z A P C Format:
? * * * * * • DIV {m+r}
O D I T S Z A P C
? ? ? ? ? ?
DAS
Ajustement décimal de AL après soustraction: voir DAA.
O D I T S Z A P C HLT
? * * * * * Suspend l’exécution du programme et place le processeur dans l’état balte. Le
processeur ne repartira que par reset ou prise en compte d’une interruption.-
Dans ce dernier cas, on retrouve les contenus de CS et IP.
DEC
Décrémente l’argument de 1. IDIV

Format:
• DEC {r+m}
Division signée: voir DIV.
* * * * * * ? ? ? ? ? ?
IMUL INT,INTO
Multiplication signée: multiplie le contenu de l’accumulateur par celui de Appel d’interruption: INTO est un appel conditionnel qui ne sera effectif
l’opérande.Si celui-ci est sur 8 bits, AL est multiplié et le résultat est placé que si l’indicateur O vaut 1.
dans AX, s’il est sur 16 bits, AX est multiplié et le résultat se trouve dans Les indicateurs T et S sont mis à zéro.
DX:AX (Poids forts dans DX). Format:
Format: • INT[O] i8
• IMUL {m+r}
IRET
O D I T S Z A P C
* ? ? ? ? * Retour d’interruption.
Dépile le registre des indicateurs.
IN Jcondition
Lecture de données sur un périphérique: transfère un octet ou un mot de- Saut si la condition est vérifiée.
puis le périphérique repéré par le deuxième opérande dans l’accumulateur. Les conditions valides sont composées des lettres suivantes:
Format: • A: above (au dessus)
• IN {AL,AX},i8 • B: below (en dessous)
• IN {AL,AX},DX • C: carry (retenue)
• E: equal (égal, pair)
O D I T S Z A P C • G: greater (plus grand)
* ? ? ? ? * • L: lesser (plus petit)
• N: not (non)
• O: overflow (dépassement de capacité, impair)
• P: parity (parité)
• S: signed (signé)
INC • Z: zero
Les conditions acceptées sont les suivantes:
Incrémente l’argument de un (voir DEC). JA,JAE,JB,JBE,JC,JE,JG,JGE,JL,JLE,JNA,JNAE,JNB,JNBE,JNC,JNE,JNG
,JNGE,JNL,JNLE,JO,JP,JPE,JS,JZ,JNO,JNP,JPO,JNS,JNZ.
O D I T S Z A P C Il existe encore une autre condition : JCXZ qui effectue le branchement si CX
* * * * * vaut 0.
L et G sont utilisés pour comparer des entiers signés, A et B pour des valeurs
non signées.
Les indicateurs ne sont pas modifiés.
Format: LOCK
• Jcondition r128.r128 est une étiquette ou une valeur correspondant à un dé-
placement dans le segment de code courant d’au plus 128 octets en amont Valide le préfixe de signal de verrouillage.
ou 127 octets en aval.Il est possible d’augmenter la longueur du saut en Les indicateurs ne sont pas modifiés.
plaçant la directive JUMPS (annulée par NOJUMPS) dans le texte source
avant l’instruction de saut. LODS,LODSB,LODSW
JMP Charge un caractère dans l’accumulateur: charge dans AL (donnée sur 8
bits) ou AX (donnée sur 16 bits) la valeur pointée par DS:SI.
Saut inconditionnel. LODS peut être préfixée par REP, ce qui a peu d’intérêt.
Les indicateurs ne sont pas modifiés. Les indicateurs ne sont pas modifiés.
Format: Format:
• JMP r128 • LODSB et LODSW n’ont pas d’arguments.
• JMP r • LODS m
• JMP m
• JMP ptr 16:16 LOOP, LOOPcondition
LAHF Boucle: décrémente CX; si le résultat est différent de zéro, opère un branche-
ment à l’adresse spécifiée en argument (voir Jcondition pour les formats).
Charge les indicateurs dans AH. LOOPcondition effectue le branchement tant que la condition est vérifiée et
Les indicateurs ne sont pas modifiés. que CX est différent de zéro. Les seules conditions valides sont LOOPE (ou
LOOPZ), vrai quand l’indicateur Z est à un, et sa négation LOOPNE
LEA (ou LOOPNZ).
Charge une valeur de déplacement d’adresse: calcul l’adresse (offset) du
second opérande et la place dans le premier. MOV
Copie de données: recopie dans le premier opérande la valeur représentée par
LDS,LES le deuxième opérande.
Charge un pointeur: Le premier mot (OFFSET) adressé par le deuxième Format:
opérande est placé dans le premier opérande, le second (SEGMENT) est placé • MOV r,*
dans DS (LDS) ou ES (LES). • MOV m,{r+i}
Les indicateurs ne sont pas modifiés. • MOV segreg,{r+m}
• MOV {r+m},segreg
MOVS,MOVSB,MOVSW NOT
Copie de données entre chaînes: copie l’octet(MOVSB) ou le mot (MO- Négation logique: l’opérande est remplacé par son complément à un.
VSW) repéré par DS:SI dans ES:DI puis incrémente (CLD) ou décrémente Les indicateurs ne sont pas modifiés.
(STD) SI et DI. Format:
Cette instruction peut être préfixée par REP. • NOT {r+m}
Format: OR
• MOVSB et MOVSW n’ont pas de paramètres.
• MOVS: m,m Ou logique: effectue un ou logique sur chaque bit des opérandes et place le
résultat dans le premier opérande.
MUL Format:
• OR {r+m},{imm+r}
Multiplication non signée: voir IMUL. • OR r,m
* ? ? ? ? * 0 * * ? * 0
NEG OUT
Négation par complément à deux: l’opérande est remplacé par son complé- Ecriture sur un périphérique: transfère une donnée depuis le premier opé-
ment à deux. L’indicateur de retenue est mis à un, sauf si l’opérande vaut 0, rande vers le périphérique repéré par le deuxième opérande.
auquel cas l’indicateur de retenue est mis à 0. Les indicateurs ne sont pas modifiés.
Format: Format:
• NEG {r+m} • OUT {imm+DX},{AL+AX}
O D I T S Z A P C
* * * * * * POP
Dépiler un mot: prend la valeur située au sommet de la pile et la place dans

NOP l’opérande, puis incrémente SP de 2.
Pas d’opération. Format:
Les indicateurs ne sont pas modifiés. • POP {r+m}
• POP DS, ES ou SS
POPF REP,REPE,REPZ,REPNE,REPNZ
Dépile le registre d’indicateurs: prend la valeur située en sommet de pile et Répétition d’opérations de manipulations de chaînes.
la place dans le registre d’indicateurs. Ces instructions sont des préfixes permettant la répétition des instructions de
Tous les indicateurs sont susceptibles d’être modifiés. chaînes.
REP décrémente CX puis répète l’instruction si CX est différent de zéro.
PUSH REPE (=REPZ) et REPNE (=REPNZ) ne préfixent que les instructions des fa-
milles SCAS et CMPS; REPE (répéter tant que égal) arrête l’itération si l’in-
Empile l’opérande: décrémente SP de 2, puis place la valeur en sommet de dicateur Z vaut 0 (détection d’une inégalité), REPNE (répéter tant que non
pile. égal) est la condition opposée.
Les indicateurs ne sont pas modifiés. L’indicateur Z peut être modifié.
Format:
• PUSH {r+m}
PUSHF RET
Empile le registre des indicateurs, qui ne sont pas modifiés. Retour d’une procédure: IP et CS (retour long) sont dépilés.
Si RET est suivi d’une valeur sur 16 bits, elle représente le nombre d’octets à
RCL,RCR,ROL,ROR enlever de la pile avant d’effectuer le retour de procédure (paramètres d’entrée
de la procédure).
Rotation d’un octet ou d’un mot d’une ou CL positions. Les indicateurs ne sont pas modifiés.
RCL: rotation vers la gauche en tenant compte de la retenue. A chaque étape
de la rotation, la retenue est placée dans le bit de poids faible du premier opé-
rande, le bit de poids fort de cet opérande est placé dans la retenue.
ROL: rotation vers la gauche sans tenir compte de la retenue. A chaque étape
de la rotation, la retenue prend la valeur du bit de poids fort du premier opé- SAHF
rande avant la rotation.
RCR et ROR sont les rotations vers la droite correspondantes. Sauvegarde AH dans le registre des indicateurs (seulement les indicateurs
C et O peuvent être modifiés. S,Z,A,P,C).
Format: AH doit contenir SZ*A*P*C dans cet ordre.
• {RCL+RCR+ROL+ROR} {r+m},{1+CL}
SAL,SAR,SHL,SHR SCAS,SCASB,SCASW
Instructions de décalage. Comparaison de [chaînes de] caractères.

SAL (=SHL) décale l’opérande vers la gauche de 1 ou CL bits. A chaque étape Compare le contenu de ES:DI à celui de l’accumulateur, modifie les indica-
du décalage, le bit de poids fort du premier opérande est placé dans l’indicateurs en conséquence, puis incrémente (si CLD a été exécuté) ou décrémente
teur de retenue, le bit de poids faible est mis à 0. (STD) DI.
SHR est le décalage vers la droite symétrique de SAL. S’utilise généralement préfixée par REPE ou REPNE.
SAR ne modifie pas le bit de poids fort (décalage vers la droite des nombres Format: voir MOVS.
signés).
Format: voir RCL,RCR O D I T S Z A P C
* * * * * *
O D I T S Z A P C
* * * ? * * STC
Met à un l’indicateur de retenue.
STD
Met à un l’indicateur de direction.

SBB
STI
Soustraction avec retenue: le deuxième opérande et la retenue éventuelle
sont soustraits du premier opérande et le résultat est placé dans le premier opé- Met à un l’indicateur d’autorisation d’interruptions.
rande.
Format: voir ADC STOS,STOSB,STOSW
O D I T S Z A P C Range le contenu de l’accumulateur dans une chaîne: copie le contenu de
* * * * * * l’accumulateur dans ES:DI, puis incrémente (CLD) ou décrémente (STD) DI.
STOSB copie le contenu de AL, STOSW celui de AX. STOS utilise AL ou
AX, selon la taille de l’opérande.
Format:
• STOSB et STOSW n’ont pas d’arguments.
• Pour STOS: m.
SUB XLAT,XLATB
Soustraction: soustrait le deuxième opérande au premier et place le résultat Table de correspondance: avant d’appeler XLAT, AL doit contenir un indice
dans le premier. de tableau, BX l’adresse de base du tableau. Au retour, AL contient la valeur
Format: voir ADC. de la case correspondante du tableau.
O D I T S Z A P C
Format:
* * * * * * • XLAT m8
• XLATB
XOR
TEST
Ou exclusif.
Comparaison: même action que AND, mais le résultat n’est pas gardé. Format: voir OR.
Format: voir AND.
A O D I T S Z A P C
O D I T S Z P C
0 * * ? * 0 0 * * ? * 0
WAIT
Arrêt du processeur jusqu’à ce que la broche BUSY# soit inactive. Cette bro-
che est gérée par le coprocesseur.
XCHG
Echange les contenus des deux opérandes.

Format:
• XCHG {r+m},r
• XCHG r,{r+m}
S.I.O. Travaux pratiques Documentation de travaux pratiques
PRINCIPALES INTERRUPTIONS DU DOS/BIOS

Interruption 10h, fonction 00h Interruption 10h, fonction 02h

Fixer le mode vidéo. Positionnement du curseur.
Entrée: AH=0 Entrée: AH=2
AL=mode vidéo. BH=Page écran.
0 40*25 caractères noir et blanc. (carte couleur). DH=Ligne de l’écran.
1 40*25 caractères couleur. (carte couleur). DL=Colonne de l’écran.
2 80*25 caractères noir et blanc (carte couleur)
3 80*25 caractères couleur (carte couleur) Sortie: Aucune.
4 320*200 points, 4 couleurs.
5 320*200 points, 4couleurs
6 640*200 points, 4 couleurs.
7 Carte monochrome.
8 160*200, 16 couleurs. (PC junior)
9 320*200, 4 couleurs. (PC junior) Interruption 10h, fonction 03h
0Ah 640*200, 4couleurs (PC junior)
0Dh 320*200, 16 couleurs. Lecture de la position du curseur.
0Eh 640*200, 16 couleurs. Entrée: AH=3
0Fh 640,350, monochrome. BH=Numéro de la page écran.
10h 640*350, 16 couleurs.
11h 640*480, 2 couleurs. Sortie: DH=Ligne du curseur.
12h 640*480, 16 couleurs. DL=Colonne du curseur.
13h 640*480, 256 couleurs. CH=Ligne de départ du curseur.
CL=Ligne de fin du curseur.
Sortie: Aucune.

Définir l’apparence du curseur. Sélection de la page d’écran.
CH=Ligne de départ du curseur (0-13). AL=Numéro de la page écran.
CL=Ligne de fin du curseur (0-7).
Sortie: Aucune.
Sortie: Aucune.
Principales interruptions du DOS/BIOS


Faire défiler des lignes de texte vers le haut. Ecriture d’un caractère et de son attribut.
AL= Nombre de lignes du décalage. BH=Page écran.
CH=Ligne écran du coin supérieur gauche. CX=Nombre d’écritures successives du caractère.
CL=Colonne écran du coin supérieur gauche. AL=Code ASCII du caractère.
DH=Ligne écran du coin inférieur droit. BL=Attribut.
DL=Colonne écran du coin inférieur droit.
BH=Couleur des lignes vides. Sortie: Aucune.
Sortie: Aucune.
Interruption 10h, fonction 0Ah

Ecriture d’un caractère.
Interruption 10h, fonction 07h Entrée: AH=0Ah
BH=Page écran.
Faire défiler des lignes de texte vers le bas. CX=Nombre d’écritures successives du caractère.
Entrée: AH=7 AL=Code ASCII du caractère.
Mêmes paramètres que pour l’interruption 10h fonction 6.
Sortie: Aucune.
Sortie: Aucune.
Remarque: Ne modifie pas la position du curseur.
Interruption 10h, fonction 08h Interruption 10h, fonction 0Bh, service 0

Lecture d’un caractère et de son attribut. Sélection des couleurs de cadre et de fond.
Entrée: AH=8 Entrée: AH=0Bh
BH=Numéro de la page écran. BH=0
BL=Couleur de cadre et de fond.
Sortie: AL=Code ASCII du caractère.
AH=Couleur. Sortie: Aucune.

Interruption 10h, fonction 0Bh, service 01h Interruption 10h, fonction 0Fh
Sélection de la palette de couleurs. Lecture du mode vidéo.
Entrée: AH=0Bh Entrée: AH=0Fh
BH=1
BL=Numéro de la palette. Sortie: AL=Mode vidéo (voir fonction 0 de l’interruption 10h).
AH=Nombre de caractères par ligne.
Sortie: Aucune. BH=Numéro de la page écran.
Interruption 10h, fonction 0Ch

Allumer un point.
Entrée: AH=0Ch
DX=Ligne. Interruption 10h, fonction 13h
CX=Colonne.
AL=Couleur.
Sortie d’une chaîne de caractères.
BH=Page écran. Entrée: AH=13h
AL=Mode de sortie(0-3):
Sortie: Aucune. 0=Attribut dans BL, conserver position du curseur.
1=Attribut dans BL, bouger curseur.
Remarque: Si le bit 7 de AL vaut 1, un OU exclusif est appliqué entre la nouvelle 2=Attribut dans buffer, conserver position du curseur.
et l’ancienne couleur. 3=Attribut dans buffer, bouger curseur.
BL=Attribut des caractères.
CX=Longueur de la chaîne.
DH=Ligne.
Interruption 10h, fonction 0Dh DL=Colonne.
BH=Page écran.
Lire un point. ES:BP=Adresse du buffer.
Entrée: AH=0Dh
DX=Ligne. Sortie: Aucune.
CX=Colonne.
BH=Page écran. Remarque: Les codes de commande sont interprétés comme tels.
Sortie: AL=Couleur.

Interruption 11h Interruption 21h, fonction 01h

Déterminer la configuration. Entrée de caractères avec sortie.
Entrée: Aucune. Entrée: AH=1
Sortie: AX contient le codage de la configuration: Sortie: AL=Caractère lu.

Pour XT:
Bit 0=1 s’il y a un lecteur de disquettes. Remarque: Si un code étendu est entré, AL contient 0, il faut rappeler
Bit 2 et 3=Mémoire RAM sur la carte mère: l’interruption pour connaître le caractère entré.
00=16 Ko
01=32 Ko
02=48 Ko
03=64 Ko
Bit 4 et 5=Mode vidéo: Interruption 21h, fonction 02h
01=40*25 couleur.
10=80*25 couleur. Sortie d’un caractère.
11=80*25 monochrome. Entrée: AH=2
Bit 6 et 7=Nombre de lecteurs de disquettes (00=1 lecteur). DL=Code ASCII du caractère.
Bit 8=0 si DMA présent.
Bit 9-11=Nombre de RS232 présentes. Sortie: Aucune.
Bit 12=1 si joystick connecté.
Bit 14-15=Nombre d’imprimantes. Remarque: Interprète les codes de commande.
Pour AT:
Bit 1=1 si coprocesseur présent.
Les bits 2,3,8,12 et 13 sont inutilisés.Les autres gardent la même
signification. Interruption 21h, fonction 06h
Entrée/sortie directe de caractère.
Entrée: AH=6
Interruption 12h DL=Si FFh alors lire un caractère, sinon l’écrire.
Déterminer la taille mémoire.
Sortie: Si DL=FFh alors:
Entrée: Aucune. ZF=1 pas de caractère à lire.
ZF=0 le caractère est dans AL.
Sortie: AX=Taille mémoire en Ko. Si DL=FFh, pas de sortie.

Interruption 21h, fonction 07h Interruption 21h, fonction 0Ah

Entrée de caractère sans sortie. Entrée d’une chaîne de caractères.
Entrée: AH=7 Entrée: AH=0Ah
DS:DX=Adresse du buffer.
Sortie: AL=Caractère lu.
Sortie: Aucune.
Remarque: Permet la saisie des codes étendus, mais pas de CTRL-C.
Remarque: Permet la saisie des codes étendus et CTRL-C.

Entrée de caractère sans sortie. Lire la date.
Entrée: AH=8 Entrée: AH=2Ah
Sortie: AL=Caractère lu. Sortie: AL=Jour de la semaine (dimanche=0).

CX=Année (1980=0).
Remarque: Permet la saisie des codes étendus, et de CTRL-C. DH=Mois.
DL=Jour.
Interruption 21h, fonction 09h Interruption 21h, fonction 2Bh

Sortie d’une chaîne de caractères. Fixer la date.
Entrée: AH=9 Entrée: AH=2Bh
DS:DX=Adresse de la chaîne. CX=Année(1980=0).
DH=Mois.
Sortie: Aucune. DL=Jour.
Remarque: La chaîne doit être terminée par un $. Sortie: AL=FFh, date erronée.

Interruption 21h, fonction 2Ch Interruption 21h, fonction 39h

Lire l’heure. Créer un sous-répertoire.
Entrée: AH=2Ch Entrée: AH=39h
DS:DX=Adresse du nom du sous-répertoire à créer (chaîne ASCII
Sortie: CH=Heure. terminée par 0-ASCIIZ).
CL=Minutes.
DH=Secondes. Sortie: CF=0 création réussie.
DL=Centièmes de seconde. CF=1
AX=3 Chemin non trouvé.
AX=5 Accès refusé.
Interruption 21h, fonction 2Dh

Fixer l’heure.
Entrée: AH=2Dh Interruption 21h, fonction 3Ah
CX et DX au même format que pour l’interruption ci-dessus.
Supprimer sous-répertoire.
Sortie: AL=FFh si heure erronée. Entrée: AH=3Ah
DS:DX=Adresse du nom du sous-répertoire(ASCIIZ).
Interruption 21h, fonction 30h Sortie: CF=0 Suppression effectuée.

CF=1 Mêmes codes d’erreur que ci-dessus.
Déterminer le numéro de version du DOS.
Entrée: AH=30h
Sortie: AL=Version.
AH=Sous-version. Interruption 21h, fonction 3Bh
Changer de répertoire.
Interruption 21h, fonction 31h Entrée: AH=3Bh
DS:DX=Adresse du nom du sous-répertoire(ASCIIZ).
Terminer le programme mais laisser résident.
Entrée: AH=31h Sortie: CF=0 changement réussi.
AL=Code de fin. CF=1, alors AX=3 (chemin non trouvé).
DX=Nombre de paragraphes à réserver (1 paragraphe=16 octets).
Sortie: Aucune.

Interruption 21h, fonction 3Ch Interruption 21h, fonction 3Eh

Créer fichier. Fermer fichier.
Entrée: AH=3Ch Entrée: AH=3Eh
CX=Attribut du fichier: BX=Handle du fichier.
Bit 0=1 Lecture seulement.
Bit 1=1 Fichier caché. Sortie: CF=0 tout s’est bien passé.
Bit 2=1 Fichier système. CF=1 alors AX=6 (handle interdit ou fichier non ouvert).
DS:DX=Adresse du nom du fichier(ASCIIZ).
Sortie: CF=0 création réussie; AX=Handle du fichier. Interruption 21h, fonction 3Fh
CF=1 problème:
AX=3 Chemin non trouvé. Lire fichier.
AX=4 Trop de fichiers ouverts. Entrée: AH=3Fh
AX=5 Accès refusé. BX=Handle du fichier (Handle du clavier=0).
CX=Nombre d’octets à lire.
DS:DX=Adresse du buffer.
Interruption 21h, fonction 3Dh Sortie: CF=0 tout va bien, AX=nombre d’octets lus.
CF=1
Ouvrir fichier. AX=5 accès interdit.
Entrée: AH=3Dh AX=6 handle non autorisé ou fichier non ouvert.
AL=Mode d’accès.Principalement:
Bits 0-2:
000=Lecture seulement. Interruption 21h, fonction 40h
001=Ecriture seulement.
010=Lecture/écriture. Ecrire dans un fichier.
DS:DX=Adresse du nom du fichier. Entrée: AH=40h
BX=Handle du fichier (Handle de l’écran=1).
Sortie: CF=0 ouverture réussie; AX=Handle du fichier. CX=Nombre d’octets à écrire.
CF=1 problème. DS:DX=Adresse du buffer.
AX=2 fichier non trouvé.
AX=3 chemin non trouvé. Sortie: CF=0 tout s’est bien passé, AX=nombre d’octets écrits.
AX=4 trop de fichiers ouverts. CF=1
AX=5 accès refusé. AX=5 accès refusé.
AX=6 handle non autorisé ou fichier non ouvert.

Interruption 21h, fonction 41h Interruption 21h, fonction 43h, sous-fonction 0

Détruire un fichier. Lire attribut de fichier.
Entrée: AH=41h Entrée: AH=43h
DS:DX=Adresse du nom du fichier (ASCIIZ). AL=0
DS:DX=Adresse du nom du fichier.
Sortie: CF=0 fichier supprimé.
CF=1 erreur: Sortie: CF=0 alors CX=Attribut du fichier:
AX=2 fichier non trouvé. Bit 0=1 Lecture seulement.
AX=5 accès refusé. Bit 1=1 Fichier caché.
Bit 2=1 Fichier système.
Bit 5=1 Modifié depuis le dernier archivage.
CF=1 erreur:
AX=1 Code de fonction inconnu.
AX=2 Fichier non trouvé.
AX=3 Chemin non trouvé.
Interruption 21h, fonction 42h
Déplacer le pointeur de fichier.
Entrée: AH=42h
AL=code de la distance: Interruption 21h, fonction 43h, sous-fonction 1
0=Par rapport au début du fichier.
1=Par rapport à la position actuelle du pointeur.
Fixer attribut de fichier.
2=Par rapport à la fin du fichier. Entrée: AH=43h
BX=Handle. AL=1
CX=Mot de poids faible de la distance. CX=Attribut du fichier (voir ci-dessus, de plus les bit 3 et 4 doivent
DX=Mot de poids fort de la distance. être mis à 0).
DS:DX=Adresse du nom du fichier.
Sortie: CF=0 tout s’est bien passé:
DX:AX=Nouvelle position du pointeur de fichier. Sortie: CF=0 tout s’est bien passé.
(par rapport au début du fichier) CF=1 erreur:
CF=1 erreur: AX=1 code de fonction inconnu.
AX=1 distance incorrecte. AX=2 fichier non trouvé.
AX=6 handle non autorisé ou fichier non ouvert. AX=3 chemin non trouvé.


Déterminer répertoire courant. Modifier la taille d’une zone mémoire.
Entrée: AH=47h Entrée: AH=4Ah
DL=Désignation du périphérique. BX=Nouvelle taille de la zone en paragraphes.
DS:SI=Adresse du buffer (prévoir 64 octets au maximum). ES:00=Adresse de la zone mémoire.
Sortie: CF=0 tout s’est bien passé, DS:SI contient la spécification du chemin. Sortie: CF=0 tout s’est bien passé.
CF=1 erreur, AX=15 (périphérique inconnu). CF=1 erreur:
AX=7 bloc de contrôle de la mémoire détruit.
AX=8 pas assez de mémoire.
BX=Nombre de paragraphes encore disponibles.
Réserver mémoire RAM.
Entrée: AH=48h Interruption 21h, fonction 4Ch
BX=Nombre de paragraphes.
Terminer un programme.
Sortie: CF=0 réservation réussie, AX:0=adresse de la zone. Entrée: AH=4Ch
CF=1 alors: AL=Code de fin.
AX=7 bloc de contrôle de la mémoire détruit.
AX=8 pas assez de mémoire. Sortie: Aucune.
BX=Nombre de paragraphes encore disponibles.
Interruption 21h, fonction 4Dh

Déterminer code de fin.
Libérer mémoire RAM. Entrée: AH=4Dh
Entrée: AH=49h
ES:00=Adresse de la zone à libérer (la taille est connue du DOS). Sortie: AH=0 fin normale.
AH=1 arrêt par CONTROL-C ou BREAK.
Sortie: CF=0 Mémoire libérée. AH=2 arrêt par erreur d’accès à un périphérique.
CF=1 erreur: AH=3 arrêt par appel à l’interruption 21h,fonction 31h, ou à
AX=7 bloc de contrôle de la mémoire détruit. l’interruption 27h.
AX=9 cette zone n’avait pas été allouée par la fonction 48h. AL=Code de fin.

Interruption 21h, fonction 4Eh Interruption 21h, fonction 62h

Rechercher première entrée du répertoire. Déterminer adresse de PSP du programme en cours.
Entrée: AH=4Eh Entrée: AH=62h
CX=Attribut du fichier.
DS:DX=Adresse du nom du fichier (peut contenir des jokers). Sortie: BX:0=Adresse du PSP.
Sortie: CF=0 tout s’est bien passé, la DTA a été mise à jour.
CF=1 erreur:
AX=2 chemin non trouvé.
AX=18 pas de fichier correspondant au schéma.
Interruption 21h, fonction 4Fh

Rechercher prochaine entrée du répertoire.
Entrée: AH=4Fh
Sortie: CF=0 tout s’est bien passé, la DTA a été mise à jour.
CF=1 erreur AX=18 (pas de fichier correspondant au schéma).
Interruption 21h, fonction 5Ah

Créer fichier temporaire.
Entrée: AH=5Ah
CX=Attribut du fichier.
DS:DX=Adresse du nom du répertoire.
Sortie: CF=0 Tout s’est bien passé, alors:

AX=Handle.
CX=Atribut du fichier.
DS:DX=Adresse du nom du fichier complet.
CF=1 erreur:
AX=3 chemin non trouvé.
AX=5 Accès refusé.
Remarque: Le fichier n’est pas détruit à la fin du programme.

Polyasm

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Polyasm

Hochgeladen von

Copyright:

Verfügbare Formate

ASSEMBLEUR 8086

Accumulateur Registre Registre

Principe d’une architecture de type PC

2345 s'ecrit : 2 103 + 3 102 + 4 101 + 5 100

poids forts, soit 1 + 4 + 8 = 1310

{ BX (B pour base), qui se decompose en BH et BL, sert entre autre a pointer

DOS Le DOS exploite les primitives

3.1.2 Fichier: DIAGONALE.ASM

mov ah,0Bh ; choix d'une palette de couleurs

mov ah,0Bh ; palette de couleurs

3.1.3 PROGRAMMES MULTI{MODULES

mov ax, @data

mov si,ax ; Adresse de la chaine 1 dans SI

3.2.1 Les labels

3.2.2 Principales directives

Le pre xe DUP permet de dupliquer n fois l'argument entre parentheses.

Ces deux instructions chargent dans AX l'adresse de BUF.

6 Transferts de donnees et modes d'adressage

Une fois encore, nous chargeons 'E' dans AL.

Ce mode d'adressage, contrairement au precedent, permet de balayer dynami-

7 Manipulation des donnees

MOV BYTE PTR [BX], 1

7.3.2 Conversion d'un octet signe en un mot

7.3.3 Conversion d,un mot signe en double-mot

7.4 Manipulations de la pile

Dans le cas de valeurs signees, il faut utiliser IMUL :

8.3.1 Division d'un mot par un octet

8.3.2 Division d'un double-mot par un mot

l'instruction OR peut ^etre utilisee pour forcer des bits a 1:

On peut aussi utiliser LOOPE/LOOPZ qui realisent un melange de boucles POUR

12.2 Boucle TANT QUE

13 Traitement des cha^nes

La famille STOS e ectue le mouvement inverse, de l'accumulateur vers ES:DI.

Voici l'exemple de la copie d'un tampon termine par le caractere nul.

La famille des instructions MOVS (MOVSB, MOVSW) realise la m^eme chose

PREFIXE DE REPETITION : REP permet d'eliminer la construction d'une boucle

MOV DI, OFFSET tab2

MOV CX, longueur

Le sous-programme contient l'instruction RET qui permet de revenir au programme

La directive ENDP(End of Procedure) s'applique toujours a un label associe a la

params EQU [BP-par1]

15.2 partage du code

Lecture des instructions: Action sur les indicateurs:

La virgule sépare les arguments lorsqu’il y en a deux.

Ajustement ASCII après multiplication: corrige le contenu de AX pour le ADD

Compare des chaînes de caractères: compare le contenu de DS:SI à celui de

Mise à zéro de l’indicateur de retenue.

Ajustement décimal de AL après soustraction: voir DAA.

Décrémente l’argument de 1. IDIV

Dépiler un mot: prend la valeur située au sommet de la pile et la place dans

Instructions de décalage. Comparaison de [chaînes de] caractères.

Met à un l’indicateur de retenue.

Met à un l’indicateur de direction.

Echange les contenus des deux opérandes.

PRINCIPALES INTERRUPTIONS DU DOS/BIOS

Interruption 10h, fonction 00h Interruption 10h, fonction 02h

Interruption 10h, fonction 01h Interruption 10h, fonction 05h

Principales interruptions du DOS/BIOS

Interruption 10h, fonction 06h Interruption 10h, fonction 09h

Interruption 10h, fonction 0Ah

Interruption 10h, fonction 08h Interruption 10h, fonction 0Bh, service 0

Principales interruptions du DOS/BIOS

Interruption 10h, fonction 0Ch

Principales interruptions du DOS/BIOS

2345 s'ecrit : 2 103 + 3 102 + 4 101 + 5 100

{ BX (B pour base), qui se decompose en BH et BL, sert entre autre a pointer

Le prexe DUP permet de dupliquer n fois l'argument entre parentheses.

6 Transferts de donnees et modes d'adressage

Ce mode d'adressage, contrairement au precedent, permet de balayer dynami-

7 Manipulation des donnees

7.3.2 Conversion d'un octet signe en un mot

7.3.3 Conversion d,un mot signe en double-mot

Dans le cas de valeurs signees, il faut utiliser IMUL :

l'instruction OR peut ^etre utilisee pour forcer des bits a 1:

On peut aussi utiliser LOOPE/LOOPZ qui realisent un melange de boucles POUR

13 Traitement des cha^nes

La famille STOS eectue le mouvement inverse, de l'accumulateur vers ES:DI.

Voici l'exemple de la copie d'un tampon termine par le caractere nul.

La famille des instructions MOVS (MOVSB, MOVSW) realise la m^eme chose

PREFIXE DE REPETITION : REP permet d'eliminer la construction d'une boucle

La directive ENDP(End of Procedure) s'applique toujours a un label associe a la