cours mp mc .pdf



Nom original: cours_mp_mc.pdf

Ce document au format PDF 1.5 a été généré par TeX / pdfTeX-1.40.11, et a été envoyé sur fichier-pdf.fr le 15/05/2020 à 18:28, depuis l'adresse IP 196.229.x.x. La présente page de téléchargement du fichier a été vue 381 fois.
Taille du document: 2.5 Mo (120 pages).
Confidentialité: fichier public
🎗 Auteur vérifié


Aperçu du document


République Tunisienne
Ministère de l’Enseignement Supérieur et de la Recherche Scientifique
Université de Tunis El Manar
École Nationale d’Ingénieurs de Tunis
Département de Génie Électrique

Microprocesseurs et Microcontrôleurs

Support de cours

1ère année Génie Électrique
Joseph Haggège
Maı̂tre de Conférences à l’ENIT

2016

Table des matières
1 Historique et évolution des calculateurs

1

2 Calculateurs numériques
3
2.1 Architecture et organisation d’un calculateur . . . . . . . . . . . . . . . . . 3
2.2 Constituants du processeur . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2.1 Registres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2.2 Unité arithmétique et logique . . . . . . . . . . . . . . . . . . . . . 4
2.2.3 Unité de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Organisation des registres et de la mémoire . . . . . . . . . . . . . . . . . 6
2.3.1 Structure des registres . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3.2 Constitution de la mémoire . . . . . . . . . . . . . . . . . . . . . . 6
2.3.3 Représentation des données en mémoire . . . . . . . . . . . . . . . 7
2.4 Microprocesseurs et microcontrôleurs . . . . . . . . . . . . . . . . . . . . . 8
2.4.1 Implémentations matérielles d’un calculateur . . . . . . . . . . . . . 8
2.4.2 Applications des microprocesseurs et microcontrôleurs . . . . . . . . 8
2.4.3 Exemples de microprocesseurs et microcontrôleurs . . . . . . . . . . 8
2.5 Interconnexion des éléments d’un calculateur . . . . . . . . . . . . . . . . . 9
2.5.1 Architectures Von Neumann et Harvard . . . . . . . . . . . . . . . 9
2.5.2 Circulation de l’information dans un calculateur . . . . . . . . . . . 10
2.6 Aspects matériels et représentation fonctionnelle des microprocesseurs et
microcontrôleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3 Structure et fonctionnement d’un processeur
3.1 Représentation des instructions . . . . . . . . . . . . . . . . . . . . . . .
3.1.1 Codage binaire en mémoire . . . . . . . . . . . . . . . . . . . . .
3.1.2 Langage machine et langage assembleur . . . . . . . . . . . . . . .
3.1.3 Exemples d’instructions en assembleur . . . . . . . . . . . . . . .
3.2 Modes d’adressage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.2 Modes d’adressage élémentaires . . . . . . . . . . . . . . . . . . .
3.2.3 Modes d’adressage complexes . . . . . . . . . . . . . . . . . . . .
3.3 Exécution d’une instruction par le processeur . . . . . . . . . . . . . . .
3.3.1 Étapes élémentaires et datapath . . . . . . . . . . . . . . . . . . .
3.3.2 Datapath pour l’exécution d’instructions opérant sur des registres
3.3.3 Datapath pour l’accès à la mémoire par le processeur . . . . . . .
1ère année Génie Électrique

.
.
.
.
.
.
.
.
.
.
.
.

13
13
13
14
15
15
15
16
17
19
19
21
21

J. Haggège

iv

Table des matières

3.4

3.5

3.6

3.3.4 Datapath pour les instructions de branchement
Contrôle du datapath . . . . . . . . . . . . . . . . . . .
3.4.1 Rôle du séquenceur . . . . . . . . . . . . . . . .
3.4.2 Séquenceur câblé . . . . . . . . . . . . . . . . .
3.4.3 Séqenceur microprogrammé . . . . . . . . . . .
Performances temporelles d’un processeur . . . . . . .
3.5.1 Mesure des performances . . . . . . . . . . . . .
3.5.2 Amélioration des performances . . . . . . . . .
3.5.3 Architectures CISC et RISC . . . . . . . . . . .
Exécution d’un programme en mémoire centrale . . . .
3.6.1 Structure d’un programme exécutable . . . . . .
3.6.2 Appel de sous-programmes et pile de sauvegarde
3.6.3 Interruptions et exceptions . . . . . . . . . . . .

4 Systèmes à microprocesseurs
4.1 Constitution d’un système à microprocesseur . . . . . .
4.2 Circuits mémoires . . . . . . . . . . . . . . . . . . . . .
4.2.1 Mémoires ROM et RAM . . . . . . . . . . . . .
4.2.2 Schéma fonctionnel d’une mémoire . . . . . . .
4.2.3 Interfaçage microprocesseur/mémoire . . . . . .
4.2.4 Chronogrammes de lecture/écriture en mémoire
4.2.5 Connection de plusieurs boı̂tiers mémoire . . . .
4.2.6 Décodage d’adresses . . . . . . . . . . . . . . .
4.2.7 Classification des mémoires . . . . . . . . . . .
4.3 Circuits d’interfaces . . . . . . . . . . . . . . . . . . . .
4.3.1 Définitions . . . . . . . . . . . . . . . . . . . . .
4.3.2 Adressage des ports d’E/S . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

5 Le microcontrôleur STM8
5.1 Description matérielle . . . . . . . . . . . . . . . . . . .
5.1.1 Présentation du microcontrôleur STM8 . . . . . .
5.1.2 Brochage et architecture interne . . . . . . . . . .
5.1.3 Structure du processeur STM8 core . . . . . . . .
5.1.4 Organisation de l’espace d’adressage du STM8 . .
5.2 Programmation en assembleur du STM8 . . . . . . . . .
5.2.1 Jeu d’instructions . . . . . . . . . . . . . . . . . .
5.2.2 Modes d’adressage . . . . . . . . . . . . . . . . .
5.2.3 Chargement et transferts de données . . . . . . .
5.2.4 Opérations sur la pile . . . . . . . . . . . . . . . .
5.2.5 Opérations logiques . . . . . . . . . . . . . . . . .
5.2.6 Instructions de branchement . . . . . . . . . . . .
5.2.7 Opérations arithmétiques . . . . . . . . . . . . . .
5.2.8 Interruptions . . . . . . . . . . . . . . . . . . . .
5.2.9 Réalisation d’un programme en assembleur STM8
Microprocesseurs et Microcontrôleurs

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

26
27
27
28
28
31
31
32
33
34
34
35
37

.
.
.
.
.
.
.
.
.
.
.
.

41
41
41
41
42
43
44
45
46
48
49
49
50

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

53
53
53
54
56
56
59
59
59
62
63
64
66
68
69
72

ENIT 2016

v

Table des matières

5.3

5.2.10 Environnement de développement intégré
Programmation des interfaces du STM8 . . . .
5.3.1 Ports d’entrées/sorties GPIO . . . . . .
5.3.2 Timers . . . . . . . . . . . . . . . . . . .
5.3.3 Convertisseur analogique/numérique . .

Bibliographie

1ère année Génie Électrique

pour
. . .
. . .
. . .
. . .

le STM8
. . . . . .
. . . . . .
. . . . . .
. . . . . .

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

75
79
79
85
96
107

J. Haggège

Table des figures
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
2.13
2.14
2.15
2.16

Architecture d’un calculateur . . . . . . . . . . . . . . . . . . .
Unité arithmétique et logique . . . . . . . . . . . . . . . . . . .
Registre de mémorisation . . . . . . . . . . . . . . . . . . . . . .
Représentation de l’unité de contrôle . . . . . . . . . . . . . . .
Registres du processeur . . . . . . . . . . . . . . . . . . . . . . .
Schéma fonctionnel des registres . . . . . . . . . . . . . . . . . .
Mémoire centrale . . . . . . . . . . . . . . . . . . . . . . . . . .
Schéma fonctionnel de la mémoire . . . . . . . . . . . . . . . . .
Rangement en mémoire de données sur plusieurs octets . . . . .
Architecture de Von Neumann . . . . . . . . . . . . . . . . . . .
Architecture Harvard . . . . . . . . . . . . . . . . . . . . . . . .
Rangement d’un programme en mémoire . . . . . . . . . . . . .
Bus d’un calculateur . . . . . . . . . . . . . . . . . . . . . . . .
Exemples de boı̂tiers pour les microprocesseurs et microntrôleurs
Schéma fonctionnel d’un microprocesseur . . . . . . . . . . . . .
Schéma fonctionnel d’un microcontrôleur . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

3
5
5
5
6
6
7
7
8
9
9
10
11
11
12
12

3.1
3.2
3.3
3.4
3.5
3.6

Format d’une instruction . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Élaboration d’un programme en langage machine . . . . . . . . . . . . . .
Formats des instructions selon le mode d’adressage utilisé . . . . . . . . . .
Formats des instructions utilisant des modes d’adressage complexes . . . .
Datapath pour l’exécution d’une instruction à adressage registre . . . . . .
Chronogramme de l’exécution d’une instruction opérant sur les registres du
processeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Multiplexeur sur n bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Datapath pour les instructions avec adressage direct de la mémoire centrale
Chronogramme de l’exécution d’une instruction avec accès à la mémoire
centrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Datapath implémentant l’adressage indirect de la mémoire centrale . . . .
Datapath autorisant les instructions de branchement . . . . . . . . . . . .
Structure du séquenceur (figure 2.4 reproduite) . . . . . . . . . . . . . . .
Séquenceur câblé pour le contrôle du datapath . . . . . . . . . . . . . . . .
Fonction logique combinatoire réalisée à l’aide d’une mémoire morte . . . .
Principe du séquenceur microprogrammé . . . . . . . . . . . . . . . . . . .
Implémentation des instructions de branchement dans le séquenceur . . . .

13
14
17
18
21

3.7
3.8
3.9
3.10
3.11
3.12
3.13
3.14
3.15
3.16

1ère année Génie Électrique

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

22
22
23
25
25
27
27
28
29
29
30

J. Haggège

viii

Table des figures

3.17
3.18
3.19
3.20
3.21
3.22
3.23
3.24
3.25
3.26

Chronogramme de l’exécution d’une suite d’instructions . .
Exécution d’une suite d’instructions en utilisant le principe
Datapath avec pipeline . . . . . . . . . . . . . . . . . . . .
Structure d’un programme chargé en mémoire . . . . . . .
Appels de sous-programmes . . . . . . . . . . . . . . . . .
Structure de la pile . . . . . . . . . . . . . . . . . . . . . .
Principe des interruptions . . . . . . . . . . . . . . . . . .
Table des vecteurs d’interruptions . . . . . . . . . . . . . .
Traitement des requêtes d’interruptions imbriquées . . . .
Utilisation d’un contrôleur d’interruptions . . . . . . . . .

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

32
32
33
35
35
36
38
38
39
40

4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
4.11
4.12
4.13
4.14
4.15
4.16
4.17

Schéma fonctionnel d’un circuit mémoire . . . . . . . . . . . .
Création d’un bus de données bidirectionnel . . . . . . . . . .
Connexion d’un circuit mémoire à un microprocesseur . . . . .
Représentation utilisant des bus . . . . . . . . . . . . . . . . .
Chronogrammes de lecture d’un circuit mémoire . . . . . . . .
Demande de temps d’attente par une mémoire lente . . . . . .
Chronogrammes d’écriture d’un circuit mémoire . . . . . . . .
Utilisation des signaux de chip select . . . . . . . . . . . . . .
Mapping mémoire obtenu avec le câblage de la figure 4.8 . . .
Principe du décodage d’adresses . . . . . . . . . . . . . . . . .
Table de vérité d’un décodeur 3 vers 8 . . . . . . . . . . . . .
Mapping mémoire obtenu par décodage d’adresses complet . .
Classification des mémoires . . . . . . . . . . . . . . . . . . .
Interfaces d’entrées/sorties dans un système à microprocesseur
Schéma fonctionnel d’un circuit d’entrées/sorties . . . . . . . .
Adressage cartographique des entrées/sorties . . . . . . . . . .
Adressage indépendant des entrées/sorties . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

42
42
43
43
44
44
45
46
47
47
48
48
48
50
50
51
51

5.1
5.2
5.3
5.4
5.5
5.6
5.7
5.8
5.9
5.10
5.11
5.12
5.13
5.14
5.15
5.16

Carte à microcontrôleur STM8-Discovery . . . . . . . . . . . . . . . . .
Brochage du microcontrôleur STM8 . . . . . . . . . . . . . . . . . . . .
Schéma blocs du microcontrôleur STM8 . . . . . . . . . . . . . . . . .
Mapping de la mémoire et des périphériques du microcontrôleur STM8
Adressage indirect de l’espace mémoire du STM8 . . . . . . . . . . . .
Instructions de décalage, de rotation et de permutation . . . . . . . . .
Gestion des interruptions dans le STM8 . . . . . . . . . . . . . . . . . .
Chaı̂ne de développement logicielle pour le STM8 . . . . . . . . . . . .
Environnement de développement intégré STVD . . . . . . . . . . . . .
Débogage d’un programme dans l’environnement STVD . . . . . . . . .
Fichier mapping.inc contenant les définitions des adresses des segments
Fichier mapping.asm créé pour la déclaration des segments en mémoire
Fichier main.asm généré lors de la création d’un projet . . . . . . . . .
Organisation des entrée/sortie du STM8 . . . . . . . . . . . . . . . . .
Structure des lignes d’entrée/sortie d’un port du STM8 . . . . . . . . .
Commande d’une LED à travers une ligne d’entrée/sortie du STM8 . .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

