4.langage Assembleur

Architecture Intel
Architecture Intel
&
&
assembleur
assembleur
Génie informatique E.N.S.A.H

Semestre 1
Année universitaire 2016/2017
Abdelhafid MESSAOUDI Architecture des ordinateurs

langage assembleur
Présentation
Les ordinateurs PC des début des années 80 étaient équipés du

8086, un processeur 16 bits.
Depuis, les processeur n’ont cesser d’évoluer, les modèles se

succédaient. 80286, 80386, 80486, Pentium I, Pentium II …..
Chaque processeur est plus puissant que les précédents; fréquence

d’horloge plus élevée, bus de données plus large, nouvelles
instructions, augmentation du nombre de registres …
Chacun de ces processeurs est compatible avec les modèles
précédents.
Un programme écrit avec un langage machine d’un processeur

peut s’exécuter sur les nouveaux modèles, mais l’inverse n’est pas
possible.
Abdelhafid MESSAOUDI Architecture des ordinateurs 2
langage assembleur
Présentation
On parle alors de compatibilité ascendante
Dans ces conditions, il est possible de programmer les pentium IV

dont sont équipés les ordinateurs des salles de TP comme des
processeur 16 bits ou 32 bits.
Toutefois, on peut introduire des instructions manipulant des

registres 32 bits en ajoutant aux programmes des directives
particulières.
Pour cela on utilise le langage assembleur dont le rôle est de

convertir les instructions du langage assembleur (des
mnémoniques) en des micro-instructions.
Notons que, chaque type de microprocesseur possède son propre

jeu d’instructions
langage assembleur
Convention Intel
Pour programmer en assembleur, nous sommes forcés de suivre
certaines conventions, qui en réalité viennent directement du
constructeur.
Le constructeur le plus populaire est Intel
Comme exemple de programme, nous avons :
mov eax,101
mov ebx,0x378
mov ecx,3
mov edx,1
int 0x80
Le code généré est visiblement claire

langage assembleur
Convention AT&T
Le style de codage AT&T a vu le jour en même temps qu’Unix et
les conventions adoptées datent donc de la même époque.
Si nous avons pris l’habitude de coder en suivant les conventions

d’Intel, nous aurions de la peine à se familiariser rapidement avec
les conventions AT&T.
Comme exemple de programme, nous avons :
movl %esp,%ebp
pushl %ebx
movl %eax,%ebx
Pour les habitués du DOS, le code ci-dessus est « illisible »

langage assembleur
Convention AT&T
Il existe des assembleurs grâce auxquels on peut utiliser les
conventions Intel sur une plateforme Unis (linux).
Nasm (Netwide assembler) et l’un de ces assembleurs. Nous

l’avons choisi pour les deux raisons suivantes:
La convention Intel parait plus claire en comparaison avec la
convention AT&T
Nasm ne sera pas nostalgique pour ceux qui étaient habitués au
DOS
Deux raisons pouvaient nous faire migrer vers la convention AT&T
Le format d’affichage GNU gdb.
La syntaxe de l’assembleur inline à l’intérieur du code C via

__asm__().
langage assembleur
Les différents registre du microprocesseur
Le nombre de registres diffère d’un microprocesseur à un autre.
Les plus utilisés sont:
Les registres généraux
EAX : registre accumulateur (accumulator reg.) utilisé pour les

opérations arithmétiques et le stockage de la valeur de retour des
appels systèmes.
ECX : registre compteur (counter reg.)
EBX : registre de base (base reg.)
EDX : registre de données (data reg.) utilisé pour les opérations
arithmétiques et les opérations d'E/S.
AX : 16 bits de poids faible de EAX (idem BX, CX, DX)
AL : octet de poids faible de AX (idem BL, CL, DL)
AH : octet de poids fort de AX (idem BH, CH ,DH)

langage assembleur
Les différents registres du microprocesseur
D’autres registres sont utilisés comme pointeurs et sont dit:
Registres d’adresses
ESI : pointeur source (Extended Source Index)
EDI : pointeur destination (Extended Destination Index)
EBP : pointeur de base (Extended Base Pointer)
ESP : pointeur de pile (Extended Stack Pointeur)

