Structure d'un programme

Assembleur

114
 Programme assembleur

Comme tout programme, un programme écrit en assembleur

(programme source) comprend des définitions de données et
des instructions, qui s'écrivent chacune sur une ligne de texte.

115
NomData SEGMENT
;Espace de réservation des constantes et des variables.
NomData ENDS
NomCode SEGMENT

ASSUME CS : NomCode, DS: NomData

DebutProg:
MOV AX,NomData
MOV DS,AX ;Initialisation de l'adresse de segment de données

; Emplacement des instructions du programme

NomCode ENDS
END
116 DebutProg
 Déclaration des constantes

Pour déclarer une constante on utilise le mot clé EQU (Equate)

NomConst EQU Exp

Exemple:

X EQU 7 ; assigner la valeur 50 au nom VAL

Y EQU 2*X+1 ; assigner une expression calculer à VAL

117
 Déclaration des constantes "prog16.asm"
Data SEGMENT
X EQU 7
Y EQU 2*X+1
Data ENDS

Code SEGMENT
ASSUME CS:Code, DS:Data
PROG:
MOV AX,Data
MOV DS,AX

MOV AX,X
MOV BX,Y

Code ENDS
118
END PROG
 Déclaration des variables
Pour déclarer une variable on peu utiliser l'un des mots clés:

DB: Define Byte qui réserve un espace mémoire d'un octet.

[0, 255] nombres non signés et [-128, 127] nombres signés .

DW: Define Word qui réserve un espace mémoire de deux

octets. [0, 65535] nombres non signés et [-32768, 32767]
nombres signés .

119
 Déclaration des variables

Nomvar DB Val
Nomvar DW Val

Exemple:
a DB 10 ; Déclare la variable a sur un octet et l'initialise à 10.
b DW 15 ; Déclare b sur deux octets et l'initialise à 15.
c DB ? ; Déclare une variable c sans l'initialisée.

120
 Variables et constantes "prog17.asm"
Data SEGMENT
Cte EQU 5
Ecrire le programme assembleur de X DB 0F0h
Y DW 0A000h
S DW ?
l'algorithme ci-dessous avec: Data ENDS
Code SEGMENT
X (8 bits) et Y(16 bits) ASSUME CS:Code,DS:Data
PROG:
MOV AX,Data
Cte=5 MOV DS,AX

X0F0h MOV AX,Cte

MUL X
Y0A000h ADD AX,Y
MOV S,AX
SCte*A+B
Code ENDS
121 END PROG
 Déclaration des tableaux

T1 DB 10,15,33,9 : Réserve un tableau de quatre cases chacune sur un

octet avec des valeurs consécutives.
T2 DW 3000,100,65000 : Réserve un tableau de trois cases chacune sur
deux octets.
Msg DB 'Bonjour' : Réserve un tableau de sept cases chacune sur un
octet et contient le code ASCII de chaque lettre.
T3 DW 100 DUP (5) : DUPLICATE réserve un tableau de cent cases
(deux octets) toutes initialisées à la valeur 5.
T4 DB 10 DUP (?) : Réserve un tableau de dix cases (octet) sans
122 initialisation.
 Accès aux éléments d'un tableau
Pour accéder aux éléments d'un tableau on peu utiliser l'une des méthodes
suivantes:
Accès à travers les indices des éléments du tableau T[i]. Dans ce cas les
indices sont stockées dans SI ou DI.
Accès à travers l'offset de chaque élément.

Pour la deuxième méthode, pour accéder à un élément d'un tableau, son

adresse (offset) doit être calculée.
Pour cela on peu récupérer l'offset d'une variable ou des éléments d'un
tableau avec le mot clé offset.
MOV AX, offset T ; met dans AX l'adresse du premier octet de T
123
 Accès aux éléments d'un tableau "prog18.asm"
Data SEGMENT
T1 DB 1, 2, 3
@T1+2≡BX+2 03h
Data ENDS
Code SEGMENT @T1+1≡BX+1 02h
ASSUME CS:Code, DS:Data @T1+0≡BX+0 01h
PROG: Adresses Valeurs
MOV AX,Data
MOV DS,AX
MOV AL, T1 ;charger dans AL un octet a partir de l'adresse @T1+0. AL=1
MOV BX, offset T1 ;BX contient l'adresse du premier octet du T1. BX=@T1
MOV DL, T1[1] ;charger dans DL un octet a partir de l'adresse @T1+1. DL=2
MOV AH, [BX+2] ;charger dans AH un octet a partir de l'adresse @T1+2. AH=3

MOV AX, [BX+0] ;charger dans AX deux octets a partir de l'adresse @T1+0. AH=02 et AL=01
;AX=0201h
MOV DX, [BX+1] ;charger dans DX deux octets a partir de l'adresse @T1+1.DH=03 et DL=02
;DX=0302h
Code ENDS T1[i] ≡ T1+i ≡ [offset T1+i] ≡ valeur à partir de
124 ème case
END PROG la i
 Accès aux éléments d'un tableau "prog19.asm"
Data SEGMENT
@T2+5≡BX+5 FFh
T2 DW 0BBAAH, 0DDCCH, 0FFEEH
Data ENDS @T2+4≡BX+4 EEh

Code SEGMENT @T2+3≡BX+3 DDh