53
54
55
57
61
65
71
72
76
76
77
77
78
79
80
81

Microprocesseurs et Microcontrôleurs

. . . . . . .
du pipeline
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

ENIT 2016

ix

Table des figures

5.17
5.18
5.19
5.20
5.21
5.22
5.23
5.24
5.25
5.26
5.27
5.28
5.29
5.30
5.31
5.32
5.33
5.34
5.35
5.36
5.37
5.38
5.39
5.40

Extrait du fichier STM8S105C_S.ASM . . . . . . . . . . . . . . . . . . . . . .
Extrait du fichier STM8S105C_S.INC . . . . . . . . . . . . . . . . . . . . . .
Schéma de principe d’un timer . . . . . . . . . . . . . . . . . . . . . . . . .
Registres de capture et de comparaison associés un timer . . . . . . . . . .
Chronogrammes des évènements dans un timer . . . . . . . . . . . . . . . .
Génération d’un signal MLI au moyen d’un timer . . . . . . . . . . . . . .
Chronogrammes des signaux d’un timer en mode MLI . . . . . . . . . . . .
Génération de signaux MLI complémentaires avec insertion de temps morts
Chronogrammes des signaux MLI avec temps morts . . . . . . . . . . . . .
Application des timers : commande d’un pont en H . . . . . . . . . . . . .
Structure du timer de base TIM4 . . . . . . . . . . . . . . . . . . . . . . .
Structure des timers à usage général TIM2 et TIM3 . . . . . . . . . . . . .
Structure du timer à contrôle avancé TIM1 . . . . . . . . . . . . . . . . . .
Signal carré de fréquence 100 Hz généré à l’aide du timer TIM4 . . . . . .
Signaux MLI complémentaires avec insertion de temps morts générés par
le timer TIM1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Caractéristique entrée/sortie d’un convertisseur A/N sur n bits . . . . . . .
Comparateur analogique . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Convertisseur analogique/numérique flash sur deux bits . . . . . . . . . . .
Convertisseur numérique/analogique à réseau R/2R . . . . . . . . . . . . .
Convertisseur analogique/numérique à approximations successives . . . . .
Algorithme de conversion A/N par approximations successives . . . . . . .
Chronogrammes d’un cycle de conversion A/N sur 8 bits par approximations successives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Schéma synoptique du convertisseur A/N intégré au STM8 . . . . . . . . .
Alignement des bits du résultat d’une conversion A/N . . . . . . . . . . . .

1ère année Génie Électrique

84
85
85
86
87
87
88
89
89
90
91
92
92
94
96
97
97
98
99
99
100
101
102
103

J. Haggège

Liste des tableaux
4.1

Exemples de ports d’un système à microprocesseur . . . . . . . . . . . . . 49

5.1
5.2
5.3
5.4
5.5
5.6
5.7
5.8

Jeu d’instruction du STM8 . . . . . . . . . . . . . . . . . . .
Instructions de branchements conditionnels du STM8 . . . .
Table des vecteurs d’interruptions du STM8 . . . . . . . . .
Configuration des ports d’entrées/sorties du STM8 . . . . .
Adresses des ports d’entrées/sorties du STM8 . . . . . . . .
Caractéristiques des timers du STM8 . . . . . . . . . . . . .
Mapping des registres du timer TIM4 . . . . . . . . . . . . .
Mapping des registres du convertisseur analogique numérique

1ère année Génie Électrique

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

59
67
70
82
83
91
93
104

J. Haggège

Chapitre 1
Historique et évolution des
calculateurs
La nécessité de disposer de moyens permettant d’effectuer des calculs longs et répétitifs,
avec un faible risque d’erreur, a conduit à concevoir des instruments et des machines
de plus en plus complexes dont la liste suivante résume, de manière très incomplète, les
principales évolutions.
Machines mécaniques
• Premiers instruments de calcul, développés depuis l’antiquité et utilisés jusqu’au début du xxème siècle : bouliers, abaques, règles à calculer, compas de
proportion.
• Première vraie machine à calculer : Blaise Pascal, 1642, machine à additionner.
• Machine à multiplier : Gottfried Wilhelm Leibniz, 1694, basée sur les travaux
de John Neper (1617, logarithmes).
• Première machine programmable : métier à tisser, Joseph Marie Jacquard,
xviiième siècle, machine à cartes perforées.
• Machine programmable universelle : Charles Babbage, xviiième siècle, non réalisable avec les technologies de l’époque (machines à vapeur), principe des machines actuelles.
Machines électromécaniques
• Machine à calculer à cartes perforées : Hermann Hollerith, 1885, facilite le
recensement américain.
• Machines industrielles à base de relais électromécaniques pour la comptabilité
et les statistiques, Howard Aiken et George Stibitz, 1936-1939.
Machines électroniques
• Première machine à calculer électronique : ENIAC, 1944, John Eckert et John
William Mauchly, 18000 tubes électroniques, machine à programme câblé.
• Concept de machine universelle à programme enregistré : Alan Turing, John
Von Neumann, 1946, instructions stockées dans la mémoire du calculateur :
ordinateur.
1ère année Génie Électrique

J. Haggège

2

Chapitre 1. Historique et évolution des calculateurs

• Premier ordinateur commercialisé : SSEC d’IBM, 1948.
• Ordinateur à transistors : 1963, PDP5 de Digital Equipment Corporation (DEC),
introduction des mémoires à ferrites : mini-ordinateurs.
• Micro-ordinateurs : 1969-70, utilisation des circuits intégrés LSI.
• Premier microprocesseur : Intel, 1971, microprocesseur 4004, puis 8008, premier
micro-ordinateur : le Micral, 1973, France, puis l’Altair, 1975, États-Unis.
• Autres microprocesseurs : 8080 et 8085 d’Intel, 6800 de Motorola, Z80 de Zilog :
microprocesseurs 8 bits, début des années 1980.
• Microprocesseurs 16 bits : 8086/8088 d’Intel, 68000 de Motorola.
• Microprocesseurs 32 bits en 1986 : 80386 d’Intel et 68020 de Motorola.
• Fabrication en grandes séries des micro-ordinateurs : 1977, Apple, Commodore,
Tandy, IBM PC + MS–DOS (Microsoft) en 1981.
Machines actuelles
• Ordinateurs de plus en plus puissants, basés sur des microprocesseurs performants : Pentium, Power PC.
• Nouvelles architectures de microprocesseurs : RISC.
• Applications multimédia, réseaux.
• Systèmes embarqués : microcontrôleurs, processeurs de traitement de signal
(DSP).

Microprocesseurs et Microcontrôleurs

ENIT 2016

Chapitre 2
Calculateurs numériques
2.1

Architecture et organisation d’un calculateur

Un calculateur est un système constitué d’un ensemble complexe de circuits électroniques
numériques permettant d’effectuer une suite de traitements, tels que des opérations arithmétiques et logiques, sur des données binaires. Le séquencement de ces opérations doit
pouvoir être imposé arbitrairement à l’aide d’un programme enregistré dans une mémoire,
à l’exclusion de toute modification matérielle des circuits.
L’architecture d’un calculateur, représentée sur la figure 2.1, montre que l’élément de base
de celui-ci est le processeur, appelé également unité centrale de traitement, (UCT ou CPU,
Central Processing Unit).
processeur (unité centrale de traitement)
horloge

registres

unité
de contrôle

unité
arithmétique
et logique
(UAL)

: ordre ou commande
: données

unité
de
transfert

unité
d'entrées/
sorties

monde extérieur
(périphériques,
capteurs,
actionneurs, ...)

mémoire
centrale

Figure 2.1 – Architecture d’un calculateur
Le processeur est réalisé autour des trois éléments suivants :
• l’unité arithmétique et logique (UAL, ALU : Arithmetic and Logic Unit) qui représente l’organe de calcul du calculateur ;
• les registres qui sont des zones de stockage pour les données de travail de l’UAL tels
que les opérandes ou les résultats intermédiaires ;
1ère année Génie Électrique

J. Haggège

4

Chapitre 2. Calculateurs numériques

• l’unité de contrôle (UC, CU : Control Unit) qui envoie les ordres, sous la forme de
signaux de commande, à tous les autres éléments du calculateur afin d’exécuter le
programme.
Le support matériel de la circulation des signaux électriques à l’intérieur et à l’extérieur
du calculateur est appelé unité de transfert. Il s’agit d’un ensemble de circuits logiques
permettant d’aiguiller les différents signaux entre les éléments du calculateur, comme par
exemple le transfert de données entre les registres et la mémoire centrale ou l’UAL.
Les échanges de données entre le calculateur et le monde extérieur se font par l’intermédiaire d’une unité d’entrées/sorties contenant les circuits électroniques permettant d’adapter les informations qui se présentent sous forme de signaux analogiques ou numériques
en provenance ou à destination, respectivement, de capteurs ou d’actionneurs, ainsi que
de tout autre périphérique (interface de communication, interface homme/machine, . . .)
Finalement, les échanges d’ordres et de données dans le calculateur sont synchronisés
par un circuit d’horloge qui délivre des impulsions, constituant le signal d’horloge, à des
intervalles de temps fixes.

2.2
2.2.1

Constituants du processeur
Registres

Un registre, tel que celui représenté sur la figure 2.3 est un ensemble de bascules mémoires, généralement des bascules D munies un signal d’horloge commun, permettant de
mémoriser les états binaires présents sur leurs entrées. L’écriture d’une donnée dans un
tel registre consiste à présenter celle-ci sur les entrées puis à appliquer une impulsion sur
l’entrée d’horloge du registre. La lecture d’une donnée se fait en reliant, à l’aide d’un
circuit de multiplexage, les sorties du registre aux entrées de l’élément qui va utiliser ces
données (mémoire, registre ou UAL). Un processeur contient, en général, un nombre plus
ou moins important de registres. La sélection d’un registre particulier en vue de sa lecture
ou de son écriture se fait à l’aide d’un circuit de décodage.

2.2.2

Unité arithmétique et logique

L’unité arithmétique et logique, dont la représentation est donnée par la figure 2.2, est
un circuit numérique combinatoire recevant en entrée deux mots binaires A et B sur n
bits, appelés opérandes, et fournissant en sortie un mot binaire R, également sur n bits,
résultat d’une opération effectuée sur les opérandes. La sélection de l’opération se fait en
appliquant à une autre entrée, notée F , un mot binaire sur p bits permettant de choisir
une opération parmi 2p .
Les opérations généralement effectuées par une UAL sont les fonctions logiques combinatoires élémentaires (ET, OU, NON, . . .) ainsi que l’addition et la soustraction sur des
nombres entiers signés. Certaines UAL peuvent également effectuer des multiplications et
des divisions. En plus du résultat, l’UAL élabore un ensemble de variables booléennes,
appelées indicateurs (flags), dont l’état est fonction du résultat obtenu suite à la dernière
opération effectuée (résultat positif ou nul, débordement arithmétique, présence d’une
Microprocesseurs et Microcontrôleurs

ENIT 2016

5

2.2. Constituants du processeur

retenue, division par zéro, etc.). Ces indicateurs sont mémorisés dans un registre appelé
registre d’état du processeur, afin de pouvoir être éventuellement utilisés par l’instruction
suivante du programme.
indicateurs
m bits

n bits

opérandes

A

n bits

I
n bits

Q0

.
.
.

D

R
résultat

UAL

D0

.
.
.

n bits
Q

Dn-1 Qn-1

n bits

B

p bits

CLK

F
sélection
de la fonction

Figure 2.3 – Registre de mémorisation
Figure 2.2 – Unité arithmétique et logique

2.2.3

Unité de contrôle

état
interne
calcul
état
suivant

CLK

D
Q
registre
mémoire

décodeur

.
.
.

signaux de contrôle

instructions + indicateurs

L’unité de contrôle est un circuit numérique séquentiel, ou séquenceur, pouvant être modélisé par le schéma de la figure 2.4, dont le rôle est d’activer les signaux de commande des
différents éléments du calculateur, dans l’ordre nécessaire à l’exécution d’une instruction
du programme, celle-ci étant codée sous la forme d’un mot binaire propre à chaque instruction. Un tel circuit est construit autour d’un registre de mémorisation qui maintient
une valeur binaire, représentant l’état interne du séquenceur (à ne pas confondre avec
le registre d’état du processeur). Cet état est actualisé à chaque front d’horloge par une
fonction combinatoire admettant comme entrées :
• l’état interne actuel ;
• l’état des indicateurs ;
• le code binaire symbolisant l’instruction en cours d’exécution.

séquenceur

Figure 2.4 – Représentation de l’unité de contrôle
Les signaux de contrôle sont élaborés à l’aide d’une fonction combinatoire de décodage,
à partir de la valeur actuelle de l’état interne, des indicateurs ainsi que du code binaire
représentant l’instruction.
1ère année Génie Électrique