langage assembleur
Les différents registres du microprocesseur
Il existe d’autre registres qui sont utilisés pour d’autres fins
EIP : pointeur d'instruction
EFLAGS : registre d‘états (drapeaux)
CS, SS, DS, ES, FS, GS : registres de segment (16 bits) :

adresses et données de programme.

langage assembleur
Les différents drapeaux du registre d’état
Les drapeaux du registre d’état sont les suivants:
Zero Flag (ZF)

1 si les deux opérandes utilisées sont égales, 0 sinon.
Overflow Flag (OF)

1 si le dernier résultat a provoqué un overflow, 0 sinon.
Carry Flag (CF)

: 1 si la dernière opération a généré une retenue ;0 sinon.
Sign Flag (SF)

:1 si la derniere opération a généré un resultat négatif, 0 s'il est
positif ou nul.

langage assembleur
Les différents drapeaux du registre d’état
Parity Flag (PF)

:1 si la derniere opération a généré un résultat impair, 0 s'il est pair
(nombre de bits a 1).
Interrupt Flag (IF)

1 si les interruptions sont autorisées, a 0 sinon.

langage assembleur
Position de quels que drapeaux dans le registre d’état

langage assembleur
Le format des instructions
En assembleur, une instruction se compose d’un mnémonique qui
désigne l’opération qui est suivi d’opérandes.
Instruction = opération + opérandes
Une opérande peut être :
Une donnée brute:
mov eax, 55 (décimal)

mov eax, 0b110111 (binaire)
mov eax, 0xfa89 (hexadécimal)

langage assembleur
Le format des instruction
Elle peut être une adresse
mov dx, 0x37A

Dans ce cas, 37A(en hexadécimal) désigne l’adresse d ’un registre
du port parallèle.

langage assembleur
Les modes d’adressage
Pour accéder aux données stockées en mémoire, on dispose de
plusieurs mode d’adressage.
Adressage direct: dans ce cas, l’opérande est une adresse de 32 bits

qui désigne le même emplacement en mémoire dont le contenu
peut changer.
Exemple : mov eax, [0x0000f13a] : cette instruction a pour rôle de

mettre le contenu de la mémoire d’adresse 0x0000f13a dans le
registre eax.
Adressage par registre: dans ce cas l’opérande est un registre
Exemple : mov eax, esp : mettre dans eax l’adresse du sommet de
la pile

langage assembleur
Les modes d’adressage
Adressage indirect par registre: dans ce cas, l’opérande est un
registre qui contient l’adresse d’une case mémoire:
mov eax, [esp] : cette instruction a pour rôle de mettre le contenu

du sommet de la pile dans le registre eax.
Adressage indexé : dans ce cas l’opérande est une adresse

mémoire contenu dans un registre associé à un décalage.
Mov eax,[ebp +8].

langage assembleur
Les différentes instruction x86
Les instructions du x86 peuvent être regroupées en différentes
catégories.
Les opérations de transfère : ce sont des opérations qui s’effectuent

