Programmation Assembleur 2019 DR Didier BASSOLE

Programmation en
Assembleur
Dr Didier BASSOLE
dbassole@univ--ouaga.bf
dbassole@univ
dbassole@gmail.com
Programmation en assembleur
Plan
Introduction
I. Microarchitecture du processeur
II.
II. Langage machine
III.
III. Langage assembleur
IV.. Instructions de base en assembleur x86

IV
Conclusion
Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 2

Programmation en assembleur
Objectifs du cours
À la fin de cette unité, vous devriez être capable de:
 Expliquer comment l'unité de commande d'un processeur interprète une

instruction au niveau machine, soit directement ou sous forme de
microprogramme;
 Expliquer le cycle de traitement des instructions par le processeur;
 Expliquer les jeux d’instructions de d’un processeur(Instruction Set
Architecture ou ISA) ;
 Apprécier les performances du système et les limites des architectures de
bas niveau ;
 Écrire des programmes en Assembleur x86
3
Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4
Introduction
Tous les langages de programmation dits « évolués » (« structurés »,
« orientés objet », etc.), qu'ils soient compilés ou interprétés
doivent d'une manière ou d'une autre être « traduits » en langage
machine avant de pouvoir être exécutés par un ordinateur.
Bien que ces langages ont un grand nombre d'atouts pour le

développement de logiciels complexes, en termes de conception,
de lisibilité, de portabilité et de maintenance, le revers de la
médaille est qu'ils masquent fortement sinon totalement, les
limitations de la machine.
Introduction
Ne pas avoir conscience de ces limitations peut pourtant avoir des
conséquences fâcheuses :
- En terme de performance, dans le cas d'une sous-exploitation des

capacités du processeur.
- En terme de fiabilité, dans le cas d'une surestimation des capacités

(programmes qui dysfonctionnent ou qui doivent être entièrement
réécrits dès que le cadre d'utilisation s'élargit).
Or, s'il est presque impossible d'écrire un programme conséquent

directement en langage machine, il est tout à fait possible de l'écrire en
« assembleur », qui n'en est qu'une version légèrement « humanisée ».
Introduction
Connaître les rudiments de la programmation en assembleur
peut donc donner des atouts considérables pour la
compréhension et la maîtrise de tous les autres langages de
programmation.
L'assembleur permet de contrôler directement le processeur.

Cela permet d'avoir une total maîtrise du système et surtout
il permet de faire des programmes rapides par rapport aux
langages de haut niveau.
Introduction
La programmation assembleur permet aussi de:
 mieux comprendre la façon dont fonctionne un

ordinateur;
 mieux comprendre comment fonctionnent compilateurs

et langages haut niveau


Le processeur
Le processeur ou microprocesseur est un circuit électronique complexe qui
exécute chaque instruction très rapidement, en quelques cycles
d’horloges. Toute l’activité de l’ordinateur est cadencée par une horloge
unique, de façon à ce que tous les circuits électroniques travaillent
ensembles.
La fréquence de cette horloge s’exprime en MHz ou GHz.
Pour chaque instruction, le processeur effectue schématiquement les
opérations suivantes:
1. Lire en mémoire l’instruction à exécuter ;
2. Effectuer le traitement correspondant ;
3. Passer à l’instruction suivante.
suivante.
9
Architecture schématique d’un ordinateur
Processeur Mémoire Principale
Unité de commande Codes

Programmes
instructions
Données
Unité de traitement binaires
Données
(U.A.L.)
informations
codées en binaire
Unité d’entrées / Sorties
Ecran
Clavier
10
Le processeur
Le processeur est le véritable cerveau de l’ordinateur. Toutes les
avancées technologiques se concentrent sur ce composant, qui
travaille toujours plus vite et effectue des opérations de plus en
plus compliquées.
Le rôle du processeur est d’exécuter les instructions composant le

programme. Il se charge de tous les calculs mathématiques et des
transferts de données internes et externes. Il décide de ce qui se
passe à l’intérieur de l’ordinateur.
Le processeur
Le processeur est caractérisé par son jeu d’instructions. Il s’agit de

l’ensemble des instructions reconnues par la machine.
Cet ensemble qui constitue le « vocabulaire » de la machine,

constitue l’interface entre le matériel et le logiciel. En effet, c’est ce
que le programmeur doit connaître afin de dicter à l’ordinateur, le
traitement qu’il souhaite lui faire exécuter.

Notion de micro architecture
La microarchitecture d'un processeur est un plan de ce processeur au
niveau logique
La couche de la microarchitecture se situe entre la couche logique
numérique (niveau 0) et la couche architecture du jeu d’instruction
(couche ISA)
Le rôle de la couche microarchitecture est l’exécution d’instructions
complexes et l’interprétation par un microprogramme (l’extraction
des instructions de la mémoire, le décodage des instructions et
l’exécution pas à pas)
Illustration de la couche microarchitecture