J. Haggège

6

Chapitre 2. Calculateurs numériques

2.3

Organisation des registres et de la mémoire

2.3.1

Structure des registres

Les registres contenus dans le processeur sont en nombre généralement réduit, ne dépassant
pas une vingtaine dans la plupart des cas. Chacun d’entre eux possède un numéro, codé
sur un nombre m de bits, qui permet de l’identifier et de le désigner parmi l’ensemble
des N = 2m registres, comme le montre la figure 2.5. Un même processeur peut contenir
des registres de différentes tailles (8 bits, 16 bits, 32 bits, etc.). Certains registres, dits à
usage général, peuvent contenir les opérandes des instructions alors que d’autres ne sont
accessibles que par les circuits internes du processeur. Dans certains cas, le processeur
doit pouvoir lire simultanément plusieurs registres (deux, le plus souvent), mais ne peut
écrire qu’un seul registre à la fois, d’où le schéma fonctionnel représenté sur la figure 2.6,
comportant :
• deux entrées sur m bits pour les numéros des deux registres à lire et/ou écrire ;
• deux sorties sur n bits présentant les données contenues dans ces deux registres ;
• une entrée sur n bits pour la donnée à écrire dans l’un des registres sélectionnés ;
• une entrée permettant d’appliquer l’impulsion d’écriture à ce registre.
registres
m bits numéro
contenu
registre 1
0 ... N-1 en lecture/ registre 1 n bits
écriture

2m registres

numéros
des registres
N-1
.
.
.

1EH
.
.
.

1

0AH

0

25H

m bits numéro
registre 2
0 ... N-1 en lecture

contenu
d'un registre

n bits

Figure 2.5 – Registres du processeur

2.3.2

contenu
registre 2

n bits

entrée de
n bits donnée
signal
d'écriture

Figure 2.6 – Schéma fonctionnel
des registres

Constitution de la mémoire

La mémoire centrale est constituée d’un nombre relativement élevé de registres de mémorisation, appelés cases mémoires. La différence entre les registres contenus dans le
processeur et les cases mémoires se situe essentiellement au niveau de leurs nombres ainsi
que de la technologie utilisée lors de la réalisation de ces circuits, ainsi que des temps
d’accès aux informations qui y sont stockées. Cette mémoire, organisée selon le schéma
de la figure 2.7, contient :
Microprocesseurs et Microcontrôleurs

ENIT 2016

7

2.3. Organisation des registres et de la mémoire

• les instructions du programme sous forme de mots binaires qui seront décodés dans
l’unité de contrôle afin d’élaborer les signaux de commande ;
• les données à traiter par le calculateur, également stockées sous forme binaire.
Données et instructions peuvent parfois être stockées dans deux mémoires distinctes.
La mémoire peut être vue comme un ensemble de cellules ou cases mémoires, contenant
les instructions et les données. Ces informations sont accessibles par mots de n bits, le plus
souvent n = 8, ce qui constitue l’unité élémentaire d’adressage de la mémoire. Chaque
case mémoire est repérée par un numéro d’ordre unique qui représente son adresse. Le
nombre de cases mémoire ainsi adressables dépend du nombre de bits utilisés pour coder
les adresses. Ainsi, avec p bits, il est possible de sélectionner une case mémoire parmi 2p .
La figure 2.8 représente le schéma fonctionnel de la mémoire centrale, comportant :
• une entrées d’adresse sur p bits où est présentée l’adresse de la case mémoire à lire
ou écrire ;
• les entrées/sorties de données sur n bits où est présentée la donnée à lire ou à écrire
dans la case mémoire adressée ;
• le signal d’écriture qui permet de charger dans la case mémoire adressée la donnée
présentée sur les entrées de données.
2p-1

p bits

adresse de
la dernière
case mémoire

contenu
des cases
mémoire

adresse
n bits
sortie de
donnée

adresses des
cases mémoire
12H
C6H
05H
3EH

n bits entrée de
donnée

0003H
0002H
0001H
0000H

largeur des cases mémoire :
en général 1 octet (n=8 bits)

Figure 2.7 – Mémoire centrale

mémoire
centrale

signal
d'écriture
Figure 2.8 – Schéma fonctionnel de la
mémoire

Une case mémoire peut être :
• lue ou écrite par le processeur s’il s’agit d’une mémoire vive ;
• seulement lue dans le cas d’une mémoire morte.

2.3.3

Représentation des données en mémoire

La mémoire peut être vue sous la forme d’un tableau dont chaque case contient un octet,
comme indiqué sur le schéma de la figure 2.7. Pour le stockage en mémoire de mots sur
plusieurs octets, il existe deux types de rangement :
1ère année Génie Électrique

J. Haggège

8

Chapitre 2. Calculateurs numériques

• le format Little Endian dans lequel l’octet de poids faible du mot est rangé dans la
case mémoire d’adresse la plus basse ;
• le format Big Endian dans lequel l’octet de poids faible est rangé dans la case
mémoire d’adresse la plus élevée.
La figure 2.9 montre le stockage d’une donnée sur quatre octets selon les deux formats de
rangement.
octet de
poids fort

octet de
poids faible

octet de
poids faible

octet de
poids fort

B3 B2 B1 B0

B3 B2 B1 B0
B3
B2
B1
B0
Little
Endian

mémoire

i+3
i+2
i+1
i
adresses
croissantes

B0
B1
B2
B3
Big
Endian

mémoire

i+3
i+2
i+1
i
adresses
croissantes

Figure 2.9 – Rangement en mémoire de données sur plusieurs octets

2.4
2.4.1

Microprocesseurs et microcontrôleurs
Implémentations matérielles d’un calculateur

L’implémentation matérielle d’un calculateur peut se faire à l’aide de circuits logiques combinatoires et séquentiels élémentaires, toutefois cette méthode est actuellement obsolète
car un calculateur est généralement construit autour d’un microprocesseur qui regroupe,
en un seul circuit intégré, tous les éléments d’un processeur : UAL, registres et unité de
contrôle. Si ce circuit intégré inclut, en plus du processeur, la mémoire centrale et des
périphériques, il devient alors un microcontrôleur.

2.4.2

Applications des microprocesseurs et microcontrôleurs

Les microprocesseurs sont généralement utilisé pour la réalisation d’ordinateurs à usage
général tels que les PC de bureau ou les PC portables, les stations de travail, les serveurs
réseau, et toute autre application informatique. Par contre, les microcontrôleurs sont plutôt destinés à la réalisation d’applications embarquées à usage domestique ou industriel
telles que les appareils électroménagers, les télécommunications, la commande de machines, l’automatisation et la régulation numérique de procédés, les appareils de mesure,
et bien d’autres applications.

2.4.3

Exemples de microprocesseurs et microcontrôleurs

Les microprocesseurs suivants figurent parmi les plus connus : Intel x86, Motorola 68K,
Hitachi SuperH, IBM PowerPC, Sun SPARC, MIPS, ARM. Quant aux microcontrôleurs,
Microprocesseurs et Microcontrôleurs

ENIT 2016

9

2.5. Interconnexion des éléments d’un calculateur

on peut citer : Intel 8051, Microchip PIC, Atmel AVR, ST Microelectronics STM8 et
STM32. Chacune de ces références désigne en fait toute une famille de microprocesseurs
ou de microcontrôleurs, basée sur une architecture commune et comportant des différences
au niveau des fonctionnalités qu’ils proposent et qui évoluent au cours du temps, d’une
génération à l’autre.
L’intégration peut être étendue en incluant dans un même circuit intégré, un microcontrôleur associé à des capteurs, des dispositifs mécaniques, des circuits radio, ou encore des
composants optiques afin de former des systèmes sur puce (System on chip, SoC).

2.5
2.5.1

Interconnexion des éléments d’un calculateur
Architectures Von Neumann et Harvard

processeur

mémoire

E/S

périphériques

La réalisation matérielle des calculateurs est généralement basée sur l’architecture de Von
Neumann représentée sur la figure 2.10 ou bien l’architecture Harvard apparaissant sur
la figure 2.11. La différence entre les deux architectures se traduit principalement par
l’existence d’une mémoire unique, pouvant contenir indifféremment le programme et les
données dans le cas de la première, alors que la deuxième architecture distingue deux
types de mémoires, l’une contenant le programme et l’autre les données. L’architecture
de Von Neumann est typique des microprocesseurs, alors celle de type Harvard est plutôt
mise en œuvre dans les microcontrôleurs.

BUS

processeur

mémoire
programme

mémoire
données

E/S

périphériques

Figure 2.10 – Architecture de Von Neumann

BUS

Figure 2.11 – Architecture Harvard
Les instructions et les données d’un programme sont enregistrées dans la mémoire centrale
selon le schéma de la figure 2.12 dans le cas de l’architecture de Von Neumann. Dans le cas
de l’architecture Harvard, les instructions et les données sont rangées dans deux espaces
mémoire différents : la mémoire programme et la mémoire données.
Les instructions et les données sont généralement codées sur un nombre variable d’octets.
L’adresse d’une instruction ou d’une donnée désigne l’octet de poids faible de celle-ci dans
1ère année Génie Électrique

J. Haggège

10

Chapitre 2. Calculateurs numériques

mémoire centrale

mémoire données
donnée p

.
.
.

données

données

donnée p

donnée 3
donnée 2

.
.
.
donnée 3
donnée 2
donnée 1

donnée 1

mémoire programme

.
.
.
instruction 3
instruction 2
instruction 1

instruction n
programme

programme

instruction n

.
.
.
instruction 3
instruction 2
instruction 1

Von Neumann

Harvard

Figure 2.12 – Rangement d’un programme en mémoire
le cas du rangement en mémoire selon le format little endian, l’octet de poids fort dans le
cas où c’est le format big endian qui est utilisé.

2.5.2

Circulation de l’information dans un calculateur

Le processeur échange des informations avec la mémoire et l’unité d’entrée/sortie, sous
forme de mots binaires, au moyen d’un ensemble de connexions appelé bus. Un bus permet de transférer des données sous forme parallèle, c’est-à-dire en faisant circuler n bits
simultanément. Les microprocesseurs et les microcontrôleurs peuvent être classés selon la
longueur maximale des mots binaires qu’ils peuvent échanger au cours d’une même opération de transfert avec la mémoire et les périphériques. Il existe ainsi des microprocesseurs
et des microcontrôleurs 8 bits, 16 bits, 32 bits, etc.
Le bus peut être décomposé en trois bus distincts, selon le schéma de la figure 2.13 :
• le bus d’adresses qui permet au microprocesseur de spécifier l’adresse de la case
mémoire ou du périphérique à lire ou à écrire ;
• le bus de données qui sert de support aux transferts entre le microprocesseur et la
mémoire ou les E/S ;
• le bus de commande dont le rôle est de transmettre les ordres de lecture et d’écriture
de la mémoire et des E/S.
Il convient de noter que les bus de données et de commande sont bidirectionnels alors que
le bus d’adresse est unidirectionnel car seul le microprocesseur peut délivrer des adresses,
bien qu’il existe une dérogation pour certains circuits qui peuvent accéder directement à
la mémoire, sans passer par le processeur (DMA : Direct Memory Access).
Microprocesseurs et Microcontrôleurs

ENIT 2016

unité centrale

largeur du bus
(nombre de bits
en parallèle)

mémoire

11

périphériques

2.6. Aspects matériels et représentation fonctionnelle des microprocesseurs et microcontrôleurs

E/S

8
bus de données
16

bus d'adresses
bus de commande

Figure 2.13 – Bus d’un calculateur

2.6

Aspects matériels et représentation fonctionnelle
des microprocesseurs et microcontrôleurs

Du point de vue matériel, les microprocesseurs et les microcontrôleurs se présentent sous la
forme de circuits intégrés à très fort taux d’intégration, munis d’un nombre plus ou moins
important de broches, et en divers boı̂tiers dont certains sont représentés sur la figure 2.14 :
Dual In-line Package (DIP), Small-Outline Integrated Circuit (SOIC), Quad Flat Pack
(QFP), Pin Grid Array (PGA), Ball Grid Array (BGA), Micro Lead-Frame Package
(MLP), etc. Initialement réalisés en technologies NMOS et PMOS avec une finesse de
gravure de l’ordre de la dizaine de micromètres, les microprocesseurs et microcontrôleurs
sont actuellement réalisés exclusivement en technologie CMOS, avec une finesse pouvant
descendre jusqu’à quelques dizaines de nanomètres.

DIP

PGA

SOIC

BGA

QFP

MLP

Figure 2.14 – Exemples de boı̂tiers pour les microprocesseurs et microntrôleurs
On peut représenter un microprocesseur par un schéma fonctionnel tel que celui de la
figure 2.15 et un microcontrôleur par le schéma fonctionnel de la figure 2.16.
Du fait que les microcontrôleurs intègrent une certaine quantité de mémoire ainsi que
des périphériques, il n’ont pas besoin de disposer de bus d’adresses, de données et de
commande externes. Par conséquent, un microcontrôleur dispose de lignes d’entrées sorties
1ère année Génie Électrique