entre la mémoire et les registres
Les opérations arithmétiques
Les opérations logiques
Les opérations de décalage et de rotation.
Les opérations de branchement (saut conditionnel, saut

inconditionnel, boucle et appels système.
Les opérations sur les chaînes de caractères.

langage assembleur
Les instructions de transfère
Ce sont des instructions qui consistent à copier des données entre
la mémoire et les registres. Le mnémonique utilisé est mov
mov registre, mémoire
mov mémoire, registre
mov registre, registre
mov mémoire, mémoire est une instruction qui n’est pas permise
L’instruction xchg est utilisée pour échanger le contenu de deux

registre ou le contenu d’un registre et d’une case mémoire.
xchg eax, ebx xchg eax, [0x65f28a66]

langage assembleur
Les instructions de transfère
Les deux opérations push et pop concernent la pile
push est utilisée pour empiler
pop est utilisée pour dépiler
Remarque:
Plus on empile sur la pile, plus l’adresse du sommet de la pile

décroit.

langage assembleur
Les instructions arithmétiques
add est une instruction qui permet de réaliser une addition entière
(en complément à 2).
Cette instruction nécessite deux opérandes dont au moins un

registre.
Cette opération positionne les drapeaux CF et OF
add eax,0x25fe add
Attention aux incompatibilités:

add al, ebx registres de différentes tailles.

langage assembleur
mul est une instruction qui permet de réaliser une multiplication
entière positive
Elle nécessite une seule opérande. Elle réalise le produit du

contenu du registre eax avec l’opérande en question.
mul ebx
Le résultat est stocké dans les deux registres edx|eax
mul ebx edx|eax  ebx.eax

langage assembleur
Pour réaliser une multiplication entière en complément à 2 on
dispose de l’instruction imul.
Elle possède les mêmes caractéristiques que mul, sauf qu’on utilise
des entiers relatifs.
Elle nécessite une seule opérande. Elle réalise le produit du
contenu du registre eax avec l’opérande en question.
imul ebx
Le résultat est stocké dans les deux registres edx|eax
imul ebx edx|eax  ebx.eax

langage assembleur

langage assembleur
Les instructions logiques
Les opérations logiques sont des opérations bit à bit.
Opération destination, source
L’opération and possède deux opérandes (destination et source).
Elle peut être utilisée comme masque pour extraire un ensemble de

bits.
Comme exemple and eax, 0b11110000 qui permet d’extraire les

quatre bits du registre eax à partir du cinquième.
Nous avons aussi, or, xor et not.

langage assembleur
Les instructions logiques

langage assembleur
Les instructions de décalage et de rotation
Ces instructions nécessitent deux opérandes; un registre et le
nombre de bits de décalage.
Décalage logique à gauche shl: cette opération insère nb 0 à

partir de la droite.
Exemple shl ah, 3 ( ah=01100111 ah=00111000)
Décalage arithmétique à droite sar : cette opération insère nb

copies du bit qui se trouve complètement à gauche (bit du poids
fort).
Exemple sar al, 5 (al=10100001  al=11111101)

langage assembleur
Rotation à gauche rol : cette opération fait une rotation de nb bits,
les bits qui sortent de la gauche sont réinjectés à partir de la droite.
Exemple rol bl, 2 (bl=10111001  bl=11100110).
Rotation à droite avec retenue crr: cette opération permet de faire

une rotation de nb bits à droite en prenant en considération le bit
de la retenue.
Exemple crr bl, 4 : (bl=01101110 c=1  bl=11010110 c=1)
1er décalage : (bl=01101110 c=1  bl=10110111 c=0)
2ème décalage : (bl=10110111 c=0  bl=01011011 c=1)

langage assembleur

langage assembleur
Les instructions de comparaison
L’instruction de comparaison cmp compare deux opérandes en
faisant une soustraction des deux opérandes sans stocker le
résultat. Elle positionne le drapeau CF.
Exemple cmp eax, ebx : l’opération réalisée est eax- ebx
Si eax=ebx  ZF=0 sinon ZF=1

langage assembleur
Instructions de branchement
Il existe plusieurs instructions de branchement.
Les sauts conditionnels.
Les sauts inconditionnels.
Les boucles fixes.
Les boucles conditionnelles.
Les boucles inconditionnelles.

langage assembleur
Instructions de branchement les sauts conditionnels
Le saut conditionnel réalise un saut vers l’étiquette spécifiée
lorsque la condition est remplie.
L’expression de l’instruction est comme suit: jxxxx etiquette.
Exemple
je étiquette : saut à étiquette si le drapeau d’égalité est à 1
jne étiquette : saut à l’étiquette si le drapeau d’égalité est à 0
Pour ces deux instructions, le drapeau d’égalité doit être positionné

par l’instruction cmp.

langage assembleur
jge étiquette : saut à étiquette si c’est supérieur ou égal.
jnge étiquette : saut à l’étiquette si c’est inférieur.
Avant d’utiliser ces deux instructions, il faut utiliser l’instruction

cmp.
jl étiquette: saut à étiquette si c’est inférieur strictement.
jnl étiquette: saut à étiquette si ce n’est pas strictement inférieur.
jo étiquette: saut à étiquette si overflow (OF=1).
jno étiquette : saut à étiquette si no overflow (OF=0).

langage assembleur
jc étiquette: saut à étiquette si le drapeau Carry est positionné
(CF=1).
jnc étiquette: saut à étiquette si le drapeau Carry est non positionné

(CF=0).
jp étiquette : saut à étiquette si le drapeau parity est positionné

(PF=1).
jnp étiquette :saut à étiquette si le drapeau parity n’est pas

positionné (PF=0).
jcxz étiquette : saut à étiquette si le registre cx est nul.
jecx étiquette : saut à étiquette si le registre ecx est nul.

langage assembleur
Instructions de branchement les
boucles
L’instruction loop est une instruction qui exécute une boucle fixe.
loop étiquette : elle décrémente le contenu du registre ecx est saut à
étiquette si ecx ≠ 0.
L’instruction loope est une instruction qui exécute une boucle

conditionnelle.
loope étiquette : décrémente le registre ecx (ecx ecx-1) est saute à

étiquette si (ecx ≠0 et ZF=1).
loopne étiquette : décrémente le registre ecx (ecx ecx-1) est saute

si (ecx ≠0 et ZF=0).

langage assembleur
Instructions de branchement les
boucles

langage assembleur
Structure d’un programme assembleur
Un programme assembleur est un fichier texte avec l’extension
.asm. Exemple programme1.asm.
Il est organisé en plusieurs SECTION (SECTION=segment).
Ils existent plusieurs sections (SECTION du code, SECTION de

données, …).
Le NASM possède des directives auxquelles correspondent

différentes instructions pour le processeur.
Une ligne du programme doit comporter une seule instruction.

Pour séparer deux instructions, un saut de ligne est indispensable.
Une ligne comporte au plus quatre champs.

étiquette : instruction opérandes ; commentaire
langage assembleur
Structure d’un programme assembleur section de
données
La section de données SECTION .data est utilisée pour définir et
initialiser des variables.
La directive utilisée pour déclarer et initialiser des données est dx.

Le (d : difine) et le x peut être (b: byte un octet) (w: word deux
octets) (d: double quatre octets) (q : quad words 8 octets) (t : ten
10 octets).
Exemple:
var 1 : db 55 ; un octet contient la valeur décimale 55

db 0x88, 244, 0b10010110, 0xfa ; 4 octets
dw 0xfaec ; deux octets 0xec et 0xfa ( little endian)
var2 : dw ‘AB’ ; deux octets 0x41 et 0x42 ( little endian).
var3 : dd ‘ABC’ ; quatre octets 0x41, 0x42, 0x43 et 0x00.
: dq ‘C’ ; 8 octets 0x43, 0, 0, 0, 0, 0, 0, 0, et 0.
langage assembleur
données
La section de données SECTION .data est aussi utilisée pour
définir des constantes à l’aide de la directive equ.
Exemple :
longeur_chaine equ 29.
Par fois, nous avons besoin de répéter une déclaration un certain

nombre de fois. La directive utilisée est times.
Exemple
var_1 times 80 db 25 ; déclare et initialise 80 fois l’octet 25.
var_2 times 35 dw 0xfaec ; 35 fois le mot 0xfaec.

langage assembleur
données
La section SECTION .bss est utilisée pour déclarer des variables
non initialisées.
SECTION .bss
Var1 resb 5 ; reserve 5 octets
Var2 resw 8; reserve 8 words 8x2=16 octets)
Var3 resd 6; reserve 6 dwords 6x4=24 octets)
Var4 resq 4; reserve 4 quadwords 4x8=32 octets)
Var5 rest 7 ;reserve 7x10=70 octets)
Remarque
Les étiquettes qui précèdent les directives représentent des adresses
et non les noms des variables.
var11 dw 0x22ab ; var11 représente l’adresse du mot 0x22ab.

