Vous êtes sur la page 1sur 29

assembleur

http://cs.nyu.edu/courses/spring07/G22.3130-001/assembly_howto.txt
Contenu du cours

Structure d’un programme


Les directives
Les instructions / opérandes
Les données initialisées
Déplacer des données (MOV, PUSH )
Structure d’un programme
Un source assembleur est
une suite de lignes :
Indépendantes
Se suivant dans l’ordre
Chaque ligne peut contenir (dans l’ordre)
Un label
Une instruction/directive (+ opérandes)
Un commentaire
Le symbole « \ » seul
Les espaces/tabulations n’ont pas de sens
Structure d’un programme (2)

Exemple :

Ici1: movl2 $0,%eax3 \4


#5 met A à 0

1. Le label « Ici »
2. L’instruction « movl »
3. Les opérandes « $0, %eax »
4. La rupture de ligne « \ »
5. Le commentaire « met A à 0 »
Les labels
Tant qu’un programme n’est pas assemblé
Les instructions n’existent pas vraiment
Elles n’ont donc pas d’adresse en mémoire
On doit pourtant y faire référence :
Écriture dans une variable
Affichage d’un message
Appel d’une fonction
Nécessité de donner un nom à une ligne du programme

Naissance du label (ou encore étiquette)


Un label

Commence en première colonne


Obéit au motif [A-Za-z_.][0-9A-Za-z_.]* :
Une lettre, le caractère « _ » ou un point
Éventuellement des chiffres, des lettres,
des caractères « _ » ou « . »
Se termine par un deux-points : « : »
Est unique dans tout le programme.
Exemple :
Label_exemple.13 :
Les commentaires

Commencent par un dièse « # »


Se terminent en fin de ligne
Contiennent ce que vous voulez !

Ils sont ignorés par le compilateur


Ils ne produisent pas de code machine

Ils expliquent le programme


Le caractère « \ » seul
Indique la rupture de ligne
N’est suivi d’aucun caractère

Lors de l’assemblage :
La ligne suivante sera lue
Comme la suite de la ligne courante

Exemple :
movl %eax, \
$0x12345678 # gros entier
Contenu du cours

Structure d’un programme


Les directives
Les instructions / opérandes
Les données initialisées
Déplacer des données (MOV, PUSH )
Définition

Une directive de compilation


Ne génère pas de code
Donne des ordres au compilateur
Ne change pas le structure du programme

Elle respecte le motif .[a-z]+ :


Un point « . »
Une ou plusieurs lettres MINUSCULES
Directives de segmentation
.align n
Aligne les données en mémoire
Sur des paquets de n octets
Exemple : un 80386 ne peut lire un ‘long’ (32 bits) que s’il est aligné tous
les 4 octets.
.data
Indique le début du segment de données
.text
Indique le début du segment de code
Directives de constantes

.byte 65,0b1100101,0101,0x41,‘A
Inscrit 5 fois le nombre 65 en mémoire
Sur 8 bits chacun
Séparés par des virgules

.quad 0x0123456789ABCDEF, 13
Inscrit de grands nombres en mémoire
Sur 64 bits
Séparés par des virgules
Directives de constantes (2)
.ascii "Ring the bell\7"
Stocke les caractères en mémoire
(Ici suivi du caractère N°7 : BELL)
N’ajoute pas le ‘\0’ finale (≠ .string)

.float 0f – 31415926E-7
Stocke un nombre flottant en mémoire
(voir cours sur le FPU)
(ici : - p)
Contenu du cours

Structure d’un programme


Les directives
Les instructions / opérandes
Les données initialisées
Déplacer des données (MOV, PUSH )
Les instructions
Mnémoniques du langage du processeur cible
Peuvent avoir un ou plusieurs opérandes
Génèrent du code pendant l’assemblage
Sont très nombreuses
(Ne seront pas toutes étudiées !)
Exemple :
addl $4, %eax
cmpl $111, %eax
jz Boucle
Les opérandes
Indiquent les argument de l’instruction (ou directive) courante séparées par des
virgules
Peuvent être :
Registres : %eax, %esp, %bh, …
Constantes : $1, $0x24, $’A, $Question
(Question étant un label)
(sauf dans les directives : pas de dollar « $ »)
Expressions : $(64+1), $(’B-1)
(L’assembleur remplace par le résultat)
Indirection : (13)
(contenu de la mémoire à l’adresse 13.
Pas pour les directives)
Contenu du cours