J. Haggège

12

Chapitre 2. Calculateurs numériques

alimentation

alimentation

n bits

horloge

horloge

bus d'adresses

reset

reset

microprocesseur
signaux de
commande du
microprocesseur

p bits
bus de données

microcontrôleur

ports

ports

bus de commande

Figure 2.15 – Schéma fonctionnel d’un
microprocesseur

Figure 2.16 – Schéma fonctionnel d’un
microcontrôleur

banalisées, regroupées en un ensemble de ports et pouvant être utilisées comme entrées ou
sorties binaires. Toutefois, une ou plusieurs fonctions particulières peuvent être associées
à ces lignes qui servent alors d’entrées ou de sorties aux périphériques contenus dans
le microcontrôleur. Dans certaines familles de microcontrôleurs, des ports peuvent être
utilisés comme bus d’adresses, de données et de commandes externes afin d’étendre la
mémoire interne du microcontrôleur ou d’ajouter des périphériques externes.

Microprocesseurs et Microcontrôleurs

ENIT 2016

Chapitre 3
Structure et fonctionnement d’un
processeur
3.1
3.1.1

Représentation des instructions
Codage binaire en mémoire

Le processeur d’un calculateur a pour rôle d’exécuter le programme. Celui-ci est constitué d’une suite d’instructions et de données enregistrées dans la mémoire centrale. Les
instructions que peut exécuter un processeur peuvent être généralement classées en trois
principaux groupes :
• opérations arithmétiques et logiques ;
• transferts de données ;
• sauts et branchements.
Chaque instruction est représentée par un mot binaire dont le nombre de bits peut être
fixe ou variable selon la nature de l’instruction. Ce mot binaire peut être décomposé en
différents segments, appelés champs, comme l’indique la figure 3.1.
p bits
code opératoire
opération à effectuer

q bits
opérande 1

r bits

m bits

opérande 2

opérande 3

données nécessaire à l'exécution de l'opération

Figure 3.1 – Format d’une instruction
Le premier champ d’une instruction est le code opératoire qui indique la nature de celleci. Les champs suivants, lorsqu’ils sont présents, permettent de désigner les opérandes sur
lesquels l’instruction est exécutée :
• registres du processeur ;
• données en mémoire ;
• périphérique d’entrée/sortie.
1ère année Génie Électrique

J. Haggège

14

Chapitre 3. Structure et fonctionnement d’un processeur

Ainsi, selon la nature de l’instruction, le nombre de champs correspondant aux opérandes
est variable. Le plus souvent, il est compris entre zéro et trois, mais il peut être plus élevé.
L’ensemble des instructions pouvant être exécutées par un processeur donné est appelé
jeu d’instruction de ce processeur.

3.1.2

Langage machine et langage assembleur

Les instructions codées sous forme de mots binaires enregistrés en mémoire constituent
un langage adapté au contrôle des circuits électroniques du processeur, appelé langage
machine ou code machine. Un tel langage n’étant pas facile à manipuler par l’être humain qui conçoit un programme, une représentation symbolique des instructions est donc
employée pour faciliter sa tâche. Cette représentation remplace les mots binaires par des
mnémoniques qui sont des termes abrégés de mots appartenant à un langage humain,
généralement l’anglais.
L’ensemble des mnémoniques associés à un jeu d’instructions est appelé langage assembleur. Celui-ci est également connu sous le nom de langage de bas niveau, étant donné sa
proximité avec les circuits électroniques qu’il contrôle pour exécuter les instructions. Au
contraire, les langages dits de haut niveau tels que les langages C, Java, Pascal, Basic,
Fortran, manipulent des instructions qui n’agissent pas directement sur le matériel, mais
qui sont préalablement traduites en un ensemble d’instructions assembleur à l’aide d’un
logiciel appelé compilateur.
La figure 3.2 représente les étapes nécessaires à l’obtention d’un programme en code machine, enregistré en mémoire et prêt à être exécuté. Le programme en langage assembleur
peut être élaboré à l’aide d’un logiciel d’édition de texte, puis un autre logiciel, appelé
assembleur, traduit le langage assembleur en langage machine appelé, à ce stade, code
objet. Celui-ci sera, éventuellement, lié à d’autres programmes en code machine déjà existants, appartenant à une bibliothèque de code objet. Cette opération est effectuée à l’aide
d’un éditeur de liens (linker) dont le rôle est de produire le programme en langage machine proprement dit, qui est alors enregistré dans la mémoire du calculateur à l’aide d’un
chargeur (loader).

éditeur de texte

bibliothèques
mémoire

langage de
haut niveau

langage
assembleur

code
objet

assembleur

compilateur
langage
assembleur

code
objet
éditeur de liens
langage
machine

chargeur

Figure 3.2 – Élaboration d’un programme en langage machine
Microprocesseurs et Microcontrôleurs

ENIT 2016

3.2. Modes d’adressage

15

Toute la chaı̂ne impliquée dans la création du code machine est constituée d’un ensemble
d’outils logiciels exécutés par un ordinateur qui peut être différent du calculateur pour
lequel le code machine est élaboré.

3.1.3

Exemples d’instructions en assembleur

Les instructions suivantes sont présentes dans le langage assembleur de la plupart des
processeurs, la dénomination exacte des mnémoniques pouvant varier selon le fabricant
du processeur.
• L’addition du contenu de deux registres, représentés par les lettres A et B :
ADD A,B
Cette instruction additionne le contenu des registres A et B, la somme étant placée
dans le registre A.
• L’opération logique de complémentation binaire qui inverse l’état des bits d’un mot :
CPL A
Cette instruction remplace le contenu du registre A par son complément binaire Ā.
Il s’agit d’une instruction ne possédant qu’un seul opérande.
• Le transfert du contenu d’une case mémoire dans un registre du processeur :
LD A,1000H
Dans ce cas, LD signifie Load (charger) et la valeur 1000H représente l’adresse de la
case mémoire, codée en hexadécimal comme l’indique le suffixe H.
• La copie du contenu d’un registre vers une case mémoire :
ST 2000H,A
Ici, ST est l’abréviation de Store (ranger).
• Les transferts entre deux registres ou entre deux cases mémoires :
MOV A,B
Le mnémonique MOV signifie Move (déplacer), les instructions Load et Store étant
généralement réservées aux transferts de données entre les registres et la mémoire.
En général, les adresses des cases mémoires sont elles-mêmes représentées par des valeurs
symboliques, appelées labels ou étiquettes, permettant de manipuler les cases mémoires à
la manière des variables définies dans les langages de programmation de haut niveau.

3.2
3.2.1

Modes d’adressage
Définition

Un mode d’adressage représente la manière dont l’adresse effective des opérandes est
déterminée lors de l’exécution d’une instruction. Les adresses effectives sont les mots
binaires qui sont physiquement émis sur le bus d’adresse du calculateur, ainsi que les
signaux de sélection des différents registres internes du processeur.
Certains modes d’adressage sont conçus spécialement pour faciliter la manipulation de
structures de données complexes, telles que les chaı̂nes de caractères, les tableaux ou les
enregistrements.
1ère année Génie Électrique

J. Haggège

16

3.2.2

Chapitre 3. Structure et fonctionnement d’un processeur

Modes d’adressage élémentaires

La plupart des processeurs permettent de manipuler les données selon un certain nombre
de modes d’adressages élémentaires décrits ci-dessous.
Adressage implicite Une instruction utilise l’adressage implicite lorsqu’elle agit toujours sur un même emplacement du calculateur, pouvant être un registre ou une
case mémoire, rendant ainsi inutile la présence d’opérandes dans l’instruction. Par
exemple, une instruction qui permet de modifier l’état de l’indicateur de retenue
de l’UAL utilise un adressage implicite puisque cette instruction n’agit que sur un
registre particulier du processeur, en l’occurrence le registre d’état.
Adressage immédiat Lorsque l’un des opérandes d’une instruction est une valeur numérique constante, celle-ci peut être directement codée dans l’instruction. Un tel
opérande est alors appelé valeur immédiate et l’adressage utilisé par l’instruction
est dénommé adressage immédiat. Il n’y a donc pas d’accès à la mémoire pour ce
mode d’adressage.
Adressage registre Les registres du processeur possèdent un numéro permettant à
l’unité de contrôle de sélectionner les registres concernés par l’instruction à exécuter. Ainsi, lorsqu’une instruction n’a que des registres comme opérandes, le mode
d’adressage utilisé par cette instruction est appelé adressage registre et l’adresse du
registre est codée dans l’un des champs du mot binaire représentant l’instruction.
L’adressage registre est aussi appelé adressage inhérent.
Adressage direct Dans le cas d’une instruction qui agit sur une donnée rangée dans
la mémoire centrale, l’adresse de la case mémoire est codée dans l’instruction. Il
s’agit alors d’un adressage direct de la mémoire pour lequel l’un des opérandes est
une valeur numérique constante, comme dans le cas de l’adressage immédiat, à la
différence que cette constante représente une adresse et non une donnée. Afin de ne
pas confondre entre eux ces deux modes d’adressage, la syntaxe du langage assembleur d’un processeur impose de représenter les constantes et les adresses mémoire
de façons différentes, par exemple en faisant précéder les constantes par un signe
distinctif. Ainsi, dans une instruction en langage assembleur, l’adressage immédiat
peut être représenté, par exemple, de la manière suivante :
ADD A,#100
tandis que l’adressage direct peut être spécifié comme suit :
ADD A,100
Dans le premier cas, la valeur 100 représente la constante égale à 100 alors que dans
le deuxième cas, elle indique la case mémoire d’adresse 100.
Adressage indirect par registre Une instruction peut faire référence à un registre
contenant l’adresse d’une case mémoire où est rangé l’opérande concerné par cette
instruction. Un tel registre joue le rôle de pointeur ou d’index, la case mémoire étant
alors pointée ou indexée par ce registre. Ce type d’adressage est alors dit indirect par
registre. Là encore, il est nécessaire de préciser dans l’instruction en langage assembleur le rôle du registre utilisé afin de distinguer ce mode d’adressage de l’adressage
registre, comme dans le cas de l’instruction suivante :
Microprocesseurs et Microcontrôleurs

ENIT 2016

17

3.2. Modes d’adressage

ADD A,B
dans laquelle le registre B contient la valeur à additionner au registre A (adressage
registre), et cette instruction :
ADD A,[B]
où le registre B contient l’adresse de la case mémoire dont le contenu sera additionné
au registre A (adressage indirect par registre).
La figure 3.3 représente le format des instructions selon le mode d’adressage qu’elles
utilisent pour accéder à une donnée.
adressage implicite
code opératoire

adressage immédiat
code opératoire

opérande = constante

mémoire

adressage direct
code opératoire

opérande = adresse
adresse
effective

donnée

adressage registre
code opératoire

opérande = registre

registres
adresse
effective

donnée

mémoire
adressage indirect par registre
code opératoire

opérande = registre

registres
adresse

adresse
donnée
effective

Figure 3.3 – Formats des instructions selon le mode d’adressage utilisé

3.2.3

Modes d’adressage complexes

Les modes d’adressage précédent peuvent être combinés afin d’en obtenir de nouveaux,
plus complexes, permettant de faciliter la manipulation de structures de données telles
que les tableaux et les enregistrements.
Adressage indexé avec décalage Il s’agit d’un mode d’adressage dans lequel l’adresse
effective est obtenue en additionnant le contenu d’un registre avec une valeur immédiate appelée décalage ou offset. Ce mode d’adressage est adapté au traitement des
tableaux à une dimension : l’offset désigne l’adresse de la première case du tableau,
1ère année Génie Électrique

J. Haggège

18

Chapitre 3. Structure et fonctionnement d’un processeur

considérée comme étant l’adresse de celui-ci, tandis que le registre contient l’indice
de la case du tableau à laquelle l’instruction doit accéder.
Adressage basé et indexé Dans le cas de ce mode d’adressage, l’adresse effective est
constituée par la somme des contenus de deux registres. Cela permet ainsi, dans le
cas de l’accès aux éléments d’un tableau, de disposer de l’adresse de la première case
dans un registre, appelé registre de base, et de l’indice du tableau dans le deuxième
registre, appelé registre d’index. La différence entre l’adressage indexé avec décalage
et l’adressage basé et indexé réside dans le fait que l’adresse du tableau est une
constante dans le premier cas, une variable dans le deuxième.
Adressage basé et indexé avec décalage Ce mode d’adressage est utilisé dans le cas
de l’accès aux tableaux dont les éléments sont des enregistrements. L’offset permet
alors de désigner un champ particulier de l’enregistrement contenu dans la case du
tableau indexé par l’instruction.
Le format des instructions utilisant ces modes d’adressage apparait sur la figure 3.4.
adressage indexé avec décalage

mémoire

code opératoire opérande = registre opérande = adresse

offset

+

adresse
effective

donnée

registres
adresse

index

adressage basé et indexé
code opératoire opérande = registre opérande = registre
mémoire
registres
adresse
adresse

base
index

+

adresse
effective

donnée

adressage basé et indexé avec décalage
code opératoire opérande = registre opérande = registre opérande = adresse
mémoire
offset
registres
adresse
adresse