langage assembleur
Structure d’un programme assembleur section du code
Le corps du programme commence par SECTION .text
Un programme assembleur commence par déclarer global

l’étiquette qui correspond au début du programme pour qu’elle soit
visible à l’extérieur.
SECTION .text
global main
main :
fin : mov eax,1 ; 1 est le numéro de l’appel système exit

mov ebx,0 ; 0 est l’argument de l’appel système exit
int 0x80 ; l’intrruption 0x80 appelle le noyau
langage assembleur
Structure d’un programme assembleur présentation d’un fichier
.asm
SECTION .data
; données initialisées
SECTION .bss
; données non initialisées
SECTION .text
global main ; rend l‘étiquette visible de l'extérieur
main :
; programme
;
fin :
mov ebx,0 ; code de sortie,
mov eax,1 ; numéro de l’appel système exit
int 0x80 ; interruption 80 hex, appelle le noyau
langage assembleur
Assembler un programme
La première étape par laquelle il faut passer est la création du
fichier objet.
Elle consiste à traduire le programme écrit en langage assembleur

en instructions machines
La syntaxe générale est la suivante:
nasm -g -f <format> <fichier> [-o <sortie>]
Exemple : nasm –g –f elf test1.asm –o test1.o

Si on désire obtenir un listing des instructions machines, la
commande est la suivante:
nasm -g -f elf test1.asm -l test1.lst