14
Jeu d’instructions du processeur
Le jeu d'instructions est l'ensemble des instructions machines qu'un
processeur d'ordinateur peut exécuter. Ces instructions machines
permettent d'effectuer des opérations élémentaires (addition, ET
logique…) ou plus complexes (division, passage en mode basse
consommation…).
Le jeu d'instructions définit quelles sont les instructions supportées par le

processeur. Le jeu d'instructions précise aussi quels sont les registres du
processeur manipulables par le programmeur (les registres
architecturaux).
Le jeu d’instruction précise non seulement les registres et instructions
supportées par le processeur, mais aussi la façon dont ces
instructions et les opérandes sont représentés en mémoire.
Chaque instruction machine contient un code qui indique l'instruction

à exécuter : addition, multiplication, branchement, etc.
On distingue plusieurs familles de jeux d'instructions, selon la façon

dont les instructions accèdent à leurs opérandes, leur codage et
leur complexité.
Les jeux d'instructions des processeurs diffèrent aussi dans la façon

dont sont spécifiés les opérandes des instructions.
D'autres processeurs peuvent avoir plus d'instructions.

Jeux d’instructions des processeurs CISC et RISC
Les processeurs généraux actuels se répartissent en deux grandes

catégories appelées CISC (Complex Instruction Set Computer) et
RISC (Reduced Instruction Set Computer).
Les processeurs de ces deux catégories se distinguent par la

conception de leurs jeux d'instructions.

Les processeurs CISC possèdent un jeu étendu d'instructions complexes.
Chacune de ces instructions peut effectuer plusieurs opérations

élémentaires comme charger une valeur en mémoire, faire une opération
arithmétique et ranger le résultat en mémoire.
Au contraire, les processeurs RISC possèdent un jeu d'instructions réduit où

