Introduction Pratique Assembleur

Architecture d’Ordinateurs
Introduction Pratique Assembleur
Introduction
L’objectif de ce document est de donner les d´etails pratiques pour ´ecrire, compiler et ex´ecuter les premiers
programmes en Assembleur. On va travailler sur la machine sirius o`u on dispose du compilateur nasm. Pour
se connecter `a sirius, d´emarrer l’ordinateur sous Linux. Dans la fenˆetre “Gestionnaire de bureaux GNOME”
il faut choisir Action et apr`es “Connexion distante via XDMCP”. Choisir sirius comme hˆote et se connecter.
D’abord, il faut cr´eer un r´epertoire TP1_NOM_PRENOM o`u on peut cr´eer le fichier bonjour.nasm dans lequel
on va ´ecrire nos programmes. Je vous conseille d’utiliser l’´editeur Kate car il permet de faire la coloration
syntaxique (si besoin, il faut s´electionner Tools→Highlighting→Assembler→Intel X86 nasm).
Voici un premier exemple de programme qui affiche la chaˆıne Bonjour !
1 g l o b a l main ; c e c i e s t un commentaire
2 ex t er n p r i n t f
3 SECTION .data
4 bonjour : db ”Bo nj ou r ! ” , 1 0 , 0 ; 10 =c a r a c t `e r e ASCI Line Feed ( l e s au t de l i g n e ”\n ” en C)
5; 0 = c a r a c t `e r e pour marquer l a f i n de c haˆı ne ( pour p r i n t f )
6 SECTION . t e x t
7 g l o b a l main
8 main :
9push ebp
10 mov ebp ,esp
11 pushad
12
13 pushad
14 push dword bonjour ; on mets l ’ a d r e s s e de l a c haˆı n e dans l a p i l e
15 c a l l printf
16 popad
17 add esp , 4 ; pop s ta c k ( d´e p i l e r ) une f o i s
18
19 popad
20 xor eax ,eax ; r e t u r n v a l u e = 0
21 mov esp ,ebp
22 pop ebp
23 ret
Notons que les lignes 1-3, 6-11 et 19-23 ne doivent pas ˆetre modifi´ees dans les programmes que vous
´ecrivez ensuite. Pour compiler ce programme, on va cr´eer dans le mˆeme r´epertoire un fichier Makefile qui
contient :
a l l :
[TAB] nasm −f e l f −g bonjour . nasm
[TAB] gcc −ggdb −o bonjour bonjour .o
Dans ce fichier Makefile, [TAB] fait r´ef´erence `a la touche Tabulation. Ouvrez une console (terminal) est
aller dans le r´epertoire TP1_NOM_PRENOM qui contient ces deux fichiers (Makefile et bonjour.nasm). Tapez
make pour compiler et ./bonjour pour ex´ecuter.
Modifier le fichier bonjour.nasm afin de r´esoudre les exercices de TP1.
Indications : Pour l’exercice 1 du TP1, on utilise l’instruction mov (pour mettre les valeurs de aet b
dans les registres EAX et EBX), suivie par cmp (cet instruction compare deux registres – EAX et EBX – et mets
le r´esultat dans le registre flags), suivi par une instruction jle (Jump if Lower or Equal – au cas o`u le
r´esultat stock´e dans le registre flags indique que la valeur de EAX est inf´erieure `a celle de EBX, le programme
effectue un saut).
Pour avoir des renseignements sur une instruction, vous pourriez consulter le cours, ainsi que des ma-
t´eriaux sur Internet, e.g. une liste d’instructions se trouve `a en.wikipedia.org/wiki/X86_instruction_
listings
TP Architecture des ordinateurs, M2 CCI, Universit´e d’Angers – 2009-2010 Daniel Porumbel