ASSUME CS:Code, DS:Data @T2+2≡BX+2 CCh
PROG: @T2+1≡BX+1 BBh
MOV AX,Data @T2+0≡BX+0 AAh
MOV DS,AX Adresses Valeurs
MOV BX, offset T2 ; charger l'adresse de T2 dans BX. Soit BX=@T2
MOV AX, T2 ; charger dans AX deux octets a partir de l'adresse @T2. AX=0BBAAh
MOV CX, T2[2] ; charger dans CX deux octets a partir de l'adresse @T2+2. CX=0DDCCh
MOV DX, [BX+4] ; charger dans DX deux octets a partir de l'adresse @T2+4. DX=0FFEEh

MOV AX, [BX+1] ; charger dans DX deux octets a partir de l'adresse @T2+1. AX=0CCBBh
MOV DX, T2[3] ; charger dans DX deux octets a partir de l'adresse @T2+3. DX=0EEDDh

Code ENDS
125 PROG
END
 Exercice "prog20.asm" Data SEGMENT
ecart EQU 3
T DB DUP 10 (0)
Data ENDS
Code SEGMENT
Ecrire un programme assembleur ASSUME CS:Code,DS:Data
PROG:
qui initialise un tableau T avec 10 MOV AX,Data
MOV DS,AX
nombres (0, 3, 6, ... , 27) .
XOR AX,AX
Penser à utiliser un compteur SI ou MOV CX,10
MOV SI,0
DI comme indice pour parcourir le boucle:
MOV T[SI],AL
ADD AL, ecart
tableau T ( T[SI]) INC SI
LOOP boucle
Code ENDS
126
END PROG
 Entrées/Sorties
Pour faire des entrées/sorties (essentiellement avec l’écran et le
clavier), on passe par des interruptions (des sous-programmes
préexistants dans la machine) du BIOS, la plus importante est
l’interruption 21h.

L’appel se fait via l’instruction INT 21h.

Le registre AH contient le numéro de la fonction qu’on veut

utiliser.
127
 Saisie et affichage d'un caractère
Saisie d'un caractère:
• Entrée : AH = 1 (Numéro de la fonction Dos à exécuter)
• Interruption: 21H (appelée via l’instruction Int 21h)
• Sortie: AL= Code ASCII du caractère saisi.
Affichage d'un caractère:
• Entrée : AH = 2
• DL = Code ASCII du caractère à afficher.
• Interruption: 21H
128
 Saisie et affichage d'un caractère "prog21.asm"
Exemple: Lire un caractère au clavier et l'afficher.
code SEGMENT
ASSUME CS: code
prog:
MOV AH, 1
INT 21h ;AL contient le code ASCII du caractère saisie

MOV DL,AL ;Mettre dans DL le code ASCII du caractère à afficher

MOV AH,2
INT 21H
code ENDS
end prog

129
 Saisie et affichage d'un caractère "prog22.asm"
Data SEGMENT
a db ?
Ecrire un programme Data ENDS
Code SEGMENT
assembleur qui sépare le caractère ASSUME CS:Code,DS:Data
PROG:
lu au clavier et celui afficher par MOV AX,Data
MOV DS,AX
un tiret '-'. MOV AH, 1
int 21h
Exemple : MOV a,AL
MOV DL,'-'
• Le premier S est celui saisie MOV AH,2
INT 21H
• Afficher un tiret MOV DL,a
MOV AH,2
• Puis le caractère lu S INT 21H
code ENDS
130 end PROG
 Saisie et affichage d'un caractère "prog23.asm"
Data SEGMENT
a db ?
Ecrire un programme assembleur qui Data ENDS
Code SEGMENT
ASSUME CS:Code,DS:Data
sépare le caractère lu au clavier et celui PROG:
MOV AX,Data
afficher par un retour à la ligne suivante: MOV DS,AX
MOV AH, 1
Exemple : int 21h
MOV a,AL
MOV DL,13
• Le premier D est celui saisie MOV AH,2
INT 21H
• Retour à la ligne suivante MOV DL,10
MOV AH,2
• 10 = LF (line feed - saut de ligne) INT 21H
MOV DL,a
• 13 = CR (carriage return - retour à la ligne) MOV AH,2
INT 21H
• Puis le caractère lu D
131
code ENDS
end PROG
 Exercice "prog24.asm"
data SEGMENT
msg db 'Bonjour'
data ENDS
code SEGMENT
ASSUME CS: code, DS: data
begin:
Ecrire un programme MOV AX,data
MOV DS, AX
assembleur qui affiche Bonjour. MOV SI,0
MOV CX,7
boucle:
MOV DL, msg[SI]
MOV AH, 02h
int 21h
INC SI
LOOP boucle
code ENDS
END begin
132
 Exercice "prog25.asm" data SEGMENT
msg db 'Bonjour tout le monde!!$'
data ENDS
code SEGMENT
ASSUME CS: code, DS: data
Ecrire un programme assembleur begin:
MOV AX,data
qui affiche une chaîne de taille MOV DS, AX
MOV SI,0
quelconque. boucle:
CMP msg[SI],'$'
JZ FIN
MOV DL, msg[SI]
MOV AH, 02h
int 21h
INC SI
JMP boucle
FIN:
code ENDS
133
END begin