langage assembleur
Assembler un programme
La deuxième étape est l’édition des liens qui est réalisée grâce à la
commande suivante:
ld -e main test1.o -o test1
Remarque :
main représente l’étiquette dans le programme assembleur qui a été

déclarée global.

langage assembleur
Les interruptions
Un programme est un ensemble d’instructions qui s’exécutent les
unes après les autres.
Cette exécution peut être interrompu à tous moment pour réaliser

des traitement qui correspondent à des événements qui nécessitent
une réponse instantanée.
Citons le cas de la sourie. Lorsque celle-ci est déplacée, le

programme en cours est interrompu pour gérer le déplacement.
Une fois le programme interrompu, il y a sauvegarde de tous les

registres.
Une fois l’interruption terminée, tous les registres sont restaurés à

l’exception du registre eax.
langage assembleur
Les entrées/sorties
L’échange d’informations entre le processeur et le monde extérieur
est réalisé grâce aux périphériques d’entrées/sorties.
Il y a des périphériques d’entrées qui envoient des informations au

processeur (sourie, clavier, lecteur CD ..).
Les périphériques de sorties reçoivent les informations du

processeur (écran, imprimante…).
Il y a d’autres périphériques qui sont mixtes (à la fois entrée et

sortie) (disque dur, graveur DVD…).
La plus part du temps, ces périphériques entrées/sorties sont gérés

par interruption pour garantir une réponse rapide.

langage assembleur
Les sous-programmes
Le sous-programme en question peut être utilisé par plusieurs
parties du programme.
Pour avoir une bonne exécution de tout le programme, le sous-

programme est obligé de revenir au point d’où il a été appelé.
Cette étape (retour au point de départ) ne peut pas être codé par un
saut à une étiquette (codage en dur).
Donc l’étiquette de retour doit être un paramètre du sous-

programme.
La solution est donnée par les deux instructions call et ret .
Un deuxième problème est rencontré, c’est le passage de

paramètres.
langage assembleur
Les sous-programmes
La première solution à laquelle on peut penser est la transmission
de paramètres par registres. Mais cette méthode présente un
inconvénient majeur:
Limitation du nombre de paramètres.
Comme solution à ce problème, les paramètres seront transmis en

utilisant la pile.
C’est la convention du langage C

langage assembleur
Passage des paramètres par la pile
Les paramètres transmis par le programme au sous-programme
sont empilés dans la pile avant l’exécution de l’instruction call.
Si le sous-programme doit modifier un paramètre, c’est son adresse

qui doit être transmise et non le paramètre lui-même.
Pour que le sous-programme exploite les paramètres, il ne doit pas

les dépiler de la pile. Il doit leurs accéder dans la pile.
Cela permet de garder une copie des paramètres dans la pile.

langage assembleur
Si le sous programme en question n’utilise pas la pile, cette
dernière est organisée comme suit:
esp adresse de retour
esp +4 paramètre 2
esp +8 Paramètre 1
L’accès aux paramètres se fait par adressage indirecte

[esp+4] et [esp+8].
Si par contre le sous-programme utilise la pile, l’organisation de

cette dernière est comme suit
esp Donnée du sous-programme
esp +4 Adresse de retour