Le programme suivant compare deux nombres aet bet affiche leur relation d’ordre.
1 g l o b a l main ; c e c i e s t un commentaire
2 ext er n p r i n t f
3 SECTION .data
4 a dd 10 ; a e s t un e n t i e r su r 32 b i t s , sa v a l e u r e s t 10
5 b dd 9; b e s t un e n t i e r su r 32 b i t s , sa v a l e u r e s t 9
6 bonjour : db ”Bonjour ! ” , 10 , 0
7 msgInf : db ”a<b ” ,1 0 ,0
8 msgSup : db ”a>=b ” , 10 , 0
9
10 SECTION . t e x t
11 g l o b a l main
12 main :
13 push ebp
14 mov ebp ,esp
15 pushad
16
17 mov eax , [ a ]
18 mov ebx , [ b ]
19 cmp eax ,ebx
20 j l i n f
21
22 pushad
23 push dword msgSup ; on mets l ’ a d r e s s e de l a c h aˆın e dans l a p i l e
24 c a l l printf
25 popad
26 add esp , 4 ; pop s ta c k ( d ´e p i l e r ) une f o i s
27 jmp f i n ; on ne v e ut pas c o n t in u e r `a a f f i c h e r msgInf
28 i n f :
29 pushad
30 push dword msgInf ; on mets l ’ a d r e s s e de l a c h aˆı n e dans l a p i l e
31 c a l l printf
32 popad
33 add esp , 4 ; pop s ta c k ( d ´e p i l e r ) une f o i s
34 f i n :
35 popad
36 xor eax ,eax ; v a l e u r de r e t o u r du programme = 0
37 mov esp ,ebp
38 pop ebp
39 ret
Pour faire tourner ce programme, il est convenable d’´ecrire ce code dans le fichier bonjour.nasm et de
le compiler avec la commande make. Ensuite, pour r´esoudre d’autre exercices, il est conseiller de travailler
que avec le fichier bonjour.nasm que vous pouvez le modifier. Informations utiles :
– Observez que ce programme a plusieurs variables dans la section .data, e.g. a,b, msgInf, msgSup.
Les types de donn´es qu’on utilise sont : db (data byte), dw (data word) et dd (data double). Un variable
d´eclar´ee db est cod´e sur un octet (ou une s´erie de plusieurs octets comme pour les variables msgIng,
msgSup). Pour stocker les nombres aet b, on utilise des variables `a 4 octets (dd) car les registres eax et
ebx ont 4 octets (32 bits). Observez que la valeur d’une variable est lue/´ecrite en utilisant les crochets.
Un exemple de d´eclaration de tableau de 100 entiers de valeur 7 est monTableau : times 100 dd 7
– Les registres qu’on va utiliser le plus souvent sont : eax, ebx, ecx, edx (registres g´en´eriques) ; ebp,
esp (registres utilis´es exclusivement pour traiter la pile d’ex´ecution du programme) ; il faut aussi
connaˆıtre le registre EIP (Instruction Pointer) qui repr´esente l’adresse m´emoire de l’instruction cou-
rante. La pile est importante quand on ´ecrit des sous-programmes ou des proc´
edures.
TP Architecture des ordinateurs, M2 CCI, Universit´e d’Angers – 2009-2010 Daniel Porumbel

– Les principales instructions utilis´es dans le TP d’assembleur sont :
–mov dest,src copie le contenu de src en dest. Par exemple :
mov eax,[a] ; copie la valeur de a dans le registre eax
–jmp ´etiquette fait un saut `a une adresse ´etiquette, voir lignes 27 et 34 pour la d´eclaration des
´etiquettes de saut
–cmp op1, op2 fait une comparaison entre op1 et op2 (voir ligne 19). Le r´esultat de cette
comparaison est stock´e dans un autre registre (FLAGS) et la prochaine instruction (de saut) est
capable de lire ce r´esultat.
–jl ´etiquette fait un saut `a l’adresse ´etiquette si la derni`ere comparaison `a eu comme r´esultat
op1<op2. Il y a en fait une s´erie d’instruction de ce type : jl(Jump if Lower), jle (Jump if Lower of
Equal), jg (Jump if Greater), etc.
–push et pop instructions pour empiler et d´epiler. Par exemple :
1mov eax , 7 ; l a v a l eu r 7 s e ra dans l e r e g i s t r e eax
2push eax ; l a v a l e u r de eax ( 7) e s t mise au sommets de l a p i l e
3mov ebx , 9 ;
4mov ecx , 5 ;
5push ebx
6push ecx ; la p i l e ser a : 7 9 5
7pop edx ; edx s e r a 5 e t l a p i l e : 7 9
8pop eax ; eax se r a 9 e t l a p i l e : 7
9pop ebx ; ebx s era 7 e t l a p i l e v id e
Notons que l’instruction add esp,4 enl`eve pratiquement la valeur du sommet de la pile, e.g. si on
ajoute add esp, 4 avant pop edx, alors edx sera 9.
–call maProcedure appelle la proc´edure maProcedure, e.g. voir ligne 24 o`u on appelle printf
–ret cette instruction termine la proc´edure courante et renvoie la valeur de eax
– Add, Sub, Mul, Div, Inc, Dec, Shl, Sar ce sont des instructions pour des op´erations math´ematiques.
Par exemple :
1mov eax , 7 ; eax=7
2mov ebx , 5 ; ebx=5
3add eax ,ebx ; eax s e ra 12
4mov ecx , 10 ;
5sub eax ,ecx ; eax se r a 2
D’autres exemples d’instructions arithm´etiques sont disponibles `a en.wikibooks.org/wiki/X86_
Assembly/Arithmetic.
TP Architecture des ordinateurs, M2 CCI, Universit´e d’Angers – 2009-2010 Daniel Porumbel