base
index

+

adresse
effective

donnée

Figure 3.4 – Formats des instructions utilisant des modes d’adressage complexes

Microprocesseurs et Microcontrôleurs

ENIT 2016

19

3.3. Exécution d’une instruction par le processeur

3.3

Exécution d’une instruction par le processeur

3.3.1

Étapes élémentaires et datapath

L’exécution d’une instruction par le processeur implique l’enchaı̂nement d’au moins quatre
étapes élémentaires :
• la recherche en mémoire de l’instruction à exécuter (instruction fetch) ;
• le décodage du code opératoire de l’instruction (decode) ;
• l’exécution de l’opération spécifiée dans le code opératoire (execute) ;
• l’écriture du résultat dans sa destination (write back).
Dans le cas où l’instruction possède des opérandes rangés dans la mémoire centrale, une
étape supplémentaire peut être rajoutée afin d’accéder à ces données (data fetch).
L’ensemble des éléments impliqués dans l’enchaı̂nement des étapes conduisant à l’exécution d’une instruction est appelé chemin de données ou datapath. Celui-ci est constitué
par la mémoire, les registres et l’UAL, qui sont successivement parcourus par les mots binaires représentant les instructions et les données qui leur sont associées, afin de produire
le résultat attendu de la part de l’instruction en cours d’exécution.
Les signaux de contrôle du datapath sont élaborés par le séquenceur qui est conçu pour
reconnaı̂tre l’ensemble des instructions contenues dans le jeu d’instruction du processeur.
Ces signaux de contrôle dépendent du code opératoire contenu dans l’instruction à exécuter, ainsi que du registre d’état associé à l’UAL.
Pour exécuter les instructions dans l’ordre établi par le programme, le processeur doit
disposer de l’adresse de l’instruction courante à exécuter. Cette adresse est contenue dans
un registre appelé compteur programme (Program Counter, PC) dont la valeur initiale,
appelée adresse de démarrage ou de boot, est chargée au moment de la mise sous tension
du processeur, ou bien lors de sa remise à zéro (reset), ce qui se traduit par l’affectation :
P C ← P C IN IT
où P C IN IT désigne la valeur initiale chargée dans le registre PC. Les étapes décrites
ci-dessous peuvent alors commencer à s’enchaı̂ner.
Fetch La recherche d’une instruction en mémoire centrale (Fetch) est effectuée lors de
l’écriture du registre PC, ce qui a pour effet de présenter la valeur contenue dans
celui-ci à l’entrée d’adresse de la mémoire. Mis à part l’exécution de la première
instruction, le compteur programme est incrémenté d’un nombre n égal au nombre
de cases mémoire sur lequel est codée l’instruction précédente. Dans le cas le plus
simple, ce nombre est identique pour toutes les instructions, mais il peut être variable
selon la nature de l’instruction dans certains processeurs. C’est donc l’affectation
suivante qui est réalisé :
PC ← PC + n
L’instruction enregistrée dans l’emplacement mémoire adressé est alors disponible
sur la sortie de données de la mémoire.
1ère année Génie Électrique

J. Haggège

20

Chapitre 3. Structure et fonctionnement d’un processeur

Decode Le décodage de l’instruction consiste à mémoriser celle-ci dans un registre appelé
registre d’instruction (Instruction Register, IR). L’opération réalisée lors de cette
étape se résume par l’affectation suivante :
IR ← M EM [P C]
dans laquelle M EM [P C] désigne le contenu de la case mémoire dont l’adresse est
dans le registre PC. Les différents champs de l’instruction (code opératoire et opérandes) sont alors répartis entre les éléments du processeur. Le cas le plus simple
est celui d’une instruction codée sur p bits, contenant quatre champs et représentée
selon le format suivant :
p − 1 ... r r − 1 ... q q − 1 ... m m − 1 ... 0
@reg2
@reg1
fct ual
opcode
p − r bits
r − q bits
q − m bits
m bits
Le champ noté opcode correspond au code opératoire qui spécifie la nature de l’instruction, le champ fct ual permet de sélectionner la fonction effectuée par l’UAL,
alors que les champs @reg1 et @reg2 sont les numéros des registres constituant les
opérandes de l’instruction qui utilise, dans ce cas, le mode d’adressage registre. Le
code opératoire est appliqué à l’entrée de sélection d’opération de l’UAL, tandis que
les opérandes sont appliqués aux entrées d’adressage des registres :
F CT U AL = IR[p − 1 . . . r] = @reg2
@REG1
= IR[r − 1 . . . q] = @reg1
@REG2
= IR[q − 1 . . . m] = fct ual
où F CT U AL, @REG1 et @REG2 désignent respectivement l’entrée de sélection
de fonction de l’UAL, l’entrée d’adressage du premier registre en lecture/écriture et
l’entrée d’adressage du deuxième registre en lecture. En ce qui concerne le champ
IR[m − 1 . . . 0] = opcode, il sera utilisé par l’unité de contrôle du processeur.
Execute Pour exécuter l’opération spécifiée dans l’instruction, les données nécessaires
sont copiées et mémorisées dans deux registres temporaires, souvent notés A et B,
appelés registres d’opérandes de l’UAL et connectés aux entrées de celle-ci, ce qui
se traduit par les affectations :
A ← REG[@reg1]
B ← REG[@reg2]
dans lesquelles REG[@reg1] et REG[@reg2] désignent respectivement le contenu
des deux registres adressés par l’instruction. Le résultat de l’opération se trouve alors
à la sortie de l’UAL, tandis que les indicateurs d’état sont actualisés en fonction du
résultat de l’opération.
Write Back L’écriture du résultat de l’instruction consiste à transférer la valeur présente
en sortie de l’UAL vers la destination spécifiée dans l’instruction, par exemple le
premier registre opérande dont la valeur initiale sera remplacée par le résultat de
l’opération. Les indicateurs d’état actualisés suite à l’exécution de l’instruction sont
Microprocesseurs et Microcontrôleurs

ENIT 2016

21

3.3. Exécution d’une instruction par le processeur

également mémorisés dans le registre d’état. Les affectations effectuées au cours de
cette étape sont donc les suivantes :
REG[@reg1] ← SORT IE U AL
REG ET AT ← IN DICAT EU RS U AL
où SORT IE U AL et IN DICAT EU RS U AL représentent, respectivement, la sortie et les indicateurs de l’UAL, REG ET AT étant le registre qui mémorise la valeur
de ceux-ci.

3.3.2

Datapath pour l’exécution d’instructions opérant sur des
registres

La figure 3.5 représente un datapath élémentaire pouvant être utilisé dans le cas de l’exécution d’une suite d’instructions utilisant le mode d’adressage registre. Les signaux d’écriture
de la mémoire et des différents registres, élaborés par le séquenceur, ne sont pas représentés
afin de ne pas encombrer le schéma.
registre
d'état

registres
mémoire
centrale
sortie de
donnée

reset

n

+

compteur
programme

MEM[PC]

registre
d'instruction

@reg1

PC

REG[@reg1]
numéro
registre 1 contenu
A
en lecture/ registre 1
écriture

@reg2

entrée de
donnée

Ind.
UAL

adresse

REG[@reg1]

numéro
registre 2
en lecture

contenu
registre 2

REG[@reg2]

B

Fct

entrée de
données
fct_ual

Figure 3.5 – Datapath pour l’exécution d’une instruction à adressage registre
La figure 3.6 représente un chronogramme des signaux de contrôle délivrés par le séquenceur pour l’exécution d’une instruction du type décrit précédemment.
Ces signaux sont les impulsions appliquées aux entrées d’écriture des différents registres,
à chaque front du signal d’horloge du séquenceur et dans l’ordre requis pour achever un
cycle d’instruction, c’est-à-dire la séquence d’étapes constituant l’exécution de l’instruction. Ce chronogramme montre ainsi qu’à chaque front d’horloge, le contenu des registres
intervenant dans une étape donnée de l’exécution, est transféré dans les registres utilisés
lors de l’étape suivante.
Le signal d’horloge est caractérisé par sa fréquence f (ou sa période T = 1/f ). Il est
généré par un oscillateur, le plus souvent à base d’un quartz afin d’assurer la stabilité et
la précision de la fréquence du signal d’horloge.

3.3.3

Datapath pour l’accès à la mémoire par le processeur

Le datapath présenté sur la figure 3.5 n’autorise que l’exécution d’instructions utilisant le
mode d’adressage registre car il n’y a pas de chemin permettant le transfert de données
1ère année Génie Électrique

J. Haggège

22

Chapitre 3. Structure et fonctionnement d’un processeur

cycle d'instruction
période d'horloge
signal
d'horloge

recherche

décodage

exécution

écriture

signaux de contrôle

écriture
compteur
programme

instruction
suivante

écriture registre
d'instruction
écriture
registres UAL
écriture
registres processeur

Figure 3.6 – Chronogramme de l’exécution d’une instruction opérant sur les registres du
processeur
entre la mémoire et les registres du processeur. Il n’est pas non plus possible de charger en
mémoire ou dans un registre une valeur immédiate. Par conséquent, et afin d’implémenter
les autres modes d’adressage élémentaires (immédiat, direct et indirect par registre), il
convient de modifier le datapath en ajoutant la possibilité de lire ou écrire une donnée en
mémoire au cours de l’exécution d’une instruction, ce qui nécessite l’ajout d’un registre
contenant l’adresse de la case mémoire à laquelle l’instruction doit accéder. Ce registre,
appelé registre d’adresse (Address Register, AR), sera connecté à l’entrée d’adressage de
la mémoire lors d’un accès à celle-ci, en lieu et place du compteur programme. La sélection
entre les contenus de ces deux registres, PC ou AR, se fait à l’aide d’un multiplexeur sur
n bits dont le schéma fonctionnel est représenté sur la figure 3.7.
0

n bits
Y

mux

entrées

n bits
X

1

n bits
sortie

si C = 0
S= X
Y si C = 1

C

Figure 3.7 – Multiplexeur sur n bits
L’entrée d’adressage de la mémoire sera donc reliée à la sortie d’un multiplexeur dont les
entrées sont les registres AR et PC, le signal de sélection étant mis à l’état approprié par
le séquenceur au cours du cycle d’horloge suivant le décodage de l’instruction. En notant
@M EM l’entrée d’adressage de la mémoire, le multiplexeur permettra d’effectuer le choix
suivant entre deux sources d’adresses :
• @M EM = P C pour une recherche d’instruction ;
• @M EM = AR pour un accès à la mémoire.
Microprocesseurs et Microcontrôleurs

ENIT 2016

23

3.3. Exécution d’une instruction par le processeur

Une donnée lue en mémoire sera enregistrée dans un registre appelé registre de donnée
(Data Register, DR). Le contenu de celui-ci pourra ensuite être transféré dans l’un des
registres du processeur, figurant parmi les opérandes de l’instruction. Pour cela, un autre
multiplexeur est nécessaire afin de sélectionner la source de donnée à l’entrée des registres,
notée DAT A REG, celle-ci pouvant être la sortie de l’UAL ou le registre de donnée :
• DAT A REG = SORT IE U AL pour l’écriture d’un résultat dans un registre ;
• DAT A REG = DR pour l’écriture d’une donnée de la mémoire dans ce registre.
Un troisième multiplexeur est ajouté sur l’une des entrées de l’UAL, permettant ainsi
la sélection entre l’un des registres du processeur ou une valeur immédiate, codée dans
l’instruction (adressage immédiat) et notée val imm, comme source de donnée pour cette
entrée :
• B = REG[@reg2] pour le transfert d’un registre du processeur dans le registre
d’opérande B de l’UAL ;
• B = val imm pour l’écriture d’une valeur immédiate dans ce registre.
Finalement, une liaison est ajoutée entre la sortie de l’UAL et l’entrée de données de
la mémoire centrale, en plus de la liaison déjà existante entre cette sortie et l’entrée de
données des registres, dans le but de pouvoir enregistrer une donnée en mémoire. Ainsi,
selon le cas, l’une des affectations suivantes pourra être réalisée :
• M EM [AR] ← SORT IE U AL pour l’écriture dans une case mémoire ;
• REG[@reg1] ← SORT IE U AL pour l’écriture dans un registre du processeur.
Le datapath ainsi modifié est représenté sur le schéma de la figure 3.8.

registre
d'adresse

mémoire
centrale

AR

sortie de
donnée

registre
d'instruction

reset

n

+

compteur
programme

adresse

1

entrée de
donnée

registre
de donnée
MEM[AR]

numéro
registre 1 contenu
en lecture/ registre 1
écriture

A

contenu
registre 2

B

numéro
registre 2
en lecture

DR

Ind.
UAL
0

Fct

1
0
mux

mux

0

registre
d'état

registres

mux

offset

sélection source
adresse mémoire

1

entrée de
données
val_imm

sélection source
donnée UAL

sélection source
donnée registres