esp +8 Paramètre 2
esp +12 Paramètre 1
langage assembleur
L’accès aux paramètres se fait par adressage indirecte mais en
commençant par l’adresse esp+8.
[esp+8] et [esp+12].
On remarque que esp fait référence aux paramètres. Cela peut

provoquer des erreurs.
Pour palier à ce problème, on fait référence aux paramètres en

utilisant le registre ebp (base de la pile).
En utilisant la convention du langage C, un sous programme

commence par empiler sur la pile le contenu du registre ebp.
Ensuite le sous-programme affecte le contenu du registre esp dans

le registre ebp.
langage assembleur
Dans ces conditions le contenu du registre esp peut changer sans

altérer le contenu du registre epb lorsque le sous programme utilise
la pile.
À la fin du sous-programme, la valeur du registre ebp est restaurée.

langage assembleur
En réalité le registre ebp indique là où commence la pile pour le
sous-programme.
Donc d’après ce qui précède, le code d’un sous-programme se

présente comme suit:
étiquette_du_sous-programme :
push ebp ; sauvegarde de ebp
mov ebp, esp ; ebp=esp
; code du sous-programme
mov esp, ebp

pop ebp ; restauration de ebp
ret ; retour au programme
langage assembleur
Observant l’organisation de la pile dans les deux cas différents;

lorsque le sous-programme utilise la pile et lorsque le sous-
programme n’utilise pas la pile.

langage assembleur
Passage des paramètres par la pile le sous-programme n’utilise pas la
pile
esp ebp ebp sauvegardé

esp + 4 ebp + 4 adresse retour
esp + 8 ebp + 8 paramètre 2
On remarque dans ce cas que le contenu des deux registre esp ne

change pas; par ce que le sous-programme n’a empilé aucune
donnée.
Le sous-programme peut accédé aux paramètre par adressage

indexé en utilisant soit le registre esp ou le registre ebp.
Aucune différence, le contenu des deux registres est le même.

langage assembleur
Passage des paramètres par la pile le sous-programme utilise pas la
pile
esp Donnée du sous-programme
esp + 4 ebp ebp sauvegardé
esp + 8 ebp + 4 adresse retour
Dans ce cas, les contenus des deux registres esp et ebp sont
différents
Pour que le sous-programme fonctionne correctement, il faut qu’il

utilise le registre ebp pour accéder aux paramètres envoyées par le
programme appelant.
Le premier paramètre est accessible depuis l’adresse ebp+8

langage assembleur
Pour une meilleure gestion de la mémoire, et pour éviter

d’éventuels mauvais fonctionnements du programme, les
paramètres qui ont été empilés sur la pile doivent être dépilés.
En réalité, on a pas besoin de les dépiler, il suffit juste de les

ignorer.
D’après la convention d’appel du C, c’est le programme appelant

qui doit dépiler les paramètres transmis à la pile.
Remarque
En mode 32 bits une instruction push mobilise 4 octets sur la pile,

pour désallouer l’espace qui lui a été alloué, il suffit d’exécuter
l’instruction add esp, 4
langage assembleur
De façon générale, si le programme appelant envoie sur la pile n
paramètres, la première instruction qui doit être exécutée par le
programme après le retour est add esp, (n*4).
La partie du programme qui correspond à l’envoie des paramètres,

l’appel du sous-programme et la reprise du programme appelant
est
push paramètre ; transmission d’un paramètre

call étiquette ; appel du sous-programme
…. ; code du sous-programme
add esp 4 ; on désalloue 4 octet qui correspondent au paramètre

langage assembleur
push paramètre 1 ; transmission du premier paramètre

push paramètre 2 ; transmission du deuxième paramètre
call étiquette ; appel du sous-programme
…….. ; code du sous-programme
add esp 8 ; on désalloue 8 octet qui correspondent aux 2

paramètres
On pourrait utiliser l’instruction pop, mais cela est sans intérêt,

