Mic Presentation

Microprocesseurs
MIC2-MIC
J. Beleho (bej) A. Hallal (hal) (*) . . . Et tous les précédents . . .
Haute école de Bruxelles-Brabant

École Supérieure d’Informatique
Année académique 2020 / 2021
(HE2B - ÉSI) Microprocesseurs 2020 – 2021 1 / 290

Liste des séances
1 Objectifs, évaluation et introduction
2 Ouvrons le PC
3 Microprocesseurs : Fonctionnement
4 Interruptions
5 Mode réel et mode protégé
6 Langage d’assemblage
7 Les modes d’adressage
8 Le codage des instructions assembleur x86 64 bits

Objectifs, évaluation et introduction
Séance 1
Objectifs, évaluation et introduction
Objectifs du cours Supports-Ressources

Évaluation

Notre objectif · · · · · · votre objectif
Crédit photo
Objectifs, évaluation et introduction Objectifs du cours
Objectifs du cours
Comprendre le microprocesseur :
I Ce qu’on y trouve ;
I Comment il fonctionne ;
I Les liens avec les autres composants ;
I Sa programmation (son jeu d’instructions) ;
I Son évolution.
Remarque : Nous nous concentrerons que sur les

microprocesseurs de la famille x86.

Objectifs, évaluation et introduction Supports-Ressources
Supports et ressources
I pas de livre ;
I mais ....
I des slides, des liens, des documents. . . sur poÉSI ;
Remarque : Les slides sont une structure du cours et pas

un contenu (pas un syllabus). Il est donc indispensable de
compléter les slides avec les explications fournies au cours.