Figure 3.8 – Datapath pour les instructions avec adressage direct de la mémoire centrale
Pour utiliser ces nouvelles possibilités de transferts de données, il devient nécessaire d’ajouter deux champs supplémentaires dans le code machine des instructions, l’un pour coder
l’adresse mémoire à laquelle l’instruction va accéder, notée offset (adressage direct), l’autre
pour contenir la valeur qui sera utilisée par l’UAL, notée val imm (adressage immédiat),
selon le format suivant :
n − 1 ... s s − 1 ... p p − 1 ... r r − 1 ... q q − 1 ... m m − 1 ... 0
val imm
offset
@reg2
@reg1
fct ual
opcode
n − s bits
s − p bits
p − r bits
r − q bits
q − m bits
m bits
1ère année Génie Électrique

J. Haggège

24

Chapitre 3. Structure et fonctionnement d’un processeur

Ainsi, dans le cas de l’adressage direct, après la phase de décodage, le registre d’adresse
est chargé avec la valeur correspondant au champ d’adresse dans l’instruction :
AR ← IR[s − 1 . . . p] = offset
En même temps, le signal de commande du multiplexeur permettant la sélection de la
source d’adressage de la mémoire est positionné de manière à avoir :
@M EM = AR
Au cycle d’horloge suivant, le contenu de la case mémoire adressée est transféré dans le
registre de données :
DR ← M EM [AR]
Simultanément, la source de données pour l’écriture du registre de destination est sélectionnée, à l’aide du multiplexeur prévu à cet effet, comme source de données des registres
du processeur :
DAT A REG = DR
Finalement, un autre cycle d’horloge est nécessaire pour transférer le contenu du registre
de données vers le registre de destination indiqué par son numéro @reg1 dans l’instruction :
REG[@reg1] ← DR
Au total, trois cycles d’horloge supplémentaires sont intercalés entre le décodage et l’exécution de l’instruction, portant à sept le nombre de cycles d’horloge nécessaire à l’exécution d’une instruction comprenant un accès en lecture à la mémoire, comme l’indique le
chronogramme de la figure 3.9.
Afin d’implémenter les modes d’adressage indirects par registres ainsi que leurs variantes
(basé, indexé, avec ou sans décalage), il est nécessaire de pouvoir sélectionner, parmi
différentes sources, la valeur (adresse effective) à charger dans le registre d’adresse. Un
multiplexeur, placé à l’entrée de celui-ci, permet de charger soit l’offset codé dans l’instruction (adressage direct), soit la somme de cet offset et d’une valeur résultant d’un calcul
effectué par l’UAL. Cette valeur correspond au contenu d’un registre (adressage indexé
avec décalage) ou à la somme des contenus de deux registres (adressage basé et indexé
avec décalage). L’offset codé dans l’instruction peut être nul, ce qui correspond au cas des
adressages indexé ou basé et indexé. De cette manière, l’adresse effective chargée dans le
registre d’adresse pourra résulter de l’une des affectations suivantes :
• AR ← offset pour l’adressage direct ;
• AR ← offset + REG[@reg1] ou offset + REG[@reg1] + REG[@reg2] pour les adressages indirects par registres.
Ces différents modes d’adressage peuvent être réalisés à l’aide du datapath représenté sur
la figure 3.10
Microprocesseurs et Microcontrôleurs

ENIT 2016

25

3.3. Exécution d’une instruction par le processeur

cycle d'instruction
signal
d'horloge

recherche

lecture en mémoire

décodage

exécution

écriture

écriture
compteur
programme
écriture registre
d'instruction
écriture registre
d'adresse

signaux de contrôle

sélection source
adresses mémoire
écriture registre
de données

sélection source
données registres
écriture registre
destination
écriture
registres UAL
écriture
registres processeur

Figure 3.9 – Chronogramme de l’exécution d’une instruction avec accès à la mémoire
centrale

REG[@reg1] ou REG[@reg1] + REG[@reg2]
offset

registre
d'état

registres

offset

1

sélection
adressage
direct/indirect
n

+

adresse
effective

registre
d'adresse

AR

sortie de
donnée

registre
d'instruction

0

reset

adresse

1

compteur
programme

entrée de
donnée

registre
de donnée

numéro
registre 1 contenu
en lecture/ registre 1
écriture

A

contenu
numéro
registre 2 registre 2
en lecture

B

Ind.
UAL
0
mux

mux

0

Fct

1
0
mux

+

mux

offset

mémoire
centrale

entrée de
données

1

Figure 3.10 – Datapath implémentant l’adressage indirect de la mémoire centrale

1ère année Génie Électrique

J. Haggège

26

3.3.4

Chapitre 3. Structure et fonctionnement d’un processeur

Datapath pour les instructions de branchement

Les différents datapaths décrits précédemment ne peuvent servir qu’à l’exécution d’instructions stockées dans des emplacements mémoire consécutifs puisque, lors de la recherche
d’un instruction en mémoire, le compteur programme est systématiquement incrémenté
d’une quantité fixe, égale au nombre d’octets sur lequel sont codées les instructions.
Cependant, les programmes contiennent généralement des instructions conditionnelles,
permettant d’exécuter des suites d’instructions différentes selon la valeur du résultat de
l’instruction en cours d’exécution. Par conséquent, il est nécessaire de pouvoir charger le
compteur programme du processeur avec une adresse mémoire pouvant être différente de
l’adresse précédente incrémentée d’un nombre fixe d’octets. Les instructions permettant
d’effectuer une telle opération sont appelées instructions de branchement ou de sauts.
Elles peuvent être codée selon le format suivant :
p − 1 ... r r − 1 ... q q − 1 ... m m − 1 ... 0
offset
@reg1
code condition
opcode
p − r bits
r − q bits
q − m bits
m bits
De telles instructions contiennent un champ noté code condition, dont la valeur représente
l’un des indicateurs à tester dans le registre d’état afin de déterminer si le branchement
doit être effectivement réalisé. Le test consiste à vérifier si l’indicateur concerné est dans un
état donné, auquel cas le branchement est effectué, sinon le programme se poursuit alors
avec l’instruction suivante. Ce type de branchement est appelé saut conditionnel. Il est
également possible qu’aucune condition ne soit associée à la réalisation du branchement,
c’est-à-dire qu’aucun indicateur ne doit être testé. Un tel branchement est alors qualifié
d’inconditionnel.
Plusieurs types de branchements sont possibles, selon la manière dont est calculée l’adresse
effective de l’instruction à exécuter suite au branchement. Cette adresse, appelée destination du branchement, peut être codée dans l’instruction (champ offset) ou bien contenue
dans le registre dont le numéro figure dans l’instruction (champ @reg1) : il s’agit, respectivement, des branchements direct et indirect. Lorsque cette adresse remplace le contenu
actuel du compteur programme, le branchement est dit absolu, alors que si elle y est simplement additionnée, le branchement est relatif. Le type de saut est inclus dans le champ
code condition qui est interprété par le séquenceur afin de générer les signaux de contrôle
adéquats.
L’implémentation de telles instructions est rendue possible à l’aide du datapath apparaissant sur le schéma de la figure 3.11, dans lequel un jeu de multiplexeurs permet de
sélectionner l’une des affectations suivantes pour l’adresse à charger dans le compteur
programme :
• P C ← offset pour un branchement absolu direct ;
• P C ← REG[@reg1] pour un branchement absolu indirect ;
• P C ← P C + offset pour un branchement relatif direct ;
• P C ← P C + REG[@reg1] pour un branchement relatif indirect ;
• P C ← P C + n pour les instructions autres que celles de branchement.
Dans le jeu d’instructions en assembleur d’un processeur, les instructions de branchement
absolu sont généralement représentées par des mnémoniques du type BRA (Branch) ou
Microprocesseurs et Microcontrôleurs

ENIT 2016

27

3.4. Contrôle du datapath

registre
d'état

registres

1

offset
mux

mux

mux

0

n

+
PC

sélection
branchement
direct/indirect

compteur
programme

entrée de
donnée

1

1

adresse

1

0

1

sortie de
donnée

numéro
registre 1
en lecture/
écriture
numéro
registre 2
en lecture

registre
d'instruction

0

reset

0

REG[@reg1]

registre
d'adresse
mux

mux

0

registre
de donnée

contenu
registre 1

A

contenu
registre 2

B

Ind.
UAL
0

Fct

1
0
mux

+

mux

mémoire
centrale

sélection
branchement
relatif/absolu

entrée de
données

1

sélection source d'adresse
instruction suivante

Figure 3.11 – Datapath autorisant les instructions de branchement
JMP (Jump), avec des variantes comme Bcc ou Jcc dans lesquelles cc représente le code
condition pour les branchements conditionnels. Le mnémonique CALL est également utilisé dans le cas de l’appel de sous-programmes à partir d’un programme principal. Ces
instructions ne possèdent, le plus souvent, qu’un seul opérande : l’adresse de destination
du branchement.

3.4
3.4.1

Contrôle du datapath
Rôle du séquenceur

L’exécution d’une instruction par le processeur nécessite, à chaque cycle d’horloge, l’élaboration des signaux de contrôle des différents composants du datapath :
• impulsions d’écriture des registres et de la mémoire ;
• signaux de sélection des entrées des multiplexeurs.

état
interne
calcul
état
suivant

CLK

D
Q
registre
mémoire

décodeur

.
.
.

signaux de contrôle

instructions + indicateurs

L’enchaı̂nement de ces signaux, dans l’ordre approprié, est assuré par l’unité de contrôle
matérialisée par un séquenceur dont le schéma fonctionnel est rappelé sur la figure 3.12.
La réalisation matérielle du séquenceur peut se faire selon deux approches différentes :
par câblage ou par micro-programmation.

séquenceur

Figure 3.12 – Structure du séquenceur (figure 2.4 reproduite)

1ère année Génie Électrique

J. Haggège

28

3.4.2

Chapitre 3. Structure et fonctionnement d’un processeur

Séquenceur câblé

Dans un séquenceur câblé, l’état interne de celui-ci est actualisé à chaque front d’horloge
par un circuit logique combinatoire complexe constitué de portes logiques élémentaires,
implémentant les fonctions logiques nécessaires au calcul de l’état suivant ainsi que du décodage des signaux de contrôle du datapath, comme indiqué sur le schéma de la figure 3.13.
Ce circuit est élaboré en utilisant les méthodes de synthèse des systèmes logiques séquentiels qui conduisent à un schéma généralement complexe et plus ou moins optimisé.
circuit combinatoire
registre d'instruction

signaux de contrôle
du datapath :
- commande des
multiplexeurs
- impulsions d'écriture
des registres

calcul état
suivant et
décodage
d'état

+
registre d'état
(indicateurs)

état
interne
Q
D
registre
mémoire
signal d'horloge
CLK
séquenceur

Figure 3.13 – Séquenceur câblé pour le contrôle du datapath
L’inconvénient d’un tel séquenceur réside dans :
• la difficulté de sa conception, vu le nombre très important d’états à prendre en
compte pour implémenter l’ensemble du jeu d’instruction reconnu par le processeur ;
• l’impossibilité d’apporter des modifications dans ce jeu d’instructions sans avoir à
modifier profondément le câblage obtenu lors de la synthèse du séquenceur.
Par conséquent, les séquenceurs câblés ont très vite été abandonnés dans la conception
des unités de contrôle des processeurs, au profit des séquenceurs microprogrammés, plus
aisés à concevoir et surtout pouvant facilement être modifiés afin d’actualiser le jeu d’instruction ou de corriger des erreurs qui pourraient apparaı̂tre après la mise sur le marché
du processeur.

3.4.3

Séqenceur microprogrammé

Un séquenceur microprogrammé est basé sur le fait qu’il est possible de réaliser, à l’aide
d’une mémoire morte (ROM), un ensemble de n fonctions logiques combinatoires à m
variables. Ce principe est illustré par la figure 3.14 dans laquelle les m lignes d’adresses
de la mémoire morte représentent les variables, tandis que chacune de ses n sorties de
données correspond à une fonction logique des m variables. La ROM est programmée de
façon à établir une correspondance entre les n bits de chacune de ses 2m cases mémoire
avec les valeurs des n fonctions logiques à réaliser.
En appliquant ce principe à la conception du séquenceur, les fonctions logiques combinatoires d’évolution et de décodage de l’état interne sont implémentées à l’aide d’une ROM
Microprocesseurs et Microcontrôleurs

ENIT 2016

29

.
.
.
xm-1 = Am-1

m bits
[A0 ... Am-1]

mémoire
morte

données

variables logiques
x 0 = A0
x 1 = A1

adresses

3.4. Contrôle du datapath

fonctions logiques
D0 = f0(x0 , x1 , ... , xm-1)
n bits
D1 = f1(x0 , x1 , ... , xm-1)
.
.
[D0 ... Dn-1]
.
Dn-1 = fn-1(x0 , x1 , ... , xm-1)

Figure 3.14 – Fonction logique combinatoire réalisée à l’aide d’une mémoire morte
dénommée micro-mémoire. Chaque case de la micro-mémoire contient l’ensemble des états
logiques que doivent prendre les signaux de contrôle du datapath, à une étape particulière
de l’exécution de l’instruction courante. Ces ensembles d’états logiques constituent des
micro-instructions et le contenu de la micro-mémoire constitue le micro-code du processeur. Ainsi, lorsque ce dernier exécute une instruction, le séquenceur déroule, au rythme
du signal d’horloge, une suite de micro-instructions appelée micro-programme.
L’adresse de la case de la micro-mémoire contenant la première micro-instruction nécessaire à l’exécution d’une instruction est choisie égale à la valeur numérique du code opératoire de cette dernière. Un registre est associé à la micro-mémoire pour stocker l’adresse de
la micro-instruction en cours d’exécution. Ce registre joue le même rôle que le compteur
programme du processeur, il est donc appelé micro-compteur programme (micro-PC). La
figure 3.16 représente le schéma de principe d’un séquenceur microprogrammé.
registre d'instruction
opcode