dans la mesure où les paramètres n’ont pas besoins d’être stockés
dans les registres.
langage assembleur
Exemple complet d’appel d’un sous-programme
Soit le programme suivant:
section .data
message db ‘salam’,0x0A
Long_message equ $ - msg
section .text
global main
main :
push dword long_message
push dword message
call affiche
add esp,8
mov eax,1
mov ebx,0
int 80h
affiche:
push ebp
mov ebp,esp
mov eax,4
mov ebx,1
mov ecx,[ebp + 8]
mov edx,[ebp + 12]
int 80h
mov esp,ebp
pop ebp
ret

langage assembleur
Appel de fonctions écrites en assembleur sous un programme C
Il est possible d’appeler des fonction qui ont été écrites en
assembleur sous un programme C.
Il suffit de déclarer la fonction dans le fichier C avec la directive

extern.
extern void ma_fonction(void)
extern void ma_fonctio (int a, char b)
extern int ma_fonction (int a, int b, int c)

4.langage Assembleur

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

4.langage Assembleur

Încărcat de

Drepturi de autor:

Formate disponibile

Architecture Intel

Génie informatique E.N.S.A.H

Abdelhafid MESSAOUDI Architecture des ordinateurs

Les ordinateurs PC des début des années 80 étaient équipés du

Depuis, les processeur n’ont cesser d’évoluer, les modèles se

Chaque processeur est plus puissant que les précédents; fréquence

Un programme écrit avec un langage machine d’un processeur

Dans ces conditions, il est possible de programmer les pentium IV

Toutefois, on peut introduire des instructions manipulant des

Pour cela on utilise le langage assembleur dont le rôle est de

Notons que, chaque type de microprocesseur possède son propre

Le constructeur le plus populaire est Intel

Comme exemple de programme, nous avons :

Le code généré est visiblement claire

Si nous avons pris l’habitude de coder en suivant les conventions

Comme exemple de programme, nous avons :

Pour les habitués du DOS, le code ci-dessus est « illisible »

Abdelhafid MESSAOUDI Architecture des ordinateurs 5

Nasm (Netwide assembler) et l’un de ces assembleurs. Nous

Le format d’affichage GNU gdb.

La syntaxe de l’assembleur inline à l’intérieur du code C via

EAX : registre accumulateur (accumulator reg.) utilisé pour les

Abdelhafid MESSAOUDI Architecture des ordinateurs 7

ESI : pointeur source (Extended Source Index)

EDI : pointeur destination (Extended Destination Index)

EBP : pointeur de base (Extended Base Pointer)

ESP : pointeur de pile (Extended Stack Pointeur)

Abdelhafid MESSAOUDI Architecture des ordinateurs 8

EIP : pointeur d'instruction

EFLAGS : registre d‘états (drapeaux)

CS, SS, DS, ES, FS, GS : registres de segment (16 bits) :

Abdelhafid MESSAOUDI Architecture des ordinateurs 9

Zero Flag (ZF)

Overflow Flag (OF)

Carry Flag (CF)

Sign Flag (SF)

Abdelhafid MESSAOUDI Architecture des ordinateurs 10

Parity Flag (PF)

Interrupt Flag (IF)

Abdelhafid MESSAOUDI Architecture des ordinateurs 11

Abdelhafid MESSAOUDI Architecture des ordinateurs 12

Instruction = opération + opérandes

Une opérande peut être :

Une donnée brute:

mov eax, 55 (décimal)

Abdelhafid MESSAOUDI Architecture des ordinateurs 13

mov dx, 0x37A

Abdelhafid MESSAOUDI Architecture des ordinateurs 14

Adressage direct: dans ce cas, l’opérande est une adresse de 32 bits

Exemple : mov eax, [0x0000f13a] : cette instruction a pour rôle de

Abdelhafid MESSAOUDI Architecture des ordinateurs 15

mov eax, [esp] : cette instruction a pour rôle de mettre le contenu

Adressage indexé : dans ce cas l’opérande est une adresse

Abdelhafid MESSAOUDI Architecture des ordinateurs 16

Les opérations de transfère : ce sont des opérations qui s’effectuent

Les opérations arithmétiques

Les opérations logiques

Les opérations de décalage et de rotation.

Les opérations de branchement (saut conditionnel, saut

Les opérations sur les chaînes de caractères.

mov registre, mémoire

mov mémoire, registre

mov registre, registre