Objectifs, évaluation et introduction Évaluation
Évaluation de l’UE MIC2
Une cote pour toutes les activités d’apprentissage (AA) :
MIC2
z }| {
MIC - MICL

Ouvrons le PC
Séance 2
Ouvrons le PC
La Carte Mère La Mémoire Cache

Ouvrons le PC La Carte Mère
Schéma Carte mère PC à microprocesseur :

Ancienne Génération

Schéma Carte mère PC à microprocesseur :

Nouvelle Génération (2018)

Carte Mère

Rôle de la carte mère
La carte mère est le coeur de tout ordinateur. Elle est

essentiellement composée de circuits imprimés et de ports
de connexion, par le biais desquels elle assure la connexion
de tous les composants et périphériques propres à un
micro-ordinateur (disques durs, mémoire vive,
microprocesseur, cartes filles, etc.) afin qu’ils puissent être
reconnus et configurés par la carte lors du démarrage.

Structure de la carte mère

I Les connecteurs électriques
I Le support processeur (ou socket en anglais)
I Le chipset : Celui-ci se divise en deux parties
distinctes à savoir le northbridge et le
southbridge.
I Les bus
I Les slots mémoire
I Les slots d’extension
I Les connecteurs de stockage
I Le panneau d’entrées/sorties
Carte Multiprocesseur
Une carte multiprocesseur peut accueillir plusieurs

processeurs physiquement distincts. Elles sont
principalement utilisées dans les architectures serveur ou
les superordinateurs.

Carte Multiprocesseur

Ouvrons le PC La Mémoire Cache
La Mémoire cache
La mémoire cache (également appelée antémémoire ou
mémoire tampon) est une mémoire rapide permettant de
réduire les délais d’attente des informations stockées en
mémoire vive.
En effet, la mémoire centrale de l’ordinateur possède une
vitesse bien moins importante que le processeur. Il existe
néanmoins des mémoires beaucoup plus rapides, mais dont
le coût est très élevé.
La solution consiste donc à inclure ce type de mémoire
rapide à proximité du processeur et d’y stocker
temporairement les principales données devant être
traitées par le processeur.
La Mémoire cache
Les ordinateurs récents possèdent plusieurs niveaux de

mémoire cache :
I La mémoire cache de premier niveau (appelée L1
Cache, pour Level 1 Cache) est directement intégrée

dans le processeur.
I La mémoire cache de second niveau (appelée L2
Cache, pour Level 2 Cache) est située au niveau du

boîtier contenant le processeur (dans la puce).

La Mémoire cache
I La mémoire cache de troisième niveau (appelée L3

Cache, pour Level 3 Cache) autrefois située au
niveau de la carte mère (utilisation de la mémoire
centrale), est aujourd’hui intégré directement dans le
CPU.
Tous ces niveaux de cache permettent de réduire les
temps de latence des différentes mémoires lors du
traitement et du transfert des informations.

Microprocesseurs : Fonctionnement
Séance 3

Microprocesseur 64 bits : Schéma simplifié

Microprocesseur : Fonctionnement de base
I Le microprocesseur (MPU, Micro-Processing Unit)

élément de base, est un circuit intégré à très grande
échelle d’intégration (VLSI) capable d’exécuter
automatiquement des instructions (opérations
élémentaires) qu’il ira chercher dans la mémoire.
I Il remplit donc les fonctions d’une unité centrale de
traitement (CPU, Central Processing Unit) en un seul
boîtier.

Microprocesseur : Fonctionnement de base
I Toutes les informations qu’utilise le microprocesseur

sont stockées dans des mémoires, en particulier le
programme. Le fonctionnement du microprocesseur
est entièrement conditionné par le contenu de
celles-ci.
I Ces mémoires contiennent deux types
d’informations : le programme et les données
nécessaires pour la réalisation d’une tâche précise.

Microprocesseur : Les composantes

Le microprocesseur est constitué des unités fonctionnelles
suivantes :
I Unité Arithmétique et Logique (ALU en anglais) ;
I des registres : RAX, RBX, RCX, RDX, . . .
I une unité de contrôle (UC ou CU ) dans laquelle on

trouve :
RIP ou Compteur de programme (PC) ;
Incrémenteur(+) ;
Registre Instruction (RI) ;
Décodeur ;
Séquenceur ;

Microprocesseur : Les composantes
Autres composants :
I Horloge
I Bus de données
I Bus d’adresses ;
I Mémoire (RAM)

Code machine et instructions
I 0x0102030405060708 : adresse sur 64 bits ;

I 0x480556341200 : instruction (add rax,0x123456) ;
I 0x4801D8 : instruction (add rax,rbx) ;
I 0x4801B48A34120000 :
instruction ( add[rcx*4 + rdx + 0x1234],rsi )

Fonctionnement : Introduction
I Le programme est une suite d’instructions stockées

dans la mémoire.
I Pour exécuter ces instructions de manière
séquentielle, le microprocesseur utilise le registre
RIP, appelé compteur de programme (appelé aussi
compteur ordinal ou pointeur d’instruction).
I Ce registre contient l’adresse de la prochaine
instruction à être exécutée.

Fonctionnement : Jeu d’instructions

I Les microprocesseurs sont capables d’effectuer un
certain nombre d’opérations élémentaires.
I Cet ensemble d’opérations élémentaires est appelé jeu
d’instructions.
I Une instruction au niveau machine doit fournir à
l’unité centrale toutes les informations nécessaires
pour déclencher une telle opération élémentaire.
I Elle comporte en général plusieurs champs : le
premier champ contient le code de l’opération
(Code-Op ou Op-Code en anglais) ; les autres champs
peuvent comporter des données ou l’identificateur des
opérandes.
Fonctionnement : Cycle d’exécution d’une

instruction
I Lors de son exécution, une instruction est

décomposée en mini-opérations élémentaires.
I Celles-ci sont généralement au nombre de trois :
Recherche de l’instruction (FETCH) ;
Décodage (DECODE) ;
et Exécution (EXECUTE).

Fonctionnement : Cycle d’exécution d’une

instruction
I Ces micro-opérations (Fetch, Decode, Execute) sont

cadencées au rythme d’horloge qui pilote le
séquenceur.
I La durée de traitement d’une instruction s’appelle
cycle d’instruction ou cycle machine.
I Le nombre de périodes d’horloge nécessaires à
l’exécution d’une instruction dépend de l’architecture
du processeur et du mode d’adressage.

Cycle d’exécution d’une instruction : Fetch

I Le contenu de RIP (compteur de programme - PC)
est placé sur le bus des adresses (c’est l’unité de
contrôle qui établit la connexion).
I L’unité de contrôle (UC) émet un ordre de lecture de
la case mémoire dont le contenu sera ensuite
acheminé à travers le bus de données au registre
instruction (RI).
Remarque : Dès la mise sous tension ou après un RESET,
le compteur de programme (PC) est initialisé par une
valeur (adresse) fixée par le constructeur du
microprocesseur. C’est l’adresse du début de programme.
Cycle d’exécution d’une instruction :

Decode
I Le registre d’instruction (RI) contient maintenant le

code opératoire.
I L’unité de contrôle décode le contenu de RI pour
savoir la nature de l’opération à effectuer (addition,
rotation, multiplication, . . . ) et incrémente le
compteur ordinal (PC) RIP pour pointer sur la
prochaine instruction à exécuter.

Cycle d’exécution d’une instruction :

Execute
I Le cycle d’exécution varie en fonction de

l’architecture et du type de l’instruction.
I Mais d’une manière générale c’est l’ALU qui exécute
l’instruction en cours et positionne les indicateurs du
registre d’état.

Déroulement d’un process - Exemple1
On considère le process représenté par le bout de code

assembleur suivant :
MOV EAX, 33
ADD EAX,ECX
Code machine : B82100000001C8
On suppose au départ que EAX contient 17, EBX contient

19 et ECX contient 15. Le contenu des autres registres est
inconnu.


Exemple1 : B82100000001C8
Exécution de la première instruction (MOV EAX,33 ≡

B821000000)
I FECTH :
(1) : La porte (1) s’ouvre l’adresse contenu dans RIP

circule sur le bus d’adresses. La RAM fournit la donnée
qui se trouve à cette adresse.
(2) : Les portes (2) s’ouvrent ; l’instruction qui se
trouvaient à l’adresse (0x10...84) se retrouve dans le
registre d’instructions RI en passant par le bus de
données.

Exemple1 : B82100000001C8
I DECODE :
(3) : Le décodeur (couplé avec le registre d’instruction
RI) décode l’instruction. Il s’agit d’un MOV sur 5 bytes.
Les portes (3) s’ouvrent ; RIP s’incrémente de 5 bytes et
vaut (0x10...89).
I EXECUTE : L’instruction est une affectation de 33
dans le registre EAX.
(4) : Les portes (4) s’ouvrent ; la donnée 33 circule dans
le bus de données vers l’ALU et le contenu du registre
EAX est écrasé par la valeur 33.
(5) : Fin de la première instruction.


Exemple1 : B82100000001C8
Exécution de la deuxième instruction (ADD EAX,ECX ≡

01C8)
I FECTH :
(6) : La porte (1) s’ouvre l’adresse contenu dans RIP

circule sur le bus d’adresses. La RAM fournit la donnée
qui se trouve à cette adresse.
(7) : Les portes (2) s’ouvrent ; l’instruction qui se
trouvaient à l’adresse (0x10...89) se retrouve dans le
registre d’instructions RI en passant par le bus de
données.

Exemple1 : B82100000001C8
I DECODE :
(8) : Le décodeur (couplé avec le registre d’instruction
RI) décode l’instruction. Il s’agit d’un ADD sur 2 bytes.
Les portes (3) s’ouvrent ; RIP s’incrémente de 2 bytes et
vaut (0x10...8B).
I EXECUTE : L’instruction est une addition du
contenu de ECX avec et dans celui de EAX.
(9) : Les portes (4) s’ouvrent ; la donnée (qui ici est une
instruction) circule dans le bus de données vers l’ALU qui
effectue l’addition. Le contenu du registre EAX est
écrasé par la valeur du résultat de l’opération EAX+ECX
c’est-à-dire 48.
(10) : Fin de la deuxième instruction et du processus.


On considère le process représenté par le bout de code

assembleur suivant :
boucle : ADD BL,10

JMP boucle
Code machine : 80C30AEBFB
On suppose au départ que EAX contient 17, EBX contient

05 et ECX contient 15. Le contenu des autres registres est
inconnu.











Comment arrêter un process qui boucle ?
La notion d’interruption.

Interruptions
Séance 4
Interruptions

Interruptions
Sommaire :
I Présentation
I Définition
I Vecteur d’interruptions (x86)
I INTR et Contrôleur d’interruptions (PIC)
I Déroulement d’une interruption
I Table d’interruptions
I Handler d’interruption
I Le registre RFLAGS

Interruptions
Rappel sur le cycle du processeur

Interruptions
Présentation du problème
Le cycle du processeur vu exécute tout un processus en

une fois. Mais que se passe-t-il si on a :
I un événement extérieur ? (frappe au clavier, click
souris, . . . )
I une erreur d’exécution ? (instruction inconnue,
division par 0, . . . )
I du dialogue avec le système ? (appel système,
scheduling de processus, . . . )

Interruptions
Présentation : Polling(scrutation)

Interruptions
Présentation : Polling(scrutation)
I Exemple : traitement de texte ;

I Comment détecter une frappe au clavier sans
interruptions ?
I Seule solution : le polling ;
I Problème : attente active.

Interruptions
Définition d’une interruption
I Interruption automatique du processus en cours ;

I Exécution d’une « routine de traitement
d’interruption »(interrupt handler) ;
I En général, reprise ultérieure du programme
interrompu.

Interruptions
Types d’interruptions
Trois types d’interruptions :

I Les Interruptions Matérielles. Elles sont
provoquées par un matériel extérieur ;

I Les Exceptions. Elles sont provoquées par un
programme, généralement suite à une erreur ;

I Les Appels-système. Ils sont provoqués par un
programme, pour demander un service au système

d’exploitation (l’OS).

Interruptions
Définition : Interruptions Matérielles
Exemples :
I Frappe sur le clavier ;
I Arrivée d’un paquet sur le réseau ;
I Clic sur la souris ;
I Fin de lecture sur le disque ;
I ...

Interruptions
Définition : Exceptions
Exemples :
I Division par 0 ;
I Instruction inconnue ;
I ...

Interruptions
Définition : Appels-Système
Exemples :
I Demande de lecture sur fichier ;
I Demande d’écriture sur fichier ;
I Demande de modification des droits d’accès sur un
fichier ;
I Demande de fermeture d’un fichier ouvert ;
I ...

Interruptions
Vecteur d’interruptions : Numéros

d’interruptions (x86)
I Chaque interruption a un numéro (« vecteur ») ;
I 256 types différents ;
I 0-31 : réservés pour des exceptions ;
0 : division par 0 ;
6 : opcode non défini ;
...
I 32-255
Définis par l’OS ;
Programmé dans le PIC (interruptions matérielles)

Interruptions
Cycle du processeur avec interruptions

Interruptions
La broche INTR

Interruptions
La broche INTR
I INTR = INTerrupt Request ;
I Signale au processeur l’arrivée d’une interruption
matérielle.

Interruptions
Le contrôleur d’interruptions
I La broche INTR est unique.

Interruptions
I La broche INTR est unique ;
I Or plusieurs sources potentielles d’interruptions ;

Interruptions
I Il faut sérialiser les interruptions ;

Interruptions

I Il faut sérialiser les interruptions ;
I Rôle du Contrôleur d’interruptions (PIC =
Programmable Interrupt Controller) ;
I Set pour les interruptions matérielles ;
I Exemple : Intel 8259 ;
I Relié aux périphériques via bornes IR(Q).

Interruptions

Interruptions
I Relié aux périphériques via bornes IR(Q) ;

I Envoie les demandes d’interruptions une par une au
CPU (borne INT) ;
I Programmable pour donner des priorités différentes à
chaque périphérique ;
I Or plusieurs sources potentielles d’interruption ;
I PIC= Programmable Interrupt Controller ;

Interruptions

Interruptions
I IRQ0 - timer programmable ;

I IRQ1 - clavier ;
I IRQ2 - mise en cascade d’un 2e PIC ;
I IRQ3 - port série ;
I IRQ4 - port série ;
I IRQ5 - port parallèle ;
I IRQ6 - disque floppy ;
I IRQ7 - port parallèle.

Interruptions
Deux Contrôleur d’Interruptions en cascade

La mise en cascade de deux PIC,
I Permet d’augmenter le nombre d’IRQ.

Interruptions
Deux Contrôleur d’Interruptions en

cascade : Remarque
I Les microprocesseurs x286, x386 et x486 utilisaient 2

contrôleurs Intel 8259 chaînés, portant à 16 le
nombre d’interruptions PC possibles.
I Pour les processeurs Pentium 1 et suivants, le
contrôleur d’interruption est directement implanté
dans le chipset ; ce n’est plus un circuit spécialisé.

Interruptions
Déroulement d’une interruption

Interruptions

Interruptions

Interruptions

Interruptions

Interruptions

Interruptions
Table d’interruptions
I Elle contient les adresses des handlers d’interruptions ;

I Elle est dans la RAM ;
I Elle est gérée par l’OS ;
I Les détails : lors d’une leçon ultérieure et au cours de
Systèmes.

Interruptions
Table d’interruptions : schéma général

Interruptions
Structure d’un handler
La structure d’un handler en monoprogrammation :

I Sauver les registres utilisés (sur la pile : PUSH) ;
I Traiter l’interruption ;
I Restaurer les registres utilisés (à partir la pile : POP) ;
I IRET.

Interruptions
Handler d’interruption : L’instruction IRET
I Exécutée en fin de handler d’interruption

I Restaure automatiquement l’ancien RIP ;
I Permet de revenir au programme interrompu.

Interruptions
Le registre RFLAGS : Le flag IF

I Si IF=0, le CPU est non-interruptible ;
I Si IF=1, le CPU est interruptible ;
I CLI : instruction pour mettre IF à 0 ;
I STI : instruction pour mettre IF à 1 ;
I CLI/STI : utilisés par l’OS.

Mode réel et mode protégé
Séance 5
Mode réel et mode protégé
Avant le 80286 Le MMU

Mode protégé Mode réel
Mode / Interruptions

Mode réel et mode protégé Avant le 80286
Avant le processeur Intel 80286
I Chaque programme avait accès à toute la mémoire

centrale ;
I Le système MS-DOS travaillait dans ce mode ;
I Risques de sécurité :
Un programme peut modifier les données d’un autre
programme ;
Un programme peut même modifier les données du
système d’exploitation !
I Solution : introduction du mode de fonctionnement
protégé à partir du processeur 80286.

Mode réel et mode protégé Mode protégé
Le mode de fonctionnement protégé
I Disponible depuis le processeur 80286 ;

I Souvent abrégé en mode protégé ;
I Ce mode offre des protections à deux niveaux :
Un programme ne peut pas accéder à toute la mémoire
de l’ordinateur ;
Un programme ne peut pas toujours utiliser toutes les
instructions du processeur ;
I La quasi totalité des systèmes informatiques actuels
fonctionnent en mode protégé.

Les quatre anneaux (rings) de protection

du mode protégé
I Le mode protégé offre quatre niveaux de protection,
appelés des anneaux de protection (protection rings
en anglais) ;
I A tout moment, le processeur travaille dans un des
quatre niveaux de protection ;
I A certains moments-clé, le processeur change de
niveau de protection ;
I Les quatre niveaux de protection sont numérotés de 0
à 3, du plus permissif au moins permissif :

du mode protégé


du mode protégé
I Ring 0 :Les programmes peuvent employer toutes

les instructions du processeur et accéder à toute la
mémoire centrale (employé pour le code de l’OS sous
Windows et Linux).
I Ring 1 : Les programmes ne peuvent employer
qu’un nombre réduit d’instructions, et n’ont pas
accès à toute la mémoire (non employé sous
Windows et Linux).


du mode protégé

accès à toute la mémoire (non employé sous
Windows et Linux).
accès à toute la mémoire (employé par les
programmes utilisateurs sous Windows et Linux).

Exemple d’une instruction interdite en

mode protégé
I L’instruction CLI sert à suspendre les interruptions

en mettant le flag IF à 0 ;
I Elle n’est permise qu’en ring 0, donc seul l’OS peut
l’employer ;
I L’exemple suivant montre un essai d’utilisation de
CLI dans un programme utilisateur.

Exemple
;cli.asm
global main
section .text
main :
cli
;fin
mov rax , 60
mov rdi , 0
syscall

Le mode réel
I Malgré l’introduction du mode protégé, les

processeurs 80286 et suivants peuvent encore
travailler dans le mode précédent, non-protégé : il
s’agit du mode réel ;
I Ce mode permet notamment d’exécuter des vieux OS
comme MS-DOS, qui n’étaient pas prévus pour le
mode protégé ;

Le mode réel
I En réalité, lors du démarrage de l’ordinateur, le

processeur commence toujours à fonctionner en mode
réel, puis l’OS le fait passer en mode protégé ;
I En mode réel, la taille totale de la mémoire
adressable est limitée à 1 Mb (220 bytes), et tous les
programmes peuvent y écrire partout sans protection !

Gestion de la mémoire en mode protégé
Le mode protégé emploie 3 types d’adresses :

I Les adresses logiques : les adresses employées dans
vos programmes assembleur, et vues par le

processeur ;
I Les adresses linéaires : issues d’une traduction des
adresses logiques au travers du processus de

segmentation ;
I Les adresses physiques : véritables adresses de la
mémoire centrale.

Les adresses logiques

I Les adresses logiques sont celles employées dans vos
programmes assembleur, et visibles notamment dans
kdbg ;
I Expérience : exécutez deux fois le même programme
en même temps sur linux1 et comparez les adresses
grâce à kdbg
Les deux programmes emploient les mêmes adresses !
Or deux programmes ne peuvent occupper
simultanément le même espace en mémoire !
En réalité, les adresses employées par votre programme
(adresses logiques) ne sont pas les véritables adresses
physiques employées par la mémoire centrale.
Un mécanisme de traduction sera nécessaire pour
traduire ces adresses logiques en adresses physiques.
Adresses logique et MOV
I Introduisons une nouvelle variante du MOV, pas

encore vue au labo : MOV [adresse], valeur
I Cette instruction place une valeur à
l’adresse-mémoire spécifiée entre crochets
I Exemple : l’instruction MOV [10], AX place la
valeur de AX en mémoire centrale à l’adresse logique
10.

Adresses logique et MOV
I Attention, ici 10 est bien une adresse logique, et non

la véritable adresse physique à laquelle sera placé le
contenu de AX !
I Ainsi, deux programmes différents peuvent effectuer
un MOV [10], AX sans se marcher sur les pieds,
car l’OS traduira leur deux adresses 10 vers des
adresses physiques différentes.

Segmentation
I En mode protégé, la mémoire d’un programme est

divisée en morceaux appelés des segments ;
I Chaque segment d’un programme peut être situé à
un endroit différent de la mémoire centrale ;
I La localisation précise de chaque segment en
mémoire est stockée dans une table appelée table des
segments ;

Segmentation
I Cette table contient l’adresse et la taille de chaque

segment, ainsi qu’une information disant à quel
programme appartient le segment ;
I Les informations de la table des segments permettent
d’empêcher un programme d’accéder aux segments
d’un autre programme (protection de la mémoire).

Segments typiques d’un programme
I Segment de code : contient les instructions du

programme ;
I Segment de données : contient les variables
globales du programme (voir laboratoire)
I Segment de pile : contient les variables locales du
programme.

Les registres de segment
I Le registre CS (code selector) permet de retrouver

l’adresse du segment de code dans la table des
segments ;
I Le registre DS (data selector) permet de retrouver
l’adresse du segment de données dans la table des
segments ;
I Le registre SS (stack selector) permet de retrouver
l’adresse du segment de pile dans la table des
segments ;

Les registres de segment
Ces registres CS, DS et SS indiquent en réalité où dans

la table des segments on doit aller chercher l’adresse
du segment correspondant.
D’autres registres de segment existent (ES, FS, GS).

Traduction d’une adresse logique en une

adresse linéaire
I Les adresses logiques sont en réalité des décalages

(anglais offset) par rapport au début de leur segment ;
I Il faut donc rajouter à chaque adresse logique
l’adresse du début du segment correspondant ;
I Adresse linéaire = adresse du début du
segment + adresse logique

Traduction d’une adresse logique en une

adresse linéaire
Exemple :
I MOV [10], AX signifie mettre le contenu de AX à
l’adresse 10 du segment de données ;

I On obtient l’adresse de début du segment de données
grâce au registre DS et à la table des segments ;

I On rajoute cette adresse à 10 pour obtenir l’adresse
linéaire.

Segmentation en mode protégé : GDT et

gdtr

Pagination
I La pagination est un deuxième mécanisme de gestion
de la mémoire offerts par le processeur x86 à partir
de la version Intel 80386 ;
I Il consiste à découper les programmes en morceaux
de taille égale appelés des pages ;
I Chaque page du programme sera ensuite placée en
mémoire à un endroit différent.
I Ainsi, un même segment peut être divisé en plusieurs
pages, situées à des endroits différents de la mémoire.
I Les adresses linéaires doivent donc elles-mêmes être
traduites pour retrouver les adresses physiques !
Pagination (suite)
I Contrairement à la segmentation, la pagination peut

être désactivée dans le processeur 80386 et les
suivants ;
I Si on n’emploie pas de pagination, les adresses
linéaires et les adresses physiques sont égales ;
I Nous ne traiterons pas en détail le fonctionnement de
la pagination ;
I La pagination est fortement utilisée par les systèmes
d’exploitation modernes, dont Linux.

Résumé des étapes de traduction des

adresses

Mode réel et mode protégé Le MMU
Le processeur et la traduction des adresses
I Le processeur n’utilise que des adresses logiques dans

ces registres (RIP, . . . ) ;
I Ces adresses doivent donc être traduites en adresses
physiques (segmentation, pagination) avant d’accéder
véritablement à la mémoire ;
I Cette traduction d’adresse se fait grâce à une puce
particulière appelée MMU ( Memory Management
Unit, c’est-à-dire Unité de Gestion de la Mémoire ).

Mode réel et mode protégé Le MMU
Le processeur et la traduction des adresses
Figure : D’après Croisière au coeur d’un OS, Etape 2 :

segmentation et interruptions (GNU Linux Magazine
France numéro 63, Juillet/Aout 2004), disponible online à
l’adresse http ://sos.enix.org/wiki-fr/
upload/SOSDownload/sos-texte-art2.pdf
Mode réel et mode protégé Mode réel
Mode réel et segmentation

I En mode réel, il y a une segmentation, mais très
simpliée ;
I En mode réel, la segmentation est juste une astuce
pour contourner des limites techniques. Elle ne
contient aucun mécanisme de protection de la
mémoire et ne se sert pas de table. Ce mode est
utilisé pour le démarrer le PC.
I Il n’y a pas de pagination, donc la segmentation
donne directement des adresses physiques ;
I Adresse physique = adresse de début du segment*16
+ offset ;
I L’adresse de début du segment et l’offset sont sur 16

bits, ce qui donne une adresse totale sur 20 bits :


I En mode réel, si vous souhaitez écrire à une adresse
connue en mémoire, il suffit de choisir un segment et
un offset qui mène à cette adresse ;
I Inversement, si vous avez un segment et un offset,
vous pouvez calculer quelle adresse physique est
obtenue ;
I Vous avez à votre disposition les registres de segment
CS (code), DS (données), SS (pile) ; et aussi ES,
FS,GS que vous pouvez utiliser librement ;
I Tout programme peut donc accéder à n’importe
quelle adresse physique en choisissant un segment et
un offset qui mène à cette adresse.
I Exemple d’un programme en mode réel qui définit

son propre segment grâce au registre ES, la
segmentation en mode réel ne contient aucun
mécanisme de protection de la mémoire ;
I Ce programme ne fonctionne pas (segmentation
fault) en mode protégé, car il faut être en ring 0
pour accéder aux adresses 0xB8000.

Mode réel et segmentation : Exemple de

code
mov AX , 0xB800
mov ES , AX
mov AL , ’h’
mov AH , 10010111b
mov [ES : 0xA0] , AX
On donne la valeur B800 au registre de segment ES on
donne une valeur arbitraire à AX que l’on place aux
positions B80A0 et B80A1 en memoire.

Mode réel et mode protégé Mode / Interruptions
Mode et interruptions
I Rappel : la table des interruptions est la table disant

à quelle adresse se trouve la routine de gestion de
l’interruption numéro i ;
I Cette table se trouve dans la mémoire centrale, dans
une zone réservée appartenant au système
d’exploitation ;
I Selon qu’on est en mode réel ou protégé, cette table
est gérée de façon différente.

Mode réel et interruptions

I En mode réel, les adresses sont données par une paire
(segment : offset), où segment et offset font 2
bytes chacun (donc 4 bytes en tout) ;
I En mode réel, la table des interruptions est à
l’adresse fixe 0000 : 0000 (c’est-à-dire l’adresse 0
dans le segment 0) ;
I L’entrée i de la table contient l’adresse de la routine
de gestion de l’interruption n◦ i ;
I L’adresse de la routine de gestion de l’interruption i
(le bout de code correspondant à int i) se trouve
donc à l’adresse 4 * i.
Mode protégé et interruptions
I En mode protégé, la table des interruptions IDT est

à l’adresse donnée par le registre IDTR ;
I L’entrée i de la table contient l’adresse de la routine
de gestion de l’interruption n◦ i ;
I En mode protégé, les adresses sont données par une
paire (segment : offset), où :
en architecture 32 bits, segment fait 2 bytes et offset
fait 4 bytes (donc 6 bytes en tout) ;
en architecture 64 bits, segment fait 2 bytes et offset
fait 8 bytes (donc 10 bytes en tout) ;


Chaque entrée de la table des interruptions contient :
I en architecture 32 bits, les 6 bytes de l’adresse
de la routine de gestion d’interruption, ainsi que 2

bytes supplémentaires contenant d’autres
informations de sécurité (donc 8 bytes en tout par
entrée de la table en mode protégé) ;
I en architecture 64 bits, les 10 bytes de l’adresse
de la routine de gestion d’interruption, ainsi que 2

bytes supplémentaires contenant d’autres
informations de sécurité (donc 12 bytes en tout par
entrée de la table en mode protégé) ;
I en architecture 32 bits, l’adresse de la routine de

gestion de l’interruption i (le bout de code
correspondant à int i) se trouve donc à l’adresse
[IDTR] + 8 * i.
I en architecture 64 bits, l’adresse de la routine de
gestion de l’interruption i (le bout de code
correspondant à int i) se trouve donc à l’adresse
[IDTR] + 12 * i.


I Dans le mode protégé, le processeur peut travailler
dans un des 4 anneaux (ring) ;
I Si le processeur est en ring 0, il peut exécuter toutes
les instructions du jeu d’instructions ;
I Si le processeur est en ring 3, il ne peut exécuter
qu’une partie des instructions du jeu d’instructions ;
I Le code d’un utilisateur est exécuté dans le ring 3 ;
I Le code d’une interruption est exécuté dans le ring
0;
I Une interruption fait basculer le processeur en ring 0
et IRET le fait basculer dans l’ancien ring.
Interruption : Résumé
Lors d’une interruption,
I le processeur termine l’instruction en cours ;
I il place le contenu du registre RIP au sommet de la
pile ;
I il remplace RIP par une valeur située en mémoire,
dans une table à l’index donné par le numéro de

l’interruption ;
I le processeur bascule en ring 0 s’il est en mode
protégé pour pouvoir exécuter la routine

d’interruption.

Interruption : Résumé
Lors de l’exécution de l’instruction IRET,

I le processeur récupère RIP sur la pile ;
I le processeur bascule dans l’ancien ring s’il est en
mode protégé.

Langage d’assemblage
Séance 6

Sommaire :
I Qu’est-ce que l’assembleur ? ;

I Avantages ;
I Inconvenients ;
I Dialectes ;
I Imbeded assembleur ;
I Performance et assembleur ;
I Applications ;
I Assembleur actuellement.

Que signifie le terme assembleur ?
Le terme assembleur peut faire référence :

I au langage de programmation ;
I au compilateur.

Pourquoi utiliser l’assembleur ?

I Pour des raisons pédagogiques : permet de simuler et
comprendre le fonctionnement interne d’un
microprocesseur ;
I Plus facile à lire et à comprendre pour un humain car
dans un code assembleur, on retrouve :
du texte ;
des mnémoniques.
I L’utilisation des étiquettes (label) pour représenter
par exemple des noms de variables, les noms des
fonctions, etc., permet de ne pas devoir réaliser des
calculs d’adresses et de recalculer les adresses en cas
de modification du code ;
Pourquoi utiliser l’assembleur ?
I L’assembleur connaît les formats standards de fichiers

objet (comme elf), on ne doit pas s’en préoccuper à
la rédaction du code mais juste éventuellement
utiliser des directives et des options d’assemblage ;
I L’assembleur (au niveau de la traduction) est plus
proche du langage machine (binaire), c’est un
langage de bas niveau. L’effort de traduction en
langage machine (binaire) est donc très faible.

Les obstacles à l’utilisation de

l’assembleur ?
I Écrire et maintenir un programme en assembleur est

pénible ;
I Comme il est le reflet du jeu d’instructions du
processeur, il y a autant d’assembleurs que de
processeurs ;
I Quand on change de processeur, on change de jeu
d’instructions et donc il faut réécrire tout le
programme.

Dialectes utilisés en assembleur ?

Deux dialectes différents pour l’assembleur x86 :
I AT&T ;
I Intel.
Différences :
I ordre des opérateurs ;
I spécifications de taille ;
I ...
Exemple1 :
I Intel : mov eax, 5
I AT&T : movl $5, %eax

Dialectes utilisés en assembleur ?
Exemple2 :
I Intel : mov ax, 5
I AT&T : movw $5, %ax
Exemple3 :
I Intel : mov al, 5
I AT&T : movb $5, %al

Inclure un code assembleur dans un code C

par exemple ?
I Certains compilateurs permettent d’insérer du code

ASM à l’intérieur d’un programme en langage de
haut niveau (voir dans les annexes) ;
I Exemple en C avec le compilateur gcc (syntaxe
AT&T).

Quid de la notion de performance avec

l’assembleur ?
I On dit souvent que les programmes en assembleur

sont plus rapides ;
I Pas toujours vrai car :
Dépend fortement des capacités du programmeur ASM ;
Les compilateurs actuels permettent de fortement
optimiser le code, ce qui donne souvent un code tout
aussi rapide que l’assembleur.
Exemple d’optimisation en C avec le compilateur gcc :
gcc -o2 fichierSource.c

Quid des applications de l’assembleur ?
I Code système : Drivers, handlers d’interruptions,

BIOS, . . . , certaines portions du kernel Linux sont
encore en assembleur.
I Micro-contrôleurs et systèmes embarqués : Mais de
plus en plus remplacé par le langage C
I Applications Multimedia : applications nécessitant de
lourds calculs, nécessité de tirer parti des instructions
les plus spécialisées du processeur.
I Virus

Quid de l’assembleur aujourd’hui ?
I N’est plus employé pour le développement

d’applications complètes ;
I Employé pour certaines portions de code très précises
nécessitant une optimisation fine ;
I Intérêt pédagogique : Permet de mieux comprendre le
fonctionnement du processeur.

Les modes d’adressage
Séance 7

Sommaire
I Que signifie adresser des données ?

I Modes d’adressage de base
I Pièges à éviter
I Utilisation des modes d’adressage de base
I Architectures RISC, CISC et adressage
I Adressage indirect
I Adressage indirect avec déplacement
I Adressage indirect indexé
I Quelques remarques sur l’adressage

Adresser les données
De nombreuses instructions manipulent des données

I transferts : MOV RAX, 0x34
I calculs : ADD RAX, RDX
I tests : BT R14, 0xA
I ...
Il faut pouvoir indiquer où se trouve chaque donnée, où

mettre chaque donnée.
C’est ce qu’on appelle les modes d’adressage (l’adressage
des données).

Modes d’adressage de base

Immédiat la donnée est directement dans l’instruction.
Exemple : MOV R12, 0x4455
Registre la donnée est (doit être placée) dans un
registre. Exemple : MOV RAX, RBX
Direct la donnée est (doit être placée) à l’adresse donnée
dans l’instruction.
Exemple : MOV RAX, [0xB8A4]
Exemple : MOV [0xB8A0], RAX
Indirect la donnée est (doit être placée) à l’adresse
contenue dans le registre.
Exemple : MOV RAX, [RCX]
Exemple : MOV [RCX], RAX
Modes d’adressage de base - Piège
Attention à ne pas confondre une adresse et le contenu

d’une adresse.
Exemple :
I MOV RAX, 0xB8A0 ; immédiat. RAX reçoit la valeur
0xB8A0.
I MOV RAX, [0xB8A0] ; direct. RAX reçoit la valeur (8
bytes ) à l’adresse 0xB8A0.

I MOV EAX, [0xB8A0] ; direct. EAX reçoit la valeur (4

Modes d’adressage de base - Piège
Exemple :
I MOV AX, [0xB8A0] ; direct. AX reçoit la valeur (2

I MOV AL, [0xB8A0] ; direct. AL reçoit la valeur (1
byte) à l’adresse 0xB8A0.

Modes d’adressage de base - Autre piège
Un label est un nom symbolique pour une adresse.

I MOV RAX, label1 ; immédiat. On met dans RAX
l’adresse label1.
I MOV RAX, [label1] ; direct. RAX reçoit la valeur (8
bytes ) à l’adresse label1.

I MOV AL, [label1] ; direct. AL reçoit la valeur (1 byte
) à l’adresse label1.

Modes d’adressage de base - Utilisation

Ces trois modes d’adressage permettent de traduire les
instructions simples des langages de haut niveau.
Par exemple : b <— a + 5 pourrait se traduire
I MOV RAX, [a] ; (registre , direct)
I ADD RAX, 5 ; (registre , immédiat)
I MOV [b], RAX ; (direct , registre)
Remarque : C’est valable pour des variables globales. En

pratique, a et b sont probablement des variables locales
(cf. MICL) ; elles seront dès lors stockées dans une pile, ce
qui modifie un peu les instructions.

RISC vs CISC
RISC
I Signification : Reduced Instruction Set Computer ;
I Modes d’addressage : Peu ;
I Processeur : Moins complexe.
CISC
I Signification : Complex Instruction Set Compute ;
I Modes d’addressage : Beaucoup ;
I Processeur : Plus complexe.

RISC vs CISC
Les architectures CISC permettent de coder plus

facilement des instructions de haut niveau comme :
I maStructure.unChamp <— 5
I tab[4] <— 3
I tab[4].unChamp <— 6

Adressage indirect (registre)

La donnée est à une adresse donnée par un registre.
Exemple :
MOV RBX, 0xB8A0 ; RBX contient l’adresse donnée
MOV RAX, [RBX] ; on met dans RAX la donnée (8 bytes)
se trouvant à l’adresse 0xB8A0
Utile pour traduire les instructions manipulant les
pointeurs et/ou références.
Exemple : Pour traduire objet1 <— objet2 (copie des
références), on pourrait avoir :
MOV RAX, [objet2] ; l’objet référencé par objet2
MOV [objet1], RAX ; et si on ne met pas les crochets ?
Adressage indirect avec déplacement

Adresse obtenue en ajoutant un déplacement à une
adresse dans un registre.
Exemple :
MOV RAX, [RBX + 4] ; RAX reçoit la donnée se
trouvant à l’adresse donnée par (le contenu de) RBX + 4.
structures
Exemple : Pour traduire maStructure.unChamp <— 1, on
pourrait avoir :
MOV RAX, maStructure ; pas de crochet ici
MOV [RAX + 8], 1
Le ’8’ dépend des champs précédents dans la structure.
Adressage indirect indexé
Le déplacement est lui aussi dans un registre. On y

applique un facteur multiplicatif.
Exemple :
MOV RAX, [RBX + 4 * RCX] ; RAX reçoit la donnée
se trouvant à l’adresse donnée par (le contenu de) RBX +
4 * (le contenu de) RCX.
tableaux.

Adressage indirect indexé
Exemple : Pour traduire tab[3] <— 1, on pourrait avoir :

I MOV RAX, tab
I MOV RBX, 3
I MOV [RAX + 8 * RBX], 1
Le ’8’ est par exemple la taille d’une case d’un tableau.

On comprend mieux que les tableaux commencent à 0
dans de nombreux langages.

Remarques
Nous n’avons pas tout dit :

I Les modes d’adressages portent parfois d’autres
noms ;
I Il existe encore d’autres modes d’adressages ;
I Chaque processeur dispose d’un sous-ensemble des
modes d’adressages possibles ;

I Chaque assembleur dispose de sa propre syntaxe pour
ces modes d’adressages.

Le codage des instructions assembleur x86 64 bits
Séance 8

Objectifs
I Comprendre comment sont codées les instructions du

x86 64 bits ;
I Être capable de traduire :

Assembleur ⇐⇒ Code machine

Sommaire :
I Format général d’une instruction assembleur x86 64
bits ;
I Les préfixes : présentation générale ;
I Code machine x86 64 bits : Le code opératoire ;
I Code machine x86 64 bits : Le code des registres ;
I Code machine sur un byte fixe ;
I Code machine sur un byte ;
I Code machine avec valeur immédiate ;
I Le byte ModeR/M ;
I Le byte SIB ;
I Les préfixes : cas d’utilisation.
Format général d’une instruction

assembleur x86 64 bits
En architecture 64 bits, le format général d’une instruction
du x86 se présente comme suit :
I les préfixes de l’instruction (1 à 4 bytes optionnels,
1 byte par préfixe) ;

I l’opcode de l’instruction (1 à 3 bytes, 1 obligatoire) ;
I le byte ModR/M (1 byte optionnel) ;
I le byte SIB (1 byte optionnel) ;
I le déplacement (1 ou 4 bytes optionnels) ;
I la valeur immédiate (1, 2, 4 ou 8 bytes optionnels).

Format général d’une instruction : Schéma
préfixe code op. ModR/M SIB déplacement val. imméd.

X X X X X X X X X X X X X X X X X X
1à4 1 ou 4 1, 2,4 ou 8
X = obligatoire X = facultatif X = REX prefix
I Longueur variable en fonction de l’instruction

I Assez complexe ⇒ procédons par étapes

Les préfixes : présentation générale
Il faut distinguer 2 types : les legacy préfixes (préfixes

hérités) et les REX préfixes.
I les legacy prefixes (divisés en 4 groupes) ;
groupe 1 : préfixes de répétition (0xF2, 0xF3) ;

groupe 2 : préfixes de réécriture des segments
CS(0x2E), SS(0x36), DS(0x3E), ES(0x26),
FS(0x64), GS(0x65) ;
groupe 3 : préfixe de réécriture de la taille des opérandes
(0x66) ;
groupe 4 : préfixe de réécriture de la taille des adresses
(0x67).

Les préfixes : présentation générale
I les REX préfixes (0100WRXB) ;

c’est un ensemble de 16 opcodes ;
ce sont des préfixes d’instruction utilisés en x86 64 bits ;
servent entre autre à spécifier la taille des opérandes à
64 bits ;
toutes les instructions du x86 64 bits ne nécessitent pas
un préfixe REX ;
REX.W peut être utilisé pour déterminer la taille des
opérande.

Code machine x86 64 bits : Le code

opératoire
Le code opératoire (Opcode) :

I Permet d’idendifier l’opération à exécuter ;
I Pour un même mnémonique, on peut avoir
plusieurs opcodes associés ;

I Pour un opcode donné, on a une et une seule
instruction associée (extension comprise).

Le code opératoire : Référence
Où trouver ces codes opératoires (opcodes) :

I Dans un manuel de référence de Intel
https://software.intel.com/content/www/us/
en/develop/articles/intel-sdm.html ;
I Il faut apprendre à lire ces références car ce n’est pas
du tout évident ;
I Sur poEsi vous trouverez la documentation utile en
format PDF ;
I Exemple pour DEC et INCC.

Référence pour DEC

Référence pour INC

Code machine x86 64 bits : Le code des

registres
I Dans les instructions du x86, les registres sont codés

sur 3 bits.
I Le code machine permet au processeur de déterminer
s’il doit travailler avec des registres de 8, 16, 32 ou
64 bits.

Codes des registres sur 3 bits
I 000 : AL, AX, EAX, RAX, R8L, R8W, R8D, R8 ;

I 001 : CL, CX, ECX, RCX, R9L, R9W, R9D, R9 ;
I 010 : DL, DX, EDX, RDX, R10L, R10W, R10D,
R10 ;
I 011 : BL, BX, EBX, RBX, R11L, R11W, R11D, R11 ;
I 100 : AH, SP, ESP, R12L, R12W, R12D, R12 ;
I 101 : CH, BP, EBP, R13L, R13W, R13D, R13 ;
I 110 : DH, SI, ESI, RSI, R14L, R14W, R14D, R14 ;
I 111 : BH, DI, EDI, RDI, R15L, R15W, R15D, R15 ;

Environnement d’exécution de base : ce

qu’il faut savoir
L’architecture IA-32 supporte 3 modes de

fonctionnement de base :
I Mode protégé ;
I Mode réel ;
I Mode gestion du système (SMM) ;
L’architecture Intel 64 ajoute le mode IA-32e.


qu’il faut savoir
Le mode IA-32e a 2 sous-modes :

I Mode compatibilité (compatible) : permet
l’exécution des applications 16-bits et 32-bits sur un

OS 64-bits.
I Mode 64-bits : permet à un OS 64-bits d’exécuter
des applications écritent pour accéder un espace

linéaire 64-bits (applications 64-bits).


qu’il faut savoir sur le préfixe REX
Le mode IA-32e a 2 sous-modes : En mode 64-bits :
I La taille par défaut des adresses est 64 bits ;
I La taille par défaut des opérandes des instructions est
32 bits ;
I L’utilisation du préfixe REX sous la forme de REX.R
permet d’accéder aux registres R8, R9, R10, . . . ,

R15 ;
I L’utilisation du préfixe REX sous la forme de
REX.W promeut les opérations à 64 bits.

Code machine sur un byte fixe
Codée sur 1 byte : le code opératoire de l’instruction
Op code
Exemple : CLC
CLC =⇒ F8
|{z}
op code

Code machine sur un byte

Codée sur 1 byte : le code opératoire de l’instruction
Op code
Exemple : NOP
NOP =⇒ 90
|{z}
op code

Code machine avec valeur immédiate : cas

du MOV


du MOV
Exemple : MOV EAX, 20 et MOV RAX, 20

I MOV EAX, 20 =⇒ B8 14 00 00 00 ;
I MOV RAX, 20
=⇒ 48 B8 14 00 00.

du ADD


du ADD
Exemple : ADD EAX, 10 et ADD RAX, 10

I ADD EAX, 10 =⇒ 83 C0 0A ;
I ADD RAX, 10
=⇒ 48 83 C0 0A.

Le byte ModR/M
Utilisé pour les modes d’adressages complexes
ModR/M
|{z} | {z } | {z }
Mod divers R/M
I Mod : mode d’adressage pour la partie R/M

I R/M : opérande
(peut nécessiter d’autres bytes)
I divers : dépend du nombre d’opérandes
1 opérande : extension du code opératoire
2 opérandes : deuxième opérande (un registre)
Le byte ModeR/M : Le mode d’adressage

sur 2 bits
Le mode d’adressage est codé sur 2 bits :
I 00 : De registre à mémoire, MOV EAX, [EBX] .
L’adresse est dans le registre sauf ESP, RSP qui sont

réservés lors d’un adressage indirect indexé, exemple :
MOV RAX, [RBX + 4 * RCX]) et EBP, RBP
qui sont réservés lors d’un adressage direct
(déplacement sur 32 bits), exemple : MOV EAX,
[0xB8A0]) ;
I 01 : De registre à mémoire, MOV EAX, [EBX +
8] . L’adresse est dans le registre plus un

déplacement sur 1 byte sauf ESP, RSP.
Le byte ModeR/M : Le mode d’adressage

sur 2 bits
I 10 : De registre à mémoire, MOV EAX, [EBX +

512]. L’adresse est dans le registre plus un
déplacement sur 4 bytes sauf ESP, RSP.
I 11 : De registre à registre (MOV EAX, EBX).

Le byte ModeR/M : De registre à registre
Exemples : ADD EAX, EBX et ADD RAX, RBX

I ADD EAX, EBX (01/r)
Op code : 01
Mode adressage : 11
Registre : EBX = 011
Mémoire : EAX = 000
d’où : ADD EAX, EBX =⇒ 01 D8

Le byte ModeR/M : De registre à registre
I ADD RAX, RBX (REX.W + 01/r)

Préfixe REX sous la forme REX.W : 01001000 = 48
Op code : 01
Mode adressage : 11
d’où : ADD RAX, RBX =⇒ 48 01 D8

Le byte ModeR/M : De registre à

mémoire, l’adresse est dans le registre
Exemples : ADD [EAX], EBX et ADD [RAX], RBX
I ADD [EAX], EBX (01/r)

Op code : 01
Mode adressage : 00
d’où : ADD [EAX], EBX =⇒ 01 18


mémoire, l’adresse est dans le registre
I ADD [RAX], RBX (REX.W + 01/r)

Op code : 01
Mode adressage : 00
Registre : RBX = 011
Mémoire : RAX = 000
d’où : ADD [RAX], RBX =⇒ 48 01 18
Remarque :
ADD [EAX], RBX =⇒ 48 01 18 également


mémoire, l’adresse est dans le registre +
un déplacement sur 1 byte
Remarque : L’adresse ne peut pas être dans ESP ou

RSP.
Exemples : ADD [ECX + 0x40], ESI
et ADD [RCX + 0x40], RSI


I ADD [ECX + 0x40], ESI (01/r)

Op code : 01
Mode adressage : 01
Registre : ESI = 110
Mémoire : ECX = 001
Déplacement : 0x40
d’où : ADD [ECX + 0x40], ESI =⇒ 01 71 40


I ADD [RCX + 0x40], RSI (REX.W + 01/r)
Op code : 01
Mode adressage : 01
Registre : RSI = 110
Mémoire : RCX = 001
Déplacement : 0x40
d’où : ADD [RCX + 0x40], RSI =⇒ 48 01 71 40


un déplacement sur 4 bytes

RSP.
Exemples : ADD [ECX + 0x1234], ESI
et ADD [RCX + 0x1234], RSI


I ADD [ECX + 0x1234], ESI (01/r)

Op code : 01
Mode adressage : 10
Déplacement en little endian : 0x34120000
d’où : ADD [ECX + 0x1234], ESI =⇒ 01 B1
34120000


I ADD [RCX + 0x1234], RSI (REX.W + 01/r)
Op code : 01
Mode adressage : 10
ADD [RCX + 0x1234], RSI
=⇒ 48 01 B1 34120000
Le byte ModeR/M : De mémoire à

registre, l’adresse est dans le registre + un
déplacement sur 4 bytes

RSP.
Exemples : ADD ESI, [ECX + 0x1234]
et ADD RSI, [RCX + 0x1234]


I ADD ESI, [ECX + 0x1234] (03/r)

Op code : 03
Mode adressage : 10
d’où : ADD ESI, [ECX + 0x1234]
=⇒ 03 B1 34120000


I ADD RSI, [RCX + 0x1234] (REX.W + 03/r)
Op code : 03
Mode adressage : 10
d’où : ADD RSI,[RCX + 0x1234]
=⇒ 48 03 B1 34120000
Le byte ModeR/M : De registre à mémoire,

l’adresse est fixe sur 4 bytes (8 bytes)
Remarque : On utilise le registre EBP ou RBP pour la

mémoire.
Exemples : ADD [0x1234], ESI
et ADD [0x1234], RSI


Exemple avec une adresse sur 4 bytes (fonctionnement en

32 bits) :
I ADD [0x1234], ESI (01/r)
Op code : 01
Mode adressage : 00
Mémoire : EBP = 101
d’où : ADD [0x1234], ESI =⇒ 01 35 34120000


I ADD [0x1234], RSI (REX.W + 01/r)

Op code : 01
Mode adressage : 00
Mémoire : RBP = 101
d’où : ADD [0x1234], RSI
=⇒ 48 01 35 34120000

ModR/M - récapitulatif
Adressage Exemple ModR/M

registre EAX 1 1 0 0 0 0 0 0
indirect [EAX] 0 0 0 0 0 0 0 0
indirect + court [EAX+10] 0 1 0 0 0 0 0 0
indirect + long [EAX+800] 1 0 0 0 0 0 0 0
direct [adresse] 0 0 0 0 0 1 0 1
indirect indexé [EAX+4*EBX] 0 0 0 0 0 1 0 0
indexé + court [EAX+4*EBX+10] 0 1 0 0 0 1 0 0
indexé + long [EAX+4*EBX+800] 1 0 0 0 0 1 0 0

Le byte SIB
I Utilisé en complément au ModR/M
I Pour les modes d’adressages indexés (B + S × I )
SIB
|{z} | {z } | {z }
S I B
S facteur multiplicatif (scale)

2i ⇒ 00 = 1×, 01 = 2×, 10 = 4×, 11 = 8×
I registre d’index
B registre de base
Le byte SIB
Exemple de registre à mémoire,

I l’adresse est fournie par un index, une base et un
déplacement sur 1 ou 4 bytes ;

I le byte ModR/M spécifie si il y a un déplacement et
sur quelle taille ;

I le code du registre ESP ou RSP (100) est utilisé
pour préciser que l’adresse est calculée sur base d’un

index et d’une base.
Dans ce cas, le byte ModR/M est suivi du byte SIB.

Le byte SIB : Exemples
I ADD [ECX + 2*EAX], EBX

=⇒ 01 1C 41
I ADD [RCX + 2*RAX], RBX
=⇒ 48 01 1C 41
I ADD [EDX + 4*ECX + 0x1234], ESI
=⇒ 01 B4 8A 34 12 00 00
I ADD [RDX + 4*RCX + 0x1234], RSI
=⇒ 48 01 B4 8A 34 12 00 00

Les préfixes : Legacy prefixes
Préfixe de segmentation - exemple

I ADD [ES :EAX], EBX
=⇒ 26 01 18
I ADD [SS :ECX], ESI
=⇒ 36 01 31
I ...


Préfixe de répétition - exemple
MOVSB copie un byte de l’adresse [ESI] vers l’adresse
[EDI] et incrémente ESI et EDI.
Cette instruction peut être répétée ECX fois à l’aide du
préfixe REP codé 0xF3.
I MOVSB
=⇒ A4
I REP MOVSB
=⇒ F3 A4
I ...

Préfixe de taille
I Le programmeur fixe la taille des registres à l’aide de
la macro [BITS 16],[BITS 32] ou [BITS 64] ;
I Un bit D qui se trouve dans le descripteur de
segment précise au processeur s’il doit utiliser les
registres 16 bits (D=0) ou 32 bits (D=1) ;
I Pour une instruction, on peut changer cette taille par
défaut à l’aide du préfixe 0x66 pour les opérandes et
0x67 pour les adresses.

Préfixe de taille - exemples

[BITS 16]
ADD[EAX], EBX =⇒ 67 66 01 18
car en mode BITS 16, on utilise une adresse sur 32 bits
ET un registre opérande 32 bits
...

Autres exemples avec [BITS 16] :

I MOV EBX, 0 =⇒ 66 BB 00 00 00 00
66 : Instruction en 32 bits.
I MOV ECX, [EBP] =⇒ 67 66 8B 4D 00
67 : L’adresse sur laquelle pointe EBP n’est pas en 16

bits mais en 32 bits. 66 : Instruction en 32 bits.

Quelques exemples de préfixes de taille :

Instructions [BITS 16] [BITS 32] [BITS 64]
ADD[EBX],EAX 66 67 01 03 01 03 67 01 03
ADD[EBX],AX 67 01 03 66 01 03 66 67 01 03
ADD[BX],AX 01 07 66 67 01 07 Impossible
ADD[BX],AL 00 07 67 00 07 Impossible
ADD[EBX],AL 67 00 03 00 03 67 00 03
ADD[RBX],AL Impossible Impossible 00 03

Quelques exemples de préfixes de taille :

Instructions [BITS 16] [BITS 32] [BIT
ADD qword[EBX],8 Non Supportée Non Supportée 67 4
ADD qword[RBX],8 Impossible Impossible 48 8
ADD dword[EBX],8 66 67 83 03 08 83 03 08 67 8
ADD word[EBX],8 67 83 03 08 66 83 03 08 66 6
ADD word[BX],8 83 07 08 66 67 83 07 08 Imp

Les préfixes : REX prefix (0100WRXB).
I Les préfixes REX sont des préfixes d’instructions

utilisés en mode 64-bits.
I Ils permettent entre autre de spécifier la taille des
opérandes à 64-bits.
I Toutes les instructions ne nécessitent pas de préfixe
REX en mode 64-bits.
I Un et un seul préfixe REX par instruction.
I Le byte préfixe REX précède immédiatement le byte
opcode.

En savoir plus sur les champs du préfixes REX

(0100WRXB) :
I Le bit REX.W peut être utilisé pour déterminer la
taille des opérandes.
I Si un préfixe 0x66 est utilisé avec le préfixe REX et
(REX.W=1), alors 0x66 est ignoré.
I Si un préfixe 0x66 est utilisé avec le préfixe REX et
(REX.W=0), la taille des opérandes est 16-bits.

I Le bit REX.R modifie le champ reg (partie divers)

du Byte modR/M quand ce champ encode un
registre R8 . . . R15.
I Le bit REX.R est ignoré si ModR/M spécifie
d’autres registres ou définie une extension de
l’opcode.

I Le bit REX.X modifie le champ index du SIB.

I Le bit REX.B :
modifie la base du champ r/m dans le ModR/M (dans
la partie mémoire) ;
oubien il modifie le champ base du SIB ;
oubien il modifie le champ reg de l’opcode utilisé pour
accéder aux registres R8 . . . R15.


Exemple 1 : Adressage par registre
MOV RAX, R9 (REX.W + 89/r)
REX.W + 8B/r MOV r64,r/m64
REX.W + 89/r MOV r/m64,r64
Le code machine de l’instruction est 4C 89 C8 en
hexadécimal
I REX :
Opération à 64 bits ⇒ REX.W = 1

SIB n’est pas utilisé ⇒ REX.X = 0
La base du champ r/m du ModR/M (la parite mémoire )
= RAX ⇒ REX.B = 0
Le champ reg de ModR/M = R9 ⇒ REX.R = 1
=⇒ REX = 01001100b = 0x4C

Exemple 1 (suite) : Adressage par registre
MOV RAX, R9 (REX.W + 89/r)
Le code machine de l’instruction est 4C 89 C8 en
hexadécimal
I REX = 0x4C
I Opcode = 0x89
I ModR/M :
Mode adressage = 00b
Registre = R9 = 001b
Mémoire (r/m) = RAX = 000b
=⇒ ModR/M = 11001000b = 0xC8
d’où : MOV RAX, R9 =⇒ 0x4C 89 C8

Exemple 2 : Adressage par registre
MOV R9, RAX (REX.W + 89/r)
REX.W + 89/r MOV r/m64,r64
Le code machine de l’instruction est 49 89 C1 en
hexadécimal
I REX :

= R9 ⇒ REX.B = 1
Le champ reg de ModR/M = RAX ⇒ REX.R = 0
=⇒ REX = 01001001b = 0x49

Exemple 2 (suite) : Adressage par registre
MOV R9, RAX (REX.W + 89/r)
Le code machine de l’instruction est 49 89 C1 en
hexadécimal
I REX = 0x49
I Opcode = 0x89
I ModR/M :
Mode adressage = 11b
Registre = RAX = 000b
Mémoire (r/m) = R9 = 001b
=⇒ ModR/M = 11000001b = 0xC1
d’où : MOV R9,RAX =⇒ 0x49 89 C1

Exemple 3 : Adressage indirect
MOV RAX, [R9] (REX.W + 8B/r)
Le code machine de l’instruction est 49 8B 01 en
hexadécimal
I REX :

= R9 ⇒ REX.B = 1
=⇒ REX = 01001001b = 0x49

Exemple 4 : Adressage indirect indexé
MOV RAX, [R9 + 2 * RDX] (REX.W + 8B/r)
Le code machine de l’instruction est 49 8B 04 51 en
hexadécimal
I REX :

SIB est utilisé ⇒ REX.X = 1
= R9 ⇒ REX.B = 1
=⇒ REX = 01001001b = 0x49

Exemple 4 (suite) : Adressage indirect indexé
MOV RAX, [R9 + 2 * RDX] (REX.W + 8B/r)
Le code machine de l’instruction est 49 8B 04 51 en
hexadécimal
I REX = 0x49
I Opcode = 0x8B
I ModR/M = 0x04 (voir calculs dans les exemples
précedents)
I SIB :
S : facteur multiplicateur (scale) = 01b car c’est 21
I : registre d’index = RDX = 010b
B : registre base = R9 = 001b
=⇒ SIB = 01010001b = 0x51

MOV RBX, [R9 + 2 * R8] (REX.W + 8B/r)
Le code machine de l’instruction est 4B 8B C1 41 en
hexadécimal
I REX :

= R9 ⇒ REX.B = 1
Le champ reg de ModR/M = RBX ⇒ REX.R = 0
=⇒ REX = 01001011b = 0x4B

MOV R10, [R9 + 2 * R8] (REX.W + 8B/r)
Le code machine de l’instruction est 4F 8B 14 41 en
hexadécimal
I REX :

= R9 ⇒ REX.B = 1
Le champ reg de ModR/M = R10 ⇒ REX.R = 1
=⇒ REX = 01001111b = 0x4F
Comment visualiser le code machine ?

I Vous écrivez un programme en assembleur (en mode
[BITS 64]) : monprog.asm
I Vous le compilez avec :
nasm monprog.asm -o monprog.bin -f bin
I Vous en visualisez le contenu avec :
od -tx1 monprog.bin
I Les codes machines sont fournis dans le manuel de
référence d’Intel (volume 2 chapitres 3 à 5) ou bien
sur le lien suivant :
http ://www.felixcloutier.com/x86/.

Cartographie de la mémoire en mode réel
Séance 9

Sommaire :
I Accès à la ROM . . . ;
I Accès à la RAM . . . ;
I Accès aux périphériques . . . ;
I Cartographie de la mémoire . . . ;
I Exemples d’accès à un périphérique . . . .

La ROM
I Les bus de données et d’adresse permettent au
processeur de communiquer avec la mémoire.
I Une partie de cette mémoire est de la ROM (Read
Only Memory) non volatile.
I Les premières instructions exécutées au démarrage du
PC sont mémorisées en ROM.
I À cet endroit, vous trouvez un premier S.E. appelé le
BIOS (Basic Input Output System).
I Aujourd’hui, cette ROM est reprogrammable à l’aide
de logiciels. On dit "flasher" la ROM.
On parle de flasher, car aux premiers temps des ROM
programmables, on les effaçait en les éclairant avec une
lampe U.V. ou encore en les exposant au soleil.
La RAM
I Une autre partie de cette mémoire est de la RAM

(Random Acces Memory) volatile.
I Toutes les informations en mémoire (instructions,
données, adresses . . . ) qui se modifient pendant le
fonctionnement de l’ordinateur se trouvent en RAM.
I Une partie de cette RAM peut être utilisée par les
process des utilisateurs.
I Conventionnellement, les 640 premiers Kio sont
réservés au S.E. et aux process des utilisateurs.

Les Périphériques (1)
I Les bus de données et d’adresses permettent au

processeur de communiquer avec les périphériques via
son contrôleur.
I Il n’y a pas de conflit avec les accès mémoire car une
patte du processeur permet de sélectionner le
périphérique ou la mémoire.
I Des instructions spécialisées permettent au
processeur de décider s’il s’agit d’un accès mémoire
(MOV par exemple) ou d’un accès périphérique (IN,
OUT par exemple).

IN/OUT

I On peut toujours décider de câbler un contrôleur à

certaines adresses de la RAM. L’utilisateur écrit dans
le périphérique comme s’il écrivait en RAM.
I Dans le cas du compatible PC, on a placé le
périphérique vidéo texte aux emplacements
0xB8000-0xB8FFF et le périphérique vidéo graphique
aux emplacements 0xA0000-0xAFFFF.
I L’électronique du contrôleur vidéoo affiche en
permanence à l’écran les informations qui se trouvent
à ces adresses.

I Un simple MOV à ces adresses provoquent un

affichage !
I Le contrôleur vidéo peut travailler en différents
modes (texte, 320x200, 640x480,...) que l’on peut
changer à l’aide d’une instruction OUT dans un
registre du contrôleur.

MOV

Cartographie de la mémoire RAM d’un PC

Exemples d’accès à un périphérique :

Afficher un ’h’
Code source (en assembleur) en mode réel.

Afficher un ’h’ : Commentaire du code

I Le contrôleur vidéo affiche en mode texte tout ce qui
se trouve en B8000-B8FFF sous la forme de 25 lignes
de 80 words.
I Chacun de ces words est structuré en un byte qui est
le code ansi du caractère et en 8 bits représentant sa
couleur CrvbLRVB où :
RVB est la couleur du caractère ;
rvb est la couleur du fond ;
L pour "plus lumineux" ;
et C pour clignotant.
I Le précédent programme affichera un ’h’ gris
clignotant sur fond bleu à la première colonne de la
deuxième ligne.
Démarrage d’un ordinateur
Séance 10

Sommaire :
I À la mise sous tension : Démarrage hardware . . . ;

I Le BIOS . . . ;
I Le Secteur de boot . . . ;
I Un premier process sans BIOS . . .

À la mise sous tension

I L’alimentation met un certain temps avant de fournir
un courant stabilisé ;
I Dès que le courant est stable (soit timer, soit power
good détecté par la carte mère), READY est sous
tension (patte du processeur) ;
I CS :IP est chargé avec l’adresse FFFF0, le processeur
démarre son cycle ;
I En FFFF0, on trouve normalement un jmp vers une
adresse en ROM.
Le démarrage hardware est terminé, le software adressé
par FFFF0 est exécuté.
Le BIOS : son rôle
À la mise sous tension, un jmp est effectué vers un bout

de code qui :
I Effectue un check de périphériques, de la RAM, . . .
I Complète la table des interruptions ;
I Complète (charge) les routines d’interruption ;
I Cherche un périphérique de boot ;
I S’il le trouve, charge le premier secteur de ce
périphérique en mémoire à l’adresse 07C00 ;

I Remplace CS :IP par l’adresse 0000 :7C00.

Le Secteur de boot d’un DISK (ou USB)
I Le premier secteur du périphérique

I Enregistrement structuré de 512 bytes
000-439 : libre (zone de code)
440-443 : signature du disque (optionnel)
444-445 : 0x0000 (optionnel)
446-509 : description des 4 partitions primaires
510-511 : 0x55AA
De 000 à 439, on dispose de 440 bytes pour placer un
programme de boot.

Un process (programme) sans interruption

du BIOS
Il reste à placer ce programme, traduit en code machine,

dans le premier secteur d’un DISK (ou USB) et . . . à
rebooter le PC !
Coprocesseur mathématique
Séance 11

Sommaire :
I Introduction ;
I Intérêt et Format des données ;
I Les registres de données ;
I Les registres spéciaux ;
I La pile du x87 ;
I Les familles d’instructions ;
I Exemples de codes sources utilisant FPU
I Références.

Intérêts et Format des données

I Le FPU permet d’effectuer des calculs (des
opérations) sur des réels, plus précisement sur les
nombres en virgule flottante.
I Le format mathématique d’un nombre en virgule
flottante est : < Signe > Mantisse ∗ 2Exposant
Mantisse : elle est nomalisée ;
Base : elle vaut 2 ;
Exposant : il est limité et biaisé ; ce qui implique une
limitation du nombre de nombres représentables en
machine et l’introduction d’une erreur (relative).
I Le x87 utilise une représentation sur 80 bits :
1 bit pour le signe (0 ou 1) ;
15 bits pour l’exposant (exposant de 2) ;
64 bits pour la mantisse (< 2)
Intérêts et Format des données
I Le format (des données) utilisé est la représentation

en virgule flottante ;
I Permet de représenter des données de type : Entiers,
Packed, Réels ;
I Se caractérise par :
un plus grand représentable ;
un plus petit représentable ;
introduction d’une erreur relative ;
zéro n’est pas représentable (utilisation de SW.Tag pour
définir la valeur 0)


Les registres de données
I Le x87 dispose de 8 registres de 80 bits nommés :

ST0, ST1, ST2, ST3, ST4,ST5, ST6, ST7.
I Ces registres contiennent des données au format réel
virgule flottante.
I Ces registres se suivent de manière cyclique : ST0 ->
ST1 -> ST2 -> ST3 -> ST4 -> ST5 -> ST6 ->
ST7 -> ST0.
I La plupart des instructions utilisent ST0 (mais ST0
n’est pas toujours le même registre physique).


I La correspondance entre les 8 registres physiques et

les 8 registres nommés ST(i) se fait par un entier
compris entre 0 et 7 appelé SW.TOP (TOP du
registre spécial SW : Status Word).
Si SW.TOP=0, ST0 correspond au registre 0, . . . ST7
correspond au registre 7 ;
Si SW.TOP=1, ST0 correspond au registre 1, . . . ST7
correspond au registre 0 ;
etc . . .
2 instructions permettent de modifier SW.TOP ; il s’agit
de : FINCSTP et FDECSTP.

Les registres spéciaux : TW
I Le registre TW (Tag Word) de 16 bits contient une

description du contenu des 8 registres de données.
I C’est une description sur 2 bits pour chaque registre
de données :
00 : ST(i) contient une donnée valide ;
01 : ST(i) contient 0 ;
10 : ST(i) contient un nombre spécial (infini) ;
11 : ST(i) est vide.

Les registres spéciaux : CW

I Le registre CW (Control Word) de 16 bits contient
essentiellement des informations sur la méthode de
calcul en virgule flottante (arrondi et/ou précision).
I La méthode de calcul est décrite sur 2 soit dans le
champ AA (dans le cas de l’arrondi), soit dans le
champ PP dans les cas de la précision
AA = 00 : au plus proche ;
AA = 11 : tronqué ;
AA = 01 ou 10 : non utilisé.
PP = 00 : précision de 24 bits (réels courts) lors du
transfert vers la mémoire ;
PP = 10 : précision de 53 bits (réels longs) ;
PP = 11 : précision de 64 bits (réels temporaires) ;
PP = 01 : non utilisé
Les registres spéciaux : CW

Les registres spéciaux : SW
I Le registre SW (Status Word) de 16 bits contient le

champ TOP ;
I Le champ TOP permet de faire la liaison entre les
registres logiques et les registres physiques ;
I Les valeurs de TOP donnent le numéro du registre
physique correspondant à ST0.


I Le registre SW contient également 4 flags (il s’agit

de bits 3, 2, 1, 0) qui résument le résultat d’une
comparaison
I La position des bits 3, 2, 1, 0 de SW est telle que, si
on copie le registre SW dans le registre RFLAGS du
x86, on peut les utiliser comme si on avait exécuté
une instruction CMP du x86
3 = Zero (ZF) ;
2 = Parity (PF) ;
1 = Ajust (AF)
0 = Carry (CF).

Les registres spéciaux : CW et SW



La pile du x87
I Les 8 registres ST0 à ST7 du x87 sont accessibles
essentiellement comme une pile ;
I On peut dénombrer essentiellent 4 actions sur la pile
x87 :
L’initialisation de la pile (FINIT) ;
Le chargement d’une valeur au sommet de la pile avec
décalage dans la pile (FLD) ;
Le déchargement d’une valeur du sommet de la pile avec
décalage dans la pile (FST) ;
Les calculs effectués sur le ou les éléments au sommet
(exemple : FADD).
I Le x87 fonctionne en notation polonaise inversée
(NPI ou RPN).
Les Familles d’instructions
Toutes les instruction du FPU commencent par F :

I LD : pour le chargement sur la pile (LOAD) ;
I ST : pour le déchargement de la pile (STORE) ;
I I : pour les instructions qui traitent les entiers
(INTEGER) ;
I P : shift de la pile vers le bas (POP) ;
I Autres : comme par exemple ADD, SUB, COS,
SQRT, . . .

Utilisation FPU - code ASM : Exemple1

Utilisation FPU - code ASM : Exemple2

Références
I Manuel Intel chapitre 8 ;

Évolution des microprocesseurs
Séance 12

Sommaire :
I Historique ;
I Loi de Moore ;
I Co-processeurs ;
I Processeurs pipe-line ;
I classement SISD, SIMD ;
I Jeu d’instruction MMX ;
I Jeu d’instruction SSE ;
I Processeurs 64 bits ;
I Processeurs à plusieurs cores ;

Historique
Évolutions techniques majeures à partir du 4004 jusqu’aux

dernières séries des processeurs de la famille x86.
I 1971 : Le 4004, premier microprocesseur de Intel, sur
une seule puce ; permet d’effectuer des opérations sur

4 bits simultanément ;
I 1972 : Le microprocesseur 8008 permet un traitement
sur 8 bits simultanément.

Historique
I 1978 : processeurs à 16 bits et segmentation ; le 8086
et le 8088.
Le 8086 a des registres de 16 bits ;
il a des bus externes de données de 16 bits ;
il a 20 bits d’adressage qui donne 1Mb d’espace
adressable ;
Le 8088 est similaire au 8086 sauf qu’il a un bus de 8
bits de données externe ;
Le 8086 et 8088 introduisent la segmentation.
I 1982 : processeur x286.
Le x286 introduit le mode protégé dans l’architecture
IA-32.

Historique
I 1985 : processeurs x386.
Le x386 est le premier processeur 32 bits dans la famille
de l’architecture IA-32 ;
Introduction des registres 32 bits pour les opérandes et
l’adressage ;
La partie basse de chaque registre 32 bits offre les
propriétés des registres 16 bits des générations
précédentes ;
Le processeur offre un mode virtuel 8086 ;
Bus adresse 32 bits qui supporte 4Gb de mémoire
physique ;
Mémoire segmentée et modèle mémoire plat ;
Pagination avec une taille de 4Kb par page ;
Support pour les étapes parallèles.
Historique
I 1989 : processeurs x486.

Le x486 ajoute (augmente) la capacité d’exécution en
parallèle en élargissant les unités d’instruction de
décodage et d’exécution du x386 en 5 étapes pipelinées ;
Chaque étape opère en parallèle avec les autres ;
8Kb dans le premier niveau du cache qui augmente le
pourcentage d’instruction exécutable ;
Une FPU x87 intégré ;
Capacités de gestion du système et sauvegarde d’énergie.

Historique
I 1995 à . . . : processeurs Pentium.
Le processeur P6 était basé sur une micro-architecture
superscalaire ;
Utilisation des techniques de calcul parallèle ;
Pentium II, ajoute la technologie MMX à la famille P6 ;
Pentium III, introduit le Streaming SIMD Extensions
(SSE) à l’architecture IA-32 ;
SSE extensions offre un nouvel ensemble de registres 128
bits et la possibilité de réaliser des opérations SIMD sur
des packets de valeurs à virgule flottante simple
précision ;
Pentium 4, introduit le Streaming SIMD Extension2
(SEE2) ;
Pentium MMX (MultiMedia eXtension)
Historique
I Pentium MMX (MultiMedia eXtension) :

Ajout d’un ensemble d’instructions multimédia ;
Possibilité d’utiliser des instructions supplémentaires sur
64 bits via 8 registres spécialisés en 64 bits (même si le
le processeur reste totalement 32 bits) ;

Historique
I Processeurs Intel Core : 2008 (première génération)

. . . 2018 (neuvième génération).
diminution de la finesse de gravure ;
augmentation de la fréquence du FSB (Le front side bus
(FSB), aussi appelé bus système) ;
mémoire cache de 6 à 12 Mo ;
ajout de 47 nouvelles instructions SSE4 ;
introduction de l’hyperthreading ;
enhanced virtualization technology ;
...

Loi de Moore
I Formulé pour la première fois en 1965 : Elle postule

le doublement annuel des performances des circuits
intégrés (mémoires et processeurs) à prix constant ;
I La loi a été revue en 1975 : Le doublement aurait
lieu tous les 18 mois c’est-à-dire environ tous les
deux(2) ans ;
I Moore estime qu’elle se poursuivra jusqu’en 2017,
date à laquelle elle devrait rencontrer des contraintes
physiques ;

Loi de Moore

Co-processeurs
Les processeurs spécialisés permettent de soulager

fortement le processeur central. On peut citer entre autre :
I le co-processeur Mathématique ;
I le co-processeur D.M.A. ;
I le co-processeur Graphique ;
I ...

Processeurs pipeline : Architecture pipeline
Dans une structure standard d’un microprocesseur (sans

pipeline),
I le traitement des instructions en assembleur se fait
les unes à la suite des autres ;

I tant que l’exécution d’une instruction n’est pas
terminée, l’instruction suivante n’est pas exécutée.

Processeur sans l’architecture pipeline

Processeur sans l’architecture pipeline
Les instructions sont effectuées les unes après les autres.

Ces instructions sont découpées en :
I IF Instruction fetch ou lecture de l’instruction ;
I ID Instruction decode ou décodage de l’instruction ;
I EX Execute ou exécution de l’instruction ;
I MEM Lecture en mémoire éventuelle ;
I WB Write Back ou stocker le résultat.

Un microprocesseur de type pipeline va décomposer les

séquences,
I pour traiter plusieurs instructions en même temps ;
I et maximiser l’utilisation des bus externes (bus de
données, bus d’adresses et bus de commandes)

Le pipeline est lié à la mémoire cache L1.
Le x486 est le premier microprocesseur PC à utiliser cette
architecture pipiline.


Dans le cas d’une structure pipeline, l’exécution d’une
instruction est décomposée en :
I Chargement de l’instruction dans le processeur,
utilisation des bus externes ;

I Décodage à l’intérieur du processeur ;
I Exécution de l’instruction ;
I Renvoi du résultat sur le bus.
Comme seules la première et la dernière séquence utilisent

les bus externes, le cycle de l’instruction suivante peut
commencer en même temps que le décodage interne de
l’instruction.
Processeur doté de l’architecture pipeline

Processeur doté de l’architecture pipeline

I Ici, les pipelines permettent d’effectuer les
instructions en parallèle en utilisant des parties
différentes du circuit.
I En augmentant encore le nombre de pipelines, on
obtient des processeurs super scalaires.
I Les 5 premières instructions s’exécuteront en 9
cycles, et le processeur sera capable de terminer une
instruction par cycle à partir de la cinquième, bien
que chacune d’entre elles nécessite 5 cycles pour
s’exécuter complètement.
I Au cinquième cycle, tous les étages sont en cours
d’exécution.
Classification : SISD, SIMD, MISD, MIMD
I Classification des machines parallèles (une machine

parallèle est essentiellement un ensemble de
processeurs qui coopèrent et communiquent).
I On distingue classiquement quatre types principaux
de parallélisme :
SISD (Single Instruction Single Data) ;
SIMD (Single Instruction Multiple Data) ;
MISD (Multiple Instruction Single Data) ;
MIMD (Multiple Instruction Multiple Data) ;

I Une machine SISD (Single Instruction Single Data) :

une seule instruction est exécutée à un moment
donné et une seule donnée est traitée à un moment
donné.
I Une machine SIMD (Single Instruction Multiple
Data) : une machine qui exécute à tout instant une
seule instruction, mais qui agit en parallèle sur
plusieurs données.

I Une machine MISD (Multiple Instruction Single

Data) : peut exécuter plusieurs instructions en même
temps sur la même donnée.
I Une machine MIMD (Multiple Instruction Multiple
Data) : chaque processeur peut exécuter un
programme différent sur des données différentes.

Jeu d’instruction MMX
I Ajout de 8 registres 64 bits MM0 à MM7 ;

I Ajout de 57 instructions de type SIMD qui
permettent d’utiliser ces registres MMX comme un
ensemble de valeurs (2 doubles ou 4 words ou 8
bytes).

3DNow !
I Jeu d’instructions multimédia développé par AMD ;

I C’est la réponse de AMD à Intel ;
I Regroupe 21 instructions et huit registres 64 bits
FP/MMX ;
I AMD, avec son K6, ajoute les mêmes instruction que
MMX, aussi en SIMD, mais en calcul flottant.

Jeu d’instruction SSE
I Streaming Simd Extensions.

I Intel propose 70 instructions supplémentaires pour
son Pentium III ainsi que 8 nouveaux registres 128
bits XMM0 à XMM7.
I Ces registres sont souvent considérés comme
contenant 4 flottants de 32 bits.

Jeu d’instruction SSE2, SSE3
I Streaming Simd Extensions-2 (SSE2).

Intel propose 144 instructions supplémentaires pour son
Pentium 4.
Les registres XMM peuvent être aussi considérés comme
contenant 2 flottants de 64 bits.
I Streaming Simd Extensions-3 (SSE3) : Intel et AMD
proposent des instructions supplémentaires orientées
calcul 3D.

Jeu d’instruction SSSE3, SSE4

I Supplemental Streaming Simd Extensions-3
(SSSE3) :
16 nouvelles instructions proposées sur les processeurs
Intel et AMD.
I Streaming Simd Extensions-4 (SSE4) :
De nouvelles instructions proposées sur les processeurs
Intel et AMD.
Ce SSE4 est annoncé avec des divergences pour ces deux
constructeurs.
Possibilité d’une situation d’incompatibilité : des
programmes qui fonctionnent sur AMD et pas sur Intel
et inversement.

Processeurs 64 bits
I Conjointement à ces nouveaux jeux d’instructions, les
registres classiques augmentent de taille.
I Les registres EAX, EBX, . . . sont étendus à 64 bits et
s’appelle RAX, RBX, . . .
I Augmentation du nombre de registres classiques
étendus à 64 bits.
I Les adresses sont sur 64 bits, ce qui offre un espace
adressable de ≈ 16.1018 bytes.
I Les bus d’adresses des processeurs actuels sont
cependant limités à 40, 42 ou 44 fils.

Processeurs à plusieurs cores
On parle de : dual core ; quad core, . . .

I Plusieurs processeurs dans un même circuit intégré.
I Ceci permet de multiplier théoriquement par 2, voir
par 4 ou plus la puissance du circuit.

I Ces processeurs sont exploités à l’aide de process qui
utilisent des threads (2, 4, . . . ).

I Ces threads peuvent être vus comme des process qui
s’exécutent avec des registres RIP différents (2, 4,

. . . ) mais qui partagent tout le reste.

Annexe
Crédits
Ces slides sont le support pour la présentation orale de l’activité
d’apprentissage MIC2-MIC à HE2B-ÉSI
Crédits
Les distributions Ubuntu et/ou debian
du système d’exploitation GNU Linux.
LaTeX/Beamer comme système d’édition.
Git et GitHub pour la gestion des versions et le suivi.
GNU make, rubber, pdfnup, . . . pour les petites tâches.
Images et icônes
deviantart, flickr, The Noun Project

Mic Presentation

Transféré par

Informations du document

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

Mic Presentation

Transféré par

Droits d'auteur :

Formats disponibles

Microprocesseurs

J. Beleho (bej) A. Hallal (hal) (*) . . . Et tous les précédents . . .

Haute école de Bruxelles-Brabant

Année académique 2020 / 2021

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 1 / 290

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 2 / 290

Objectifs du cours Supports-Ressources

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 3 / 290

I Les liens avec les autres composants ;

I Sa programmation (son jeu d’instructions) ;

Remarque : Nous nous concentrerons que sur les

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 5 / 290

Remarque : Les slides sont une structure du cours et pas

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 6 / 290

Évaluation de l’UE MIC2

Une cote pour toutes les activités d’apprentissage (AA) :

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 7 / 290

La Carte Mère La Mémoire Cache

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 8 / 290

Schéma Carte mère PC à microprocesseur :

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 9 / 290

Schéma Carte mère PC à microprocesseur :

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 10 / 290

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 11 / 290

Rôle de la carte mère

La carte mère est le coeur de tout ordinateur. Elle est

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 12 / 290

Structure de la carte mère

Une carte multiprocesseur peut accueillir plusieurs

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 14 / 290

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 15 / 290

Les ordinateurs récents possèdent plusieurs niveaux de

Cache, pour Level 1 Cache) est directement intégrée

Cache, pour Level 2 Cache) est située au niveau du

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 17 / 290

I La mémoire cache de troisième niveau (appelée L3

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 18 / 290

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 19 / 290

Microprocesseur 64 bits : Schéma simplifié

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 20 / 290

Microprocesseur : Fonctionnement de base

I Le microprocesseur (MPU, Micro-Processing Unit)

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 21 / 290

Microprocesseur : Fonctionnement de base

I Toutes les informations qu’utilise le microprocesseur

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 22 / 290

Microprocesseur : Les composantes

I des registres : RAX, RBX, RCX, RDX, . . .

I une unité de contrôle (UC ou CU ) dans laquelle on

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 23 / 290

Microprocesseur : Les composantes

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 24 / 290

Code machine et instructions

I 0x0102030405060708 : adresse sur 64 bits ;

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 25 / 290

I Le programme est une suite d’instructions stockées

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 26 / 290

Fonctionnement : Jeu d’instructions

Fonctionnement : Cycle d’exécution d’une

I Lors de son exécution, une instruction est

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 28 / 290

Fonctionnement : Cycle d’exécution d’une

I Ces micro-opérations (Fetch, Decode, Execute) sont

(HE2B - ÉSI) Microprocesseurs 2020 – 2021 29 / 290