mux

0

1

micro-PC
CLK

adresses

adresse de la première
micro-instruction

mémoire
morte

données

...

..
.

signaux de
contrôle du
datapath

signal d'horloge
sélection chargement opcode
ou adresse micro-instruction suivante
adresse micro-instruction suivante

Figure 3.15 – Principe du séquenceur microprogrammé
L’exécution d’une instruction consiste à charger dans le micro-PC, au premier front d’horloge suivant l’étape de fetch, le code opératoire de l’instruction dont le code machine a été
mémorisé dans le registre d’instruction du processeur au cours de cette étape. Pour compléter l’exécution de l’instruction, les adresses des micro-instructions suivantes doivent être
successivement chargées dans le micro-PC, aux fronts d’horloges consécutifs. Pour cela,
chaque micro-instruction contient l’adresse de celle qui doit être exécutée immédiatement
après. Ainsi, la première adresse chargée dans le micro-PC est le code opératoire alors
que les adresses suivantes proviennent de la micro-mémoire. La sélection entre ces deux
sources d’adresses se fait au moyen d’un multiplexeur dont l’état du signal de commande
est également codé dans la micro-instruction en cours d’exécution.
1ère année Génie Électrique

J. Haggège

30

Chapitre 3. Structure et fonctionnement d’un processeur

Dans le cas de l’exécution d’une instruction de branchement, l’état de l’un des indicateurs
contenus dans le registre d’état du processeur est testé afin de décider si le branchement
doit être effectivement réalisé, ou bien si le programme doit se poursuivre avec l’instruction
suivante. L’indicateur sur lequel porte la condition, ainsi que l’état dans lequel celui-ci doit
se trouver pour que le branchement soit effectif, sont codés dans le champ code condition
de l’instruction selon le modèle suivant :
code condition
num ind : k = 0 . . . n bit état : x = 0 ou 1
dans lequel le champ num ind représente le numéro de l’indicateur sur lequel porte le
test tandis que le champ bit état contient l’état avec lequel l’indicateur sélectionné doit
être comparé. L’implémentation des instructions de branchement conduit à compléter le
schéma du séquenceur comme indiqué sur la figure 3.16.
registre d'état
In-1 ... I2 I1 I0
0
1

numéro indicateur à tester = k :

indicateurs

0 ... n-1 pour les branchements conditionnels
n pour les branchements inconditionnels
pour les branchements
inconditionnels

1

..
.

Ik

mux

2

Ik + x =

1 si Ik = x
0 sinon

n-1
n

état à tester = x :
0 ou 1 pour les branchements conditionnels
1 pour les branchements inconditionnels

opcode

signal activé ( = 1) pour toutes les
instructions de branchement

adresse de la première
micro-instruction
mux

0

1

micro-PC
CLK

mémoire
morte

données

code condition
registre d'instruction

adresses

...

..
.

signal de sélection
source d'adresse
instruction suivante
autres
signaux de
contrôle du
datapath

signal d'horloge
sélection chargement opcode
ou adresse micro-instruction suivante
adresse micro-instruction suivante

Figure 3.16 – Implémentation des instructions de branchement dans le séquenceur
Le code binaire correspondant au numéro de l’indicateur est appliqué aux entrées de sélection d’un multiplexeur dont les entrées de données reçoivent les bits du registre d’état
et la sortie présente l’état de l’indicateur ainsi sélectionné. Ce dernier est comparé avec
la valeur binaire bit état à l’aide d’une porte non-ou exclusif (xnor) dont la sortie est
activée en cas d’égalité des états de ses entrées. Le résultat de cette comparaison est
appliqué à l’une des entrées d’une porte non-et (nand) dont l’autre entrée est reliée à
Microprocesseurs et Microcontrôleurs

ENIT 2016

31

3.5. Performances temporelles d’un processeur

une sortie de la micro-mémoire, activée lors de l’exécution des instructions de branchement. La sortie de cette porte non-et constitue, pour le datapath de la figure 3.11, le
signal de sélection de source d’adresse pour l’exécution de l’instruction suivante : l’état
logique 0, obtenu dans le cas où la condition testée sur l’indicateur sélectionné est vraie,
conduit à charger le compteur programme du processeur avec l’adresse de destination du
branchement. Dans le cas contraire, la sortie de la porte nand reste à l’état logique 1,
ce qui conduit à incrémenter le compteur programme afin d’exécuter l’instruction suivant
immédiatement celle de branchement.
Dans le cas particulier des instructions de branchements inconditionnels, aucun indicateur
n’est testé et la sortie de la porte nand doit être forcée à l’état logique 0 afin de sélectionner l’adresse de destination du branchement comme source d’adresse pour le compteur
programme du processeur. Ce forçage est réalisé en prévoyant une entrée supplémentaire
au multiplexeur permettant de sélectionner l’indicateur à tester. Cette entrée, sélectionnée en affectant au champ num ind le code adéquat, est maintenue dans un état logique
constant, égal à celui qui doit être codé dans le code condition de l’instruction, de manière
à ce que le résultat de la comparaison entre ces deux états soit toujours vrai, conduisant
ainsi à la réalisation effective du branchement.

3.5
3.5.1

Performances temporelles d’un processeur
Mesure des performances

Chaque instruction est caractérisée par le nombre de périodes d’horloge qu’elle utilise,
donnée fournie par le fabricant de l’unité centrale et dépendant de la complexité des
instructions disponibles. Ce nombre est appelé nombre de cycles d’horloge par instruction (CPI, Cycles Per Instruction). Il permet d’évaluer les performances d’un processeur
en termes de temps d’exécution d’un programme. Ainsi, dans le cas d’une instruction
s’exécutant conformément au chronogramme de la figure 3.6, le CPI est de quatre cycles
d’horloge par instruction, alors qu’il est de sept pour une instruction comportant une étape
d’accès à la mémoire (data fetch), comme dans le cas du chronogramme de la figure 3.9.
D’autres instruction peuvent éventuellement consommer un nombre encore différent de
cycles d’horloge.
On définit le plus souvent le CPI moyen (Average CPI) du jeu d’instruction d’un processeur d’après la formule suivante :
P
Ni × CP Ii
i
CP I =
N
dans laquelle Ni est le nombre d’instructions possédant un CPI égal à CP Ii et N est le
nombre total d’instructions contenues dans le jeu d’instructions du processeur.
Le temps d’exécution (ET, Execution Time) d’une instruction est défini comme la durée
nécessaire pour exécuter cette instruction. Elle est donnée par l’expression suivante :
ET = CP I × T =
1ère année Génie Électrique

CP I
f
J. Haggège

32

Chapitre 3. Structure et fonctionnement d’un processeur

où T et f désignent, respectivement, la période et la fréquence de l’horloge du processeur.
La valeur maximale que peut prendre la fréquence d’horloge dépend essentiellement du
temps de propagation des signaux à travers les éléments qui constituent les circuits électroniques du processeur. Le plus souvent, la limitation de la fréquence d’horloge est principalement imposée par l’UAL qui est implémentée sous la forme d’un circuit logique
complexe multi-niveaux, dans lequel les signaux d’entrée sont affectés d’un retard dû au
nombre relativement important de portes logiques traversées avant de fournir le résultat
en sortie, en plus des délais apportés par les autres circuits du datapath. Une autre source
de retard dans la propagation des signaux peut être due à la mémoire et son temps d’accès,
c’est-à-dire le temps qui s’écoule entre la présentation de l’adresse d’une case mémoire et
sa disponibilité sur la sortie de données.

3.5.2

Amélioration des performances

Le chronogramme de la figure 3.17 représente l’exécution séquentielle d’une suite de quatre
instructions simples, utilisant chacune quatre cycles d’horloge, conduisant à un temps
d’exécution total de seize cycle d’horloge.
signal
d'horloge
FETCH

DECODE EXECUTE WRITE BACK

FETCH

instruction n

DECODE EXECUTE WRITE BACK

FETCH

DECODE EXECUTE WRITE BACK

instruction n+2

instruction n+1

FETCH

DECODE EXECUTE WRITE BACK

instruction n+3

Figure 3.17 – Chronogramme de l’exécution d’une suite d’instructions
Il est possible de réduire ce temps d’exécution en commençant l’exécution d’une instruction de la séquence avant que celle de l’instruction en cours ne soit complètement achevée.
Ce principe consiste à débuter l’exécution de la première étape (Fetch) d’une instruction à
chaque front d’horloge et mémoriser le résultat de cette étape dans un registre temporaire
dont le contenu sera exploité à l’étape suivante (Decode). De même, le résultat de cette
étape sera enregistré dans un autre registre temporaire afin d’être utilisé lors de la troisième étape (Execute) dont le résultat sera finalement mémorisé dans un dernier registre
temporaire dont le contenu sera transféré vers la destination spécifiée dans l’instruction
(Write Back). Ce principe, connu sous le nom de pipeline, conduit à l’exécution d’une
séquence d’instructions selon le chronogramme de la figure 3.18 montrant que la séquence
précédente de quatre instructions peut s’exécuter en seulement sept cycles d’horloge contre
seize sans pipeline.
signal
d'horloge
instruction n

FETCH

instruction n+1

DECODE

EXECUTE

WRITE BACK

FETCH

DECODE

EXECUTE

WRITE BACK

FETCH

DECODE

EXECUTE

WRITE BACK

FETCH

DECODE

EXECUTE

instruction n+2

instruction n+3

WRITE BACK

Figure 3.18 – Exécution d’une suite d’instructions en utilisant le principe du pipeline
Microprocesseurs et Microcontrôleurs

ENIT 2016

33

3.5. Performances temporelles d’un processeur

Le schéma de la figure 3.19 montre les trois registres temporaires ajoutés au datapath de
la figure 3.11 afin d’implémenter le principe du pipeline. Ces trois registres, notés respectivement F/D (Fetch/Decode), D/E (Decode/Execute) et E/W (Execute/Write Back),
jouent le rôle de registres tampons (ou buffers) entre les éléments du datapath qui entrent
en jeu lors de la réalisation de chacune des étapes de l’exécution d’une instruction. Les
signaux d’écriture de ces registres doivent être ajoutés aux autres signaux de contrôle
élaborés par le séquenceur.
Registre F/D

Registre E/W

Registre D/E

registre
d'état

registres

mux

n

+

compteur
programme

1

entrée de
donnée

registre
de donnée

1

numéro
registre 1 contenu
en lecture/
registre 1
écriture

A

numéro
contenu
registre 2 registre 2
en lecture

B

Ind.
UAL
0

Fct

1
0
mux

mux

mux

0

adresse

1

0

1

registre
d'instruction

0

reset
0

sortie de
donnée
mux

1

registre
d'adresse

mux

0
mux

+

mémoire
centrale

entrée de
données

1

Instruction Fetch / Data Fetch

Decode

Execute

Write
Back

Figure 3.19 – Datapath avec pipeline
La présence de ces trois registres permet de diviser le datapath en quatre unités fonctionnelles mises en cascade, chacune constituant l’un des éléments du pipeline assurant
la réalisation de l’étape correspondante de l’exécution d’une instruction. Ces unités fonctionnelles sont simultanément actives à chaque cycle d’horloge alors qu’elles ne seraient
exploitées qu’un cycle d’horloge sur quatre comme ce serait le cas pour un datapath sans
pipeline, d’où une accélération considérable du temps d’exécution d’un programme.
Il faut toutefois noter que le pipeline n’est vraiment efficace que lors de l’exécution séquentielle d’une suite d’instructions. Il perd de son efficacité lors de l’exécution d’instructions
de branchement puisque, dans ce cas, une telle instruction peut entraı̂ner à sa suite l’exécution d’une autre instruction que celle dont l’exécution a commencé après l’instruction de
branchement, nécessitant l’arrêt du pipeline et le rechargement du compteur programme,
situé dans l’unité de fetch, avec l’instruction située à l’adresse de destination du branchement.

3.5.3

Architectures CISC et RISC

Les performance d’un processeur donné résultent d’un compromis entre :
• le nombre d’instructions contenues dans le jeu d’instructions ;
• le nombre de cycles d’horloge par instruction ;
• la complexité des opérations effectuées par chaque instruction.
Ainsi, certaines unités centrales privilégient un jeu d’instruction comportant un grand
nombre d’instructions, généralement codées sur un nombre variable d’octets, capables
1ère année Génie Électrique

J. Haggège

34

Chapitre 3. Structure et fonctionnement d’un processeur