Structure d’un programme


Les directives
Les instructions / opérandes
Les données initialisées
Déplacer des données (MOV, PUSH )
Bases de calculs
Décimale : [1-9][0-9]*
Mode par défaut de l’assembleur
Ne peut pas commencer par un zéro

Binaire : 0b[01]+

Octal : 0[0-7]*

Hexadécimal : 0x[0-9A-Fa-f]+
Les entiers
Les processeurs ont un bus de données bien défini (aujourd’hui 32 bits et
plus)
On ne travaille pas toujours avec des mots de cette taille…
Exemple :
260 = 1 0000 01002
En octets (8b) : 0000 00012,0000 01002
Sur 16b : 0000 0001 0000 01002
Sur 32b : 0000 0000 0000 0000 0000 0001
0000 01002
Les entiers (2)
.byte
1 octet, 8 bits
.hword, ou .short
2 octets, 16 bits
.long, ou .int
4 octets, 32 bits
.quad
8 octets, 64 bits
.octa
16 octets, 128 bits
Les flottants
.float, ou .single
Simple précision, 4 octets, 32 bits
.double
Double précision, 8 octets, 64 bits

Les FPU travaillent en fait sur 80 bits


Mais échangent leurs données sur 32 ou sur 64 bits avec le processeur
central.
Voir cours sur le Floating Point Unit…
Les tableaux

Deux possibilités :
Énumération des valeurs :
.byte ‘a, ‘b, ‘c, ‘d
.short 0, 1, 2, 3, 4
Spécification de la taille :
.space 4, 25 ou .fill 4,1,25
Est équivalent à
.byte 25, 25, 25, 25
Les chaînes de caractères

Deux façons de stocker une chaîne :


.ascii "Abcdefgh"
Insère les 8 premières lettres de l’alphabet

.string "Abcdefgh"
Insère les 8 lettres suivies du caractère N° 0
Le caractère 0 indique la fin de chaîne
Contenu du cours

Structure d’un programme


Les directives
Les instructions / opérandes
Les données initialisées
Déplacer des données (MOV, PUSH )
Manipulation de données

Opération de base = copie de données.


Instruction = MOV
Copie la source dans la destination
Ex :
movl $0,%eax #A0
movl $10,%ebx #B10
Movl %ebx,%eax #AB
#ici, A et B contiennent 10
Sélection de la taille des données

Dans la norme AT&T, la taille doit être indiquée


On ajoute une lettre à l’instruction
B : Byte, 1 octet
W : Word, 2 octets
L : Long Word, 4 octets
Q : Quad Word, 8 octets
Ex :
movw $0, %ax
movq $25, %mm0 # registre mmx
MOV : opérations permises
Tous les mouvements ne sont pas permis
Exemple : Mémoire  Mémoire est illégal
Les possibilités sont :

Valeur Immédiate
eAX
M
eBX
E
eCX
M
eDX
O
eSI
I
eDI
R
eBP
E
eSP
CS, DS, ES, FS, GS, SS
Mouvements sur la pile
Pile = LIFO : Last In First Out
En assembleur : mémoire contextuelle
On ferme le dernier bloc ouvert
Comme des parenthèses
Deux instructions :
PUSH = empiler
met une valeur sur la pile.
Sur x86, le registre esp diminue
POP = dépiler
retire une valeur de la pile.
Sur x86, le registre esp augmente
Exemple de manipulation de pile

movw $0x10, %ax


pushl %eax
popl %ebx
esp
Pile
**10
esp

Registres

EAX EBX ESP

**10
**** **10
???? 96
10010
10