chaque instruction effectue une seule opération élémentaire.
Le jeu d'instructions d'un processeur RISC est plus uniforme. Toutes les
instructions sont codées sur la même taille et toutes s'exécutent dans le
même temps (un cycle d'horloge en général).
L'organisation du jeu d'instructions est souvent appelé ISA

(Instruction Set Architecture)
La technologie CISC domine le marché des ordinateurs de bureau et

des ordinateurs portables.
La technologie RISC domine le marché des microprocesseurs

embarqués.

La répartition des principaux processeurs dans les deux catégories
est la suivante:
CISC RISC
Alpha (DEC)
ARM
S/360 (IBM)
PowerPC (Motorola)
VAX (DEC)
MIPS
68xx, 680x0 (Motorola)
PA-RISC (Hewlett-
x86, Pentium (Intel)
Packard)
SPARC
Cycle d’instruction
Un cycle d'instruction est le cycle de fonctionnement de base d'un
ordinateur. Il est le processus par lequel un ordinateur récupère une
instruction de programme à partir de sa mémoire, détermine les actions
que l'instruction exige, et réalise ces actions.
Le cycle d'instruction est exécuté séquentiellement : chaque instruction est

complètement traitée avant que la suivante ne soit démarrée.
Dans la plupart des processeurs modernes, le cycle d'instruction est exécuté

simultanément en parallèle (instruction pipeline).

Le processeur de chaque ordinateur peut avoir différents cycles en fonction
de différents jeux d'instructions, mais correspondra au cycle suivant :
Récupération de l’instruction (Fetching the instruction) : l’instruction est lue

en mémoire centrale et copiée dans le registre d’instruction (RI) du
processeur
A la fin de l'opération d'extraction, le registre PC (Program Counter) pointe

sur la prochaine instruction qui sera lue dans le cycle suivant.
Décodage de l’instruction (Decode) ; l’instruction est reconnue et interprété

par l’unité de décodage
Exécution de l’instruction (Execute): L'unité de commande du processeur transmet les
informations décodées comme une séquence de signaux de commande aux unités
fonctionnelles pertinentes de l'unité centrale de traitement pour exécuter les actions
requises par l'instruction, de les transmettre à l'unité arithmétique et logique pour
exécuter des fonctions mathématiques ou logiques sur eux, et écrit le résultat de
retour dans un registre.
Si l'unité arithmétique et logique est impliquée, il envoie un signal de condition de retour

à la CU. Le résultat généré par l'opération est stocké dans la mémoire principale ou
envoyée à un dispositif de sortie.
Sur la base de l'état de toutes les informations de l'unité arithmétique et logique, le

compteur de programme peut être mis à jour à une adresse différente à partir de
laquelle l'instruction suivante sera récupérée.
Stockage du résultat en mémoire si nécessaire : Si la destination est une
adresse mémoire, un cycle d'écriture mémoire est initié pour transférer le
résultat du processeur vers la mémoire.
En fonction de la situation, le processeur peut ou pas avoir à attendre jusqu'à

ce que cette opération se termine. Si la prochaine instruction n'a pas
besoin d’accéder à la cellule mémoire où le résultat est stocké, il peut
procéder à l'instruction suivante tandis que l'unité de mémoire effectue
l’opération d'écriture opération.
Le cycle est ensuite répété avec la récupération des instructions d'exécution

Familles de micro
micro--processeurs
Plusieurs familles de micro-processeurs:
 x86 (Intel, AMD) : PC et compatibles
 PowerPC (IBM) : équipent les Wii, PS3, XBox 360
 68x00 (Motorola)
 SPARC, MIPS, ARM, etc.

Cycle de fonctionnement de l'unité de contrôle
1 2
5
3
4 27
Le processeur x86
x86 : famille de microprocesseurs compatibles avec le jeu
d'instructions de l'Intel 8086
Évolution :
 début 80 : 8086, microprocesseur 16 bits;
 puis 80286, 80386, 80486, Pentium, etc.;
 augmentation de la fréquence d'horloge, et de la largeur des
bus d'adresses et de données;
 ajout de nouvelles instructions et registres;
 Compatibilité ascendante: un programme écrit dans le langage
machine du 286 peut s'exécuter sur un 386
28
Architecture interne du 8086

Les registres du processeur
Le processeur utilise toujours des registres, qui sont des petites mémoires
internes très rapides d’accès utilisées pour stocker temporairement une
donnée, une instruction ou une adresse. Chaque registre stocke 8, 16, 32
ou récemment 64 bits.
Ces zones sont très rapide d'accès puisqu'elles sont implantées dans le
microprocesseur lui-même et non dans la memoire vive.
Le nombre exact de registres dépend du type de processeur et varie

typiquement entre une dizaine et une centaine.
30
Les registres du processeur

Les régistres des processeurs intel se clasent en quatres(04)
catégories:
- les régistres généraux
- les régistres de segment
- les régistres d'offset
- les régistres des indicateurs

Les registres généraux
- AX (A pour accumulateur): joue le rôle d’opérande implicite dans

plusieurs opérations: MUL, DIV, INC, etc.
- BX (B pour Base): utilisé comme registre de base
- CX (C pour compteur): est utilisé pour les boucles (instruction LOOP).
- DX (D pour Data): utilisé dans les multiplications et divisions comme

registre d’extension.

Chacun de ces quatres registres (04) comportent 16 bits.
Les huits (08) bits de poids fort d'un registre sont appélés ”partie haute” et les
huits (08) autres ” partie basse”.
Chaque registre est en fait constitué de deux sous-registres de 8 bits.
En arithmétique non signée, il en découle la formule suivante:
AX = AH*256 + AL
BX = BH*256 + BL
CX = CH*256 + CL
DX = DH*256 + DL

Sur les PC relativement recents, AX, BX, CX, DX ne sont en fait que
des parties basses des registres de 32 bits nommées EAX, EBX,
ECX, EDX.
On distingue actuellement les registres LEAX, LEBX, LECX, LEDX,...

pour les processeurs 64 bits
On a donc un moyen plus pratique de stocker de grands nombres.

Les registres de segment

- CS (Code Segment): Pointe sur le segment qui contient le code du
programme.
- DS (Data Segment): Pointe sur le début du segment qui contient les
données
- ES (Extended Segment) : permet de pointer sur un segment
supplémentaire défini par le programmeur. Il se charge par
l’intermédiaire de AX, comme pour DS.
- SS (Stack Segment): segment contenant la pile.
Contrairement aux registres généraux, ces registres ne peuvent
servir pour les opérations courantes; ils ont un rôle très
précis.
Par ailleurs, on ne peut pas les utiliser aussi facilement que AX

ou BX et une petite modification de l'un peut reussir à faire
planter le système.

Les valeurs attribuées à ces registres lors du chargement en

mémoire d’un fichier exécutable diffèrent selon que le
fichier est un programme COM ou EXE.
37
Fichier COM = nom des fichiers de commandes DOS. Le contenu d'un
fichier COM est codé au format binaire et peut contenir jusqu'à 64 Ko de
code.
Les fichiers COM sont également classés comme des fichiers exécutables,
mais contrairement aux fichiers EXE, il n'y a pas de détails sur les
métadonnées ou les en-têtes de fichier joint à un fichier COM.
Le contenu d'un fichier COM se compose généralement de directives ou
de commandes utilisées par les ressources DOS intégrés pour effectuer
certaines opérations.
38
Les valeurs attribuées à ces registres lors du chargement en mémoire d’un fichier
exécutable diffèrent selon que le fichier est un programme COM ou EXE.
Registres Valeur avant exécution

Fichier COM Fichier EXE
Adresse de l’unique segment, c’est-à-dire Adresse du segment de code
CS adresse de segment du PSP
Adresse de l’unique segment, c’est-à-dire Adresse de segment du PSP
DS adresse de segment du PSP
Adresse de l’unique segment, c’est-à-dire Adresse de segment du PSP
ES adresse de segment du PSP
Adresse de l’unique segment, c’est-à-dire Adresse de segment de pile
SS adresse de segment du PSP
39
40
TITLE nom ; donner un nom au programme
PILE SEGMENT STACK ; déclaration d’un segment de pile
; dont le nom est pile
..........
..........
PILE ENDS ; fin de la déclaration de la pile
DONNEE SEGMENT ; déclaration d’un segment de données qui va
; contenir les variables
...........
DONNEE ENDS ; fin de la déclaration de données
CODE SEGMENT ; déclaration du segment de code qui va contenir
; le code
Debut: ; étiquette d’indication du point d’entrée du code
.................................
CODE ENDS ; fin de la déclaration du code
END Debut ; fin du point d’entrée du code
Les registres d’offset
- IP (Instruction pointeur): contient l’adresse de l’instruction qui suit celle qui est en
cours d’exécution.
- SI (Source Index): souvent utilisé comme pointeur sur une adresse mémoire (exemple:
MOV AL, [SI]). Il est très utilisée avec les instructions de traitement de chaînes de
caractères.
- DI (Destination Index): pareil que SI.

- BP (base pointeur): sert de pointeur sur la base de la pile, et permet d’atteindre
n’importe quel élément de la pile (exple: MOV AX,[BP+2]).
- SP (Stack pointer): pointe sur le sommet de la pile; son contenu est automatiquement
changé par les instructions PUSH et POP.

Les registres d’offset
Le registre IP désigne l’offset de la prochaine instruction à exécuter,
par rapport au segment adressé par CS. La combinaison de ces
deux registres (CS:IP) suffit donc à connaître l’adresse absolue de
cette instruction. Le processeur peut alors aller la chercher en
mémoire et l’exécuter.
De plus, il actualise IP en l’incrémentant de la taille de l’instruction en
octets. Tout comme CS, il est impossible de modifier IP
directement.

Les registres des indicateurs
Ils sont utilisés pour sauvegarder des états particuliers du
microprocesseur en référence à la dernière instruction exécutée.
En effet, un programme doit pouvoir faire des choix en fonction des
données dont il dispose. Pour cela, il lui faut par exemple, comparer
des nombres, examiner leur signe, découvrir si une erreur a été
constatée...
Les indicateurs(flags) sont en fait des bits spéciaux ayant une
signification très précise. Ils sont tous regroupés dans un registre.

En mode réel, certains flags ne sont pas accessibles.
Principaux indicateurs
indicateurs::
- CF (« Carry Flag ») est l’indicateur de retenue. Il est positionné à 1 si et seulement
si l’opération précédemment effectuée a produit une retenue. De nombreuses
fonctions du DOS l’utilisent comme indicateur d’erreur : CF passe alors à 1 en cas
de problème.
- PF (« Parity Flag ») renseigne sur la parité du résultat. Il vaut 1 ssi ce dernier est
pair.
- AF (« Auxiliary Carry Flag ») est peu utilisé.
- ZF (« Zero Flag ») passe à 1 ssi le résultat d’une opération est égal à zéro.
- SF (« Sign Flag ») passe à 1 ssi le résultat d’une opération sur des nombres signés
est négatif.
Principaux indicateurs:
indicateurs:
- TF (« Trap Flag ») est utilisé pour le « débuggage » d’un programme. S’il vaut 1, une
routine spéciale du débuggeur est appelée après l’exécution de chaque instruction
par le processeur.
- IF (« Interrupt Flag ») sert à empêcher les appels d’interruptions lorsqu’il est positionné
à 1.
- DF (« Direction Flag ») est utilisé pour les opérations sur les chaînes de caractères. S’il
vaut 1, celles-ci seront parcourues dans le sens des adresses décroissantes, sinon les
adresses seront croissantes.
- OF (« Overflow Flag ») indique qu’un débordement s’est produit, c’est-à-dire que la
capacité de stockage a été dépassée. Il est utile en arithmétique signée. Avec des
nombres non signés, il faut utiliser ZF et SF.
46
La pile
NB:
Les registres SS et SP sont deux registres servant à gérer la pile:
SS est un registre 16 bits contenant l'adresse du segment de pile

courant.
Il doit être initialisé au début du programme
SP est le déplacement pour atteindre le sommet de la pile (16 bits de

poids faible).

La pile
SP pointe vers le sommet, c'est-à-dire sur le dernier bloc occupé de la
pile. Lorsque l'on ajoute un élément à la pile, l'adresse contenue
dans SP est décrémentée de 2 octets (car un emplacement de la
pile fait 16 bits de longueur).
En effet, lorsque l'on parcourt la pile de la base vers le sommet, les
adresse décroissent.
Par contre l'instruction POP incrémente de 2 octets (16 bits) la valeur
de SP.

La pile
- PUSH: SP <- SP - 2
- POP: SP <- SP + 2
Ainsi, lorsque la pile est vide SP pointe sous la pile (la case mémoire
en-dessous de la base de la pile) car il n'y a pas de case occupée. Un
POP provoquera alors une erreur...

Déclaration d’une pile

Pour pouvoir utiliser une pile, il faut la déclarer, c'est-à-dire réserver
un espace mémoire pour son utilisation, puis initialiser les
registres avec les valeurs correspondant à la base de la pile, ainsi
que son sommet (rappel: situé sous la pile lorsque celle-ci est
vide).
Ainsi pour définir une pile, il s'agit tout d'abord de la déclarer grâce à
la directive SEGMENT stack.

Déclaration d'une pile

Pour utiliser une pile en assembleur, il faut déclarer un segment de pile, et y réserver un
espace suffisant. Ensuite, il est nécessaire d'initialiser les registres SS et SP pour
pointer sous le sommet de la pile. Voici la déclaration d'une pile de 200 octets :
segment_pile SEGMENT stack ;mot clef stack pour pile
DW 100 dup (?) ; réserve espace
base_pile EQU this word ; etiquette base de la pile
segment_pile ENDS
Afin d'initialiser SP, il faut repérer l'adresse du bas de la pile; c'est le rôle de la ligne
base_pile EQU this word .
Déclaration d'une pile

La pile
Suite aux déclarations, il faut écrire une séquence d'initialisations:
ASSUME SS:segment_pile ; génère une adresse pour l’emplacement de la
pile
MOV AX, segment_pile
MOV SS, AX ; initialise le segment de pile
MOV SP, base_pile ; copier l'adresse de la base de la pile dans SP
Remarquez qu’il n'est pas possible de faire directement MOV SS,

segment_pile car cette instruction n'existe pas!
II. Langage Machine

II. Langage Machine
Introduction
L’ordinateur ne comprend que le binaire. On l’appelle le langage machine.
Le langage machine est le langage directement compréhensible par le

processeur ou le microprocesseur.
L'ordinateur ne manipulant que des suites de 0 et de 1, les instructions du

langage machine sont exprimées en binaire.
Dans les premiers temps de l'informatique, le langage machine était le seul

disponible.

II. Langage Machine
Définition
Le langage machine est une suite de bits, interprétée par le processeur de
l’ordinateur lors de l’exécution d’un programme.
Pour le langage machine, les mots sont des suites de bits qui représentent
des instructions ou des données.
Les suites de bits sont organisées par champs pour former les instructions.
Pour tout processeur il existe un langage machine caractéristique (langage

natif). Même s’il existe une compatibilité entre processeurs de la même
famille.
II. Langage Machine
Programme en langage machine
Un programme en langage machine est une suite d'instructions-

machine.
Une instruction-
instruction-machine est une suite de bits qui contient toutes les
informations nécessaires à l'exécution de l'instruction.
D'un point de vue logique, c'est-à-dire du point de vue du

programmeur, le microprocesseur va exécuter chaque instruction
les unes après les autres ( mais il peut avoir des ruptures).

II. Langage Machine
Inconvénients du langage machine
L’utilisation du langage machine par l'homme se heurte à de nombreux
inconvénients dont :
- la faible lisibilité d'où la difficulté d'écrire et de mettre au point des
programmes,
- La pauvreté de l’expression: il y a un trop grand écart entre les instructions
d'un langage machine et les problèmes à traiter.
- La non unicité du langage : à chaque processeur correspond son langage
machine.
Ce constat à conduit au développement du deuxième niveau de langage : le
langage assembleur.
III. Langage Assembleur

Définition::
Définition
Le langage assembleur est un langage de bas niveau représentant le
langage machine sous une forme « humanisée » c’est-à-dire sous une
forme lisible et compréhensible par un être humain.
Les instructions s'écrivent sous la forme «mnémonique

suite_d'opérandes » où la mnémonique est un mot qui rappelle le
rôle de l'instruction.
Assemblage = Transformation du code assembleur en code machine

Caractéristiques du langage assembleur
Les langages assembleurs ou langages machine symboliques se

caractérisent donc par l'utilisation de codes mnémoniques en vue
d'améliorer la lisibilité des programmes.
Pour être exécuter par l'ordinateur, les programmes écrits en langage

assembleur sont au préalable traduits en langage machine. Cette
traduction est réalisée automatiquement par un programme appelé
assembleur.
assembleur

Il demeure néanmoins qu'un langage assembleur reste lié à

un type de machine et qu'il ne permet pas de combler
aisément le fossé entre les instructions reconnues par
celle-ci et les problèmes à traiter.

Format des instructions
La plus simple instruction, opcode, est connue comme le code de la machine et est
exécutée directement par le CPU.
Une instruction est l'opération élémentaire que le processeur peut accomplir. Les
instructions sont stockées dans la mémoire principale, en vue d'être traitée par
le processeur.
Une instruction est composée de deux champs :
 Le code opération (opcode), représentant l'action que le processeur doit
accomplir ;
 Le code opérande, définissant les paramètres de l'action. Le code opérande
dépend de l'opération. Il peut s'agir d'une donnée ou bien d'une adresse
mémoire.
Format des instructions
La représentation du format des instructions est fixée une fois pour toutes
par le jeu d'instructions du processeur.
Le format d’instruction précise quel opcode correspond à telle ou telle

instruction, quels sont les opérandes permises, quels sont les modes
d'adressage possibles pour chaque instruction, etc.
Exemple d’une instruction MIPS32 détaillée

Caractéristiques et avantages :
L’assembleur est un langage ayant les caractéristiques suivantes:
- Langage textuel (au lieu de binaire) avec la correspondance : une instruction en
assembleur une instruction en langage machine.
- Séparation données/instructions.
- Pas de nécessité de manipuler des adresses réelles, on ne connait pas les adresses
des données, du programme!
Avantages :
- Lisibilité du code
- Niveau de langage plus facile à manipuler par rapport au langage machine

Notion de programme en assembleur
assembleur::
L'assembleur permet simplement de rendre le langage machine un

peu plus lisible :
Chaque ligne d'assembleur contient une seule instruction, l'adresse

d'une instruction est essentiellement constituée par son numéro
de ligne.
Le programmeur peut donner des noms aux adresses importantes

pour lui.

Notion de programme en assembleur:
assembleur:
Un programme écrit en langage d'assemblage doit subir un certain nombre de
transformations avant de pouvoir être exécuté.
La première phase de traitement est l'assemblage (NASM, MASM, TASM...). Le

programme source est traduit en langage machine et le programme objet ainsi
obtenu est rangé dans un fichier.
La seconde phase de traitement est l’édition des liens c’est-à-dire la liason entre
différents codes machines pour la création de l’exécutable.
La troisième phase du traitement est l'exécution du programme proprement dite

qui peut utiliser des données et qui produit des résultats.

assembleur::
Exemple 1:
1 BITS 32
2 EXTERN puts
3 SECTION .data
4 chaine db "Hello world !", 0
5 SECTION .text
6 GLOBAL main
7 main:
8 push dword chaine
9 call puts
10 add esp, 4
11 ret
assembleur::
Exemple 2:
1 SECTION .test
2 global _start
3 _start:
4 MOV EDX, len
5 MOV ECX, msg
6 MOV EBX, 1
7 MOV EAX, 4
8 INT 80h
9 SECTION .data
10 msg DB ’Bonjour Parcours Infos S4’ , 0Ah
11 len EQU $ - msg
Structure générale d’un programme en assembleur
Les SECTIONS = Segments de notre futur exécutable. Nous utilisons

ici les sections .data et .text.
.data est utilisée pour les données initialisées. C'est à dire, les
données qui doivent avoir une valeur précise au lancement du
programme.
Dans cet exemple, c'est la chaine de caractère que nous stockons.
.text contient le code de notre exécutable.

Le mot EXTERN permet de spécifier une fonction qui se trouve en
fait à l'extérieur de notre source.
GLOBAL permet de spécifier les symboles qui seront utilisables

depuis l'extérieur.
Nous devons ici déclarer puts en EXTERN car il sera utilisé par notre
programme.
main est déclaré en GLOBAL car il sera appelé par le système : c'est
le point d'entrée du programme (comme en C).

Avec le fonctionnement par défaut, main n’est qu’une fonction
comme les autres.
Le main de l’exemple 1 remplacé par _start ( le point d’entrée réel

de l’exécutable)dans l’exemple 2;
Le ret est remplacé par: { MOV EAX,4 | INT 80h}

Déclaration de variables
Les variables se déclarent de la manière suivante:
 donnée1 db ? ; donnée1 est un byte non initialisé
 donnée2 db 0FFh ; donnée2 est un byte initialisé à FF (255 en

hexadécimal)
 donnée3 dw ? ; donnée3 est un word (16 bits)
 donnée4 db 5 dup (?) ; donnée4 est un tableau de 5 bytes non initialisés
 donnée5 dw 10 dup (15) ; datas5 est un tableau de 10 byte initialisés à 15

Déclaration de variables en assembleur
De manière générale:
DB : 1 byte (8 bits) (Declare Byte)
DW : 1 word (16 bits) (Declare Word)
DD : 2 words (32 bits) (Declare Double)
DF,DP : 6 bytes (Define Far Pointer)
DQ : 8 bytes (64 bits) (Define Quadword)
DT : 10 bytes (Define Ten bytes)
Les constantes peuvent être écrites en:
- décimal : 1, 2, 3, 123, 45
- hexadécimal : 1h,2h,3h,12h,0Fh,0AD4h (noter la présence du 0 quand le premier
chiffre du nombre en hexadécimal commence par une lettre)
- binaire : 1b,0b,1010b,111101b 75
Les Entrés / Sorties en assembleur
Pour réaliser les opérations standards (affichage, saisie), le système d’exploitation (ici
DOS) fournit les fonctions pré-écrites suivantes:
 Affichage d’un caractère : mov DL, “A” ; caractère A est transféré dans DL
mov AH, 2 ; fonction no. 2
int 21h ; appel au DOS
 Affichage d’une chaine de caractères:
mov DX, offset chaine ; pointe vers l’adresse du premier caractère de la
; de la chaîne de caractères chaine
mov AH, 09h ; fonction no. 9
int 21h
 Saisie d’un caractère : mov AH, 1 ; fonction no. 1
(avec écho) int 21h ; résultat est mis dans AL
Notion de procédures - fonctions
En langage assembleur, on appelle procédure un sous-programme qui
permet d'effectuer un ensemble d'instructions par simple appel de la
procédure.
Les fonctions et les procédure permettent d'exécuter dans plusieurs parties

du programme une série d'instruction, cela permet une simplicité du code
et donc une taille de programme minimale. D'autre part, une procédure
peut faire appel à elle-même, on parle alors de procédure récursive (il ne
faut pas oublier de mettre une condition de sortie au risque sinon de ne
pas pouvoir arrêter le programme...).
Déclaration d'une procédure
Elle se fait en utilisant des mots clés:
- une étiquette (qui représente le nom de la fonction) précédant le mot clef
PROC marquant le début de la procédure, suivi de near (qui signale que
la procédure est située dans le même segment que le programme
appelant) ,
- RET désignant la dernière instruction,
- ENDP qui annonce la fin de la procédure.
Ainsi une déclaration de procédure ressemble à ceci:

Déclaration d'une procédure
Etiquette PROC near
instruction1
instruction2
.....
RET
Etiquette ENDP

Appel d'une procédure :
C'est l'instruction CALL qui permet l'appel d'une procédure. Elle est
suivie soit d'une adresse 16 bits, désignant la position du début de
la procédure, ou bien du nom de la procédure (celui de l'étiquette
qui précède le mot clé PROC).


Fonctionnement de l'appel et de la fin d’une procédure:
procédure:
Lorsque l'on appelle une procédure, la première adresse de la procédure est
stocké dans le registre IP (pointeur d’instruction), le processeur traite
ensuite toutes les lignes d'instructions jusqu'à tomber sur le mot clé RET,
qui va remettre dans le registre IP l'adresse qui y était stocké avant l'appel
par PROC.
Cela paraît simple mais le problème provient du fait que les procédures
peuvent être imbriqués, c'est-à-dire que de saut en saut, le processeur
doit être capable de revenir successivement aux adresses de retour.

Fonctionnement de l'appel et de la fin d’une procédure:

procédure:
En fait, à chaque appel de fonction via l'instruction CALL, le
processeur empile l'adresse contenue dans le registre IP (il pointe
alors sur l'instruction suivant l'instruction CALL) avant de la
modifier, à l'appel de l'instruction RET (qui ne prend pas
d'arguments) le contenu de la pile est dépilé puis stocké dans le
registre IP.

IV. Instructions de bases en
Assembleur

IV. Intructions de bases en Assembleur
Opérations courantes
Affectations
; Registres <-- Valeurs
MOV AX, 65535 ; (décimal)
MOV Cl, 01101b ; (binaire)
MOV DH, 0FAh ; (hexa)
; Entre registres
MOV AX, BX
MOV CL, DH

Affectations
; Entre Registres et Variables
MOV CX, variable ; variable de deux octets
MOV variable, DL ; variable d'un octet
;Registres <-- Adresses Mémoire

Mov AX, Offset variable ; AX <- adresse de variable
Mov CX, [ 5Ah ] ; CX <- valeur à l'adresse 5A en hexa

Arithmétique
; Incrémentation
INC AX ; AX <- AX + 1
Inc variable ; variable <- variable + 1
; Décrémentation
DEC AX ; AX <- AX - 1
Dec variable ; variable <- variable - 1

Arithmétique
; Addition
ADD AX, 5 ; AX <- AX + 5
ADD BH, toto ; BH <- BH + toto
Add toto, Cx ; toto <- toto + Cx
; Soustraction
SUB AX, 5 ; AX <- AX – 5
SUB BH, toto ; BH <- BH – toto
SUB toto, CX ; toto <- toto - CX

Exemple 1:
1
x=a+b–c Mov AX, a
ADD AX, b
sub AX, c
Mov x, AX
Exemple 1:
Code C Assembleur
x=a-b+c ; instruction x = a - b + c
y=d–x Mov AX, a
z=x+y SUB AX, b
ADD AX, c
Mov x, AX
; instruction y = d - x
Mov BX, d
SUB BX, x
Mov y, BX
; instruction z = x +y
Mov tmp, x
ADD tmp, y
Mov z, tmp
91
if . . . else Assembleur
if (ax ==1 ) If: CMP AX, 1
bx = 10; JNZ Else
else {
bx = 0; Then: MOV BX,10
cx = 10; JMP endif
} Else: MOV BX,0
MOV CX,10
endif: ..............

La boucle for Assembleur
bx = 0; MOV BX,0
for (k=0;k<=10; k++) MOV CX,0
bx = bx + k; For: CMP CX,10
JA Endfor
ADD BX,CX
INC CX
JMP For
Endfor:
La boucle while... Assembleur
bx = 5 MOV BX,5
while (bx >0) while: CMP BX,0
bx = bx -1; JLE Endwhile
DEC BX
JMP while
Endwhile:
La boucle do . . . while Assembleur
bx = 10 ; MOV BX,10
do Repeat1: DEC BX
{ CMP BX,0
bx = bx – 1 ; JG Repeat1
} Endrepeat1 :
while(bx
while(bx > 0) ;
Si le nombre de répétitions est connu et au moins égal à 1, on pourra procéder comme

suit::
suit
MOV BX, 0
MOV CX, 0Ah
Repeat2:
ADD BX, CX
LOOP Repeat2; LOOP décrémente automatiquement CX jusqu’à atteindre 0
EndRepeat2:
switch... Assembleur
switch (n) { CMP n,1
case 1: ....; break; JNE case2
case 2: .....; break; ............
default: .....; JMP endswitch
} case2: CMP n,2
JNE default
..........
JMP endswitch
default: ...........
endswitch: ...........
Écrire le code de l’instruction En assembleur
if ((a>b) && (c <= d)) if: cmp a, b
{ jng endif
................ cmp c,d
} jnle endif
…………………
endif:
Exercice: coder en assembleur les instructions suivantes:

1. if ((a >b) || (c > d)) 2. for (i=1; i < 10; i++)
{ ...} { ...}

Pour les instructions relatives à la gestion de la

conditionnelle (saut conditionnel), voir polycopié

Conclusion

Programmation Assembleur 2019 DR Didier BASSOLE

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programmation Assembleur 2019 DR Didier BASSOLE

Transféré par

Droits d'auteur :

Formats disponibles

Programmation en

IV.. Instructions de base en assembleur x86

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 2

 Expliquer comment l'unité de commande d'un processeur interprète une

Bien que ces langages ont un grand nombre d'atouts pour le

- En terme de performance, dans le cas d'une sous-exploitation des

- En terme de fiabilité, dans le cas d'une surestimation des capacités

Or, s'il est presque impossible d'écrire un programme conséquent

L'assembleur permet de contrôler directement le processeur.

 mieux comprendre la façon dont fonctionne un

 mieux comprendre comment fonctionnent compilateurs

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 7

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 8

Processeur Mémoire Principale

Unité de commande Codes

Unité d’entrées / Sorties

Le rôle du processeur est d’exécuter les instructions composant le

Le processeur est caractérisé par son jeu d’instructions. Il s’agit de

Cet ensemble qui constitue le « vocabulaire » de la machine,

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 12

Illustration de la couche microarchitecture

Le jeu d'instructions définit quelles sont les instructions supportées par le

Chaque instruction machine contient un code qui indique l'instruction

On distingue plusieurs familles de jeux d'instructions, selon la façon

Jeu d’instructions du processeur

Les jeux d'instructions des processeurs diffèrent aussi dans la façon

D'autres processeurs peuvent avoir plus d'instructions.

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 17

Jeux d’instructions des processeurs CISC et RISC

Les processeurs généraux actuels se répartissent en deux grandes

Les processeurs de ces deux catégories se distinguent par la

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 18

Chacune de ces instructions peut effectuer plusieurs opérations

Au contraire, les processeurs RISC possèdent un jeu d'instructions réduit où

L'organisation du jeu d'instructions est souvent appelé ISA

La technologie CISC domine le marché des ordinateurs de bureau et

La technologie RISC domine le marché des microprocesseurs

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 20

Le cycle d'instruction est exécuté séquentiellement : chaque instruction est

Dans la plupart des processeurs modernes, le cycle d'instruction est exécuté

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 22

Récupération de l’instruction (Fetching the instruction) : l’instruction est lue

A la fin de l'opération d'extraction, le registre PC (Program Counter) pointe

Décodage de l’instruction (Decode) ; l’instruction est reconnue et interprété

Si l'unité arithmétique et logique est impliquée, il envoie un signal de condition de retour

Sur la base de l'état de toutes les informations de l'unité arithmétique et logique, le

En fonction de la situation, le processeur peut ou pas avoir à attendre jusqu'à

Le cycle est ensuite répété avec la récupération des instructions d'exécution

Plusieurs familles de micro-processeurs:

 x86 (Intel, AMD) : PC et compatibles

 PowerPC (IBM) : équipent les Wii, PS3, XBox 360

 SPARC, MIPS, ARM, etc.

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 26

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 29

Le nombre exact de registres dépend du type de processeur et varie

Les registres du processeur

- les régistres généraux

- les régistres de segment

- les régistres d'offset

- les régistres des indicateurs

Didier BASSOLE dbassole@gmail.com Prog_ASM_P_Info_S4 31

- AX (A pour accumulateur): joue le rôle d’opérande implicite dans

- BX (B pour Base): utilisé comme registre de base