d’effectuer des opérations complexes en utilisant des modes d’adressages évolués, mais
nécessitant un nombre élevé de cycles d’horloge. De tels processeurs présentent l’avantage
d’être simples à programmer puisqu’ils permettent de réaliser des opérations complexes
en une seule instruction, ce qui facilite l’élaboration de compilateurs pour la production
de code assembleur à partir d’un programme en langage de haut niveau. De telles unités
centrales sont classées dans la famille des processeurs CISC : Complex Instruction Set
Computer, à laquelle ont appartenu les premiers calculateurs numériques.
D’autres unités centrales, au contraire, implémentent des instructions simples, ne permettant l’utilisation que d’un nombre restreint de modes d’adressages, codées sur un nombre
fixe d’octets et s’exécutant toutes en un même nombre de cycles d’horloge. De telles unités centrales appartiennent à la famille RISC : Reduced Instruction Set Computer. Leur
programmation est plus complexe puisqu’il faut alors plusieurs instructions simples pour
réaliser une opération complexe, ce qui rend plus difficile la conception de compilateurs
de langages de haut niveau. Les processeurs RISC utilisent le plus souvent des mémoires
distinctes pour stocker les programmes et les données, ils possèdent donc une architecture de type Harvard alors que les processeurs CISC sont plutôt associés à l’architecture
Von Neumann. Les plupart des instructions d’un processeur RISC n’admettent que des
registres comme opérandes, seules les instructions de chargement de registres et d’enregistrement en mémoire peuvent accéder à la mémoire centrale, ce qui permet d’économiser
des cycles d’horloge, mais rendent obligatoire l’emploi d’instructions de type load/store
pour l’exécution d’opérations sur des données en mémoire. Une autre conséquence de la
raréfaction des instructions accédant directement à la mémoire centrale est la multiplication du nombre de registres du processeur afin de disposer d’un espace de stockage
permettant la manipulation d’un nombre important de variables.
La distinction entre CISC et RISC a toutefois tendance à s’estomper depuis quelques années car les unités centrales commercialisées ont, le plus souvent, une architecture ayant
des caractéristiques appartenant à ces deux familles. Certains processeurs CISC sont parfois même construits autour d’une architecture RISC qui implémente des instructions
complexes, seules ces dernières étant visibles et utilisables par l’utilisateur qui programme
le processeur. Dans ce cas, l’architecture RISC réalise une émulation d’un processeur
CISC.

3.6
3.6.1

Exécution d’un programme en mémoire centrale
Structure d’un programme exécutable

Un programme rangé en mémoire et prêt à être exécuté nécessite au moins trois ensembles
de cases mémoires représentés sur la figure 3.20, souvent appelés segments, contenant
respectivement :
• le code du programme, constitué des instructions représentées sous forme de mots
binaires ;
• les données manipulées par le programme ;
Microprocesseurs et Microcontrôleurs

ENIT 2016

35

3.6. Exécution d’un programme en mémoire centrale

• la pile de sauvegarde (Stack), zone de stockage dont l’accès se fait selon le mode
« Last In First Out », essentiellement utilisée lors de l’appel de sous-programmes.
Les plages d’adresses correspondant à ces segments sont affectés à un programme lors de
la phase d’édition de liens (linkage) du programme, avant que celui-ci ne soit effectivement chargé en mémoire par le chargeur (loader). L’exécution du programme consiste à
initialiser le compteur programme du processeur à l’adresse de début du segment de code,
appelée point d’entrée du programme (Entry Point). Cette opération peut être réalisée en
plaçant à l’adresse de boot du processeur, un saut vers cette adresse.

programme
principal

mémoire

sous-programmes

PILE

point d'entrée
du programme

adresses
croissantes

1ère instruction

Figure 3.20 – Structure d’un programme chargé
en mémoire

3.6.2

RET

L
C AL

T
RE

DONNÉES

instructions

CODE

L
C AL

C AL

L

RET

Figure 3.21 – Appels de sousprogrammes

Appel de sous-programmes et pile de sauvegarde

Un programme est très souvent constitué d’une fonction principale faisant appel à des
sous-programmes. Ceux-ci sont formés de suites d’instructions rangées en mémoire dans
le segment de code. Un appel à un sous-programme revient à exécuter une instruction particulière, généralement représentée par le mnémonique CALL admettant comme opérande
le point d’entrée du sous-programme appelé, c’est-à-dire l’adresse effective (ou offset) de
la première instruction de celui-ci) :
CALL offset
L’offset peut parfois être spécifié selon différents modes d’adressage, mais le plus souvent il
s’agit d’une valeur immédiate constituant le point d’entrée du sous-programme, représenté
symboliquement par un label (ou étiquette) qui est une chaı̂ne de caractères indiquant le
nom du sous-programme. Un sous programme se termine nécessairement par une instruction de retour au programme appelant, cette instruction est le plus souvent représentée
par le mnémonique RET. Les appels aux sous-programmes peuvent être imbriqués comme
le montre la figure 3.21.
1ère année Génie Électrique

J. Haggège

36

Chapitre 3. Structure et fonctionnement d’un processeur

Lors de l’appel à un sous-programme à l’aide de l’instruction CALL, le compteur programme du processeur est chargé avec l’adresse du point d’entrée du sous-programme
appelé. Par conséquent, l’instruction exécutée immédiatement après CALL est la première
instruction de ce sous-programme. Lorsque celui-ci s’achève sur l’instruction RET, le compteur programme doit être rechargé avec l’adresse de l’instruction suivant immédiatement
l’instruction CALL, appelée adresse de retour au programme appelant. Ceci n’est possible
qu’à condition que cette adresse de retour ait été sauvegardée préalablement au chargement du compteur programme avec l’adresse du sous-programme. Cette sauvegarde est
réalisée en utilisant la pile qui est un segment de mémoire dont la structure est représentée
sur la figure 3.22.
PILE
début de
la pile

SP
pointeur
de pile

sens
d'accroissement
de la pile
dernière donnée empilée

sommet
de la pile

taille de la pile

adresses
croissantes

fin de
la pile

Figure 3.22 – Structure de la pile
L’emplacement et la taille de la pile sont fixés dans la mémoire centrale. Le rangement
et la lecture des données qui y sont enregistrées se fait selon le mode « Last In First
Out » : toute nouvelle donnée est placée au sommet de la pile (Top of Stack) lors d’une
opération d’empilage tandis que seule la donnée se trouvant au sommet de la pile peut
être lue lors du dépilage. L’adresse du sommet de la pile est contenue dans un registre
du processeur appelé pointeur de pile (SP : Stack Pointer). Les deux opérations possibles
avec la pile sont généralement notées PUSH (empiler) et POP (dépiler), le pointeur de pile
étant automatiquement actualisé lors de l’exécution de ces instructions.
Lorsque la pile est vide, le registre SP contient l’adresse du début de la pile (Start of
Stack), puis il est décrémenté ou incrémenté selon l’opération effectuée sur la pile. De
cette manière, le pointeur de pile SP contient l’adresse de la première case mémoire vide
située après la dernière donnée empilée, bien que pour certains processeurs, le pointeur de
pile peut contenir l’adresse de la case mémoire où a été empilée la dernière donnée. Dans
tous les cas, il convient de veiller, lors d’empilages successifs, que la valeur du pointeur
de pile ne dépasse jamais l’adresse de la fin de la pile (End of Stack), ce qui conduirait à
une situation connue sous le nom de « débordement de pile » (Stack Overflow).
Le plus souvent, la pile s’accroı̂t dans le sens des adresses décroissantes (comme représenté
sur le schéma de la figure 3.22). Dans ce cas, le pointeur de pile est décrémenté après
Microprocesseurs et Microcontrôleurs

ENIT 2016

3.6. Exécution d’un programme en mémoire centrale

37

l’empilage d’une donnée :

PUSH src ⇔

M EM [SP ] ← src
SP ← SP − n

et il est incrémenté avant son dépilage :

SP ← SP + n
POP dst ⇔
dst ← M EM [SP ]
Dans ces deux instructions, src et dst désignent respectivement l’opérande source à empiler
et l’opérande destination dans lequel le sommet de la pile est dépilé, tandis que n est la
taille de ces opérandes (un, deux ou quatre octets en général). Là encore, différents modes
d’adressages sont souvent autorisés.
Concernant l’appel à des sous-programmes, l’instruction CALL utilise la pile pour sauvegarder l’adresse de retour, par conséquent une telle instruction peut être décomposée de
la façon suivante :

 M EM [SP ] ← P C
SP ← SP − n
CALL offset ⇔

P C ← offset
L’instruction RET se traduit, quant à elle, de la manière suivante :

SP ← SP + n
RET ⇔
P C ← M EM [SP ]
Cette technique permet de réaliser des appels imbriqués de sous-programmes, le nombre
de tels appels n’étant limité que par la taille de la zone mémoire allouée à la pile.
Il est à noter que lors de l’appel à un sous-programme, le seul registre à être automatiquement sauvegardé sur la pile est le compteur programme. Toutefois, d’autres registres
peuvent être explicitement sauvegardés puis restaurés de cette manière. Il s’agit en général de registres de travail utilisés à la fois par le programme appelant et par le sousprogramme. Cette opération, lorsqu’elle est réalisée, est appelée « sauvegarde/restauration
du contexte » du programme appelant.
Un autre usage de la pile est fait par le programme appelant : il s’agit du passage
de paramètres au sous-programme. Ces paramètres représentent les arguments du sousprogramme, ils sont empilés avant l’appel afin que le sous programme puisse y accéder au
moyen d’un adressage basé sur le sommet de la pile.

3.6.3

Interruptions et exceptions

Une interruption est un saut effectué par le programme principal en cours d’exécution vers
un sous-programme appelé « routine de service de l’interruption » (ISR : Interrupt Service
Routine). Dans ce cas, le saut est causé par un évènement externe au lieu d’être effectué
à la suite d’une instruction CALL rencontrée par le processeur au cours de l’exécution du
programme.
Les évènements sont des signaux pouvant être activés par des périphériques afin d’indiquer
qu’ils se trouvent dans un état donné, requérant un traitement de la part du processeur,
1ère année Génie Électrique

J. Haggège

38

Chapitre 3. Structure et fonctionnement d’un processeur

comme par exemple un changement d’état sur une ligne d’entrée/sortie, la fin d’une opération de transfert de données ou bien la remise à zéro d’un compteur. Les exceptions
sont un type particulier d’interruptions provoquées par une cause interne au processeur,
généralement un défaut tel qu’une erreur d’accès à la mémoire, une division par zéro ou
encore une tentative d’exécuter une instruction non reconnue.
Étant donné que l’occurrence d’une interruption ou d’une exception ne peut pas être prévue à l’avance dans le programme, un appel à une routine de service d’interruption est
dit asynchrone, par opposition à un appel de sous-programme au moyen d’une instruction
CALL qui constitue un appel synchrone. Ainsi, lorsqu’une demande d’interruption est détectée par l’unité de contrôle, l’instruction en cours se termine, puis c’est une instruction
spéciale, généralement symbolisée par le mnémonique INT qui est exécutée. Une telle instruction est similaire à CALL, à la différence que d’autres registres du processeur peuvent
être automatiquement sauvegardés sur la pile avant le chargement de l’adresse de l’ISR
dans le compteur programme. Le registre des indicateurs (flags) figure souvent parmi
les registres ainsi sauvegardés. L’ISR se termine par une instruction de retour propre
aux interruptions, notée par exemple IRET (Return from Interrupt) qui permet de restaurer automatiquement les registres sauvegardés par l’instruction INT. Le schéma de la
figure 3.23 illustre le mécanisme des interruptions.
mémoire

évènement

INT

ISR

ISR 0

ISR 2

ISR 1

Figure 3.23 – Principe des interruptions

table des vecteurs
d'interruptions

IRET

points d'entrée des ISR

programme
principal

routines de service
des interruptions

.
.
.

ISR n

.
.
.

ISR 2
ISR 1
ISR 0

Figure 3.24 – Table des vecteurs d’interruptions
Le point d’entrée de l’ISR est généralement fixé à une adresse donnée, c’est-à-dire que la
valeur chargée dans le compteur programme lorsqu’un périphérique effectue une requête
d’interruption (IRQ : Interrupt Request) est toujours la même. Cette adresse, appelée
« vecteur d’interruption » doit alors contenir un saut vers le point d’entrée du sousprogramme qui sera exécuté pour répondre à la requête du périphérique. Dans le cas
où plusieurs périphériques sont susceptibles d’émettre des requêtes d’interruption, chacun
d’entre eux dispose d’un indicateur (Interrupt Flag) qu’il active pour demander une interruption. Ces indicateurs seront testés dans l’ISR afin de déterminer le périphérique qui
Microprocesseurs et Microcontrôleurs

ENIT 2016


Aperçu du document cours_mp_mc.pdf - page 1/120
 
cours_mp_mc.pdf - page 3/120
cours_mp_mc.pdf - page 4/120
cours_mp_mc.pdf - page 5/120
cours_mp_mc.pdf - page 6/120
 




Télécharger le fichier (PDF)


cours_mp_mc.pdf (PDF, 2.5 Mo)

Télécharger
Formats alternatifs: ZIP



Documents similaires


coursmicrop8086y haggege chap5
cours archi 2011 chap 5 la petite machine
coursmpmc
chapitre 1
microprocesseursintel8086
cours c

Sur